Red de conocimiento informático - Material del sitio web - Cómo agregar servicios del sistema en Android

Cómo agregar servicios del sistema en Android

Agregue servicios del sistema a Android, tomando el servicio SurfaceComposer como ejemplo a continuación.

①Primero proporcione el archivo de interfaz ISurfaceComposer.h

//frameworks/native/include/gui/ISurfaceComposer.h

//La primera es la interfaz, la implementación de c es una función virtual

clase ISurfaceComposer: public IInterface {

public:

DECLARE_META_ INTERFACE (SurfaceComposer);

// indicadores para setTransactionState()

Enumeración {

eSynchronous = 0x01,

eAnimation = 0x02,

};

Enum {

eDisplayIdMain = 0,

}; Surface Trigger crea conexión, requiere

* permiso ACCESS_SURFACE_ FLINGER

*/

virtual splt; ISurfaceComposerClientgt; >}

② Crear BnSurfaceComposer

Para crear BnSurfaceComposer, debe anular la función onTransact de BBinder.

class BnSurfaceComposer: public BnInterfacelt;ISurfaceComposergt; {

public:

enum {

// Nota: BOOT_FINISHED debe mantener este valor , que es llamado por ActivityManagerService desde

// Java.

BOOT_FINISHED = IBinder::FIRST_CALL_TRANSACTION,

CREATE_CONNECTION,

CREATE_GRAPHIC_BUFFER_ALLOC,

CREATE_DISPLAY_EVENT_CONNECTION,

CREATE_DISPLAY,

DESTROY_ DISPLAY,

GET_BUILT_IN_DISPLAY,

SET_TRANSACTION_STATE,

AUTHENTICATE_SURFACE,

EN BLANCO,

DESBLANCO,

GET_DISPLAY_INFO,

CONNECT_DISPLAY,

CAPTURE_SCREEN,

}

estado virtual_t; onTransact(código uint32_t, const Parcel & data,

Parcel* respuesta, uint32_t flags = 0

}

③ Implementar Bpxxx

);

frameworks\native\libs\gui\ISurfaceComposer.

//Implementación de Bp, lado del agente

clase BpSurfaceComposer: public BpInterfacelt;ISurfaceComposergt;

{

público:

BpSurfaceComposer(const splt;IBindergt;amp;impl)

: BpInterfacelt;ISurfaceComposergt;(impl)

{

}

// Interfaz proxy

virtual splt; ISurfaceComposerClientgt; createConnection()

{

uint32_t n;

Datos de parcela, respuesta

data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

remoto()-gt; : CREATE_CONNECTION, datos, respuesta;

return interface_castlt; ISurfaceComposerClientgt; (reply.readStrongBinder());

④ Implementación de Bnxxx

//Lado Bn, es decir, lado del servidor

status_t BnSurfaceComposer::onTransact(

código uint32_t, const Parcelamp; datos , Parcel* respuesta, uint32_ t flags)

{

cambiar(código) {

caso CREATE_CONNECTION: {

CHECK_INTERFACE(ISurfaceComposer, datos, respuesta);

// crearConexión Es una implementación del lado del servidor

splt; b = createConnection()-gt; asBinder()

writeStrongBinder(b);

return NO_ERROR;

}

Valor predeterminado: {

return BBinder:: onTransact(código, datos, respuesta, banderas

);

}

}

}

// No debería ser accesible

return NO_ERROR;

}

⑤ Registrar servicio

A través de los pasos anteriores, hemos completado la creación del servicio y ahora necesitamos registrar el servicio con el administrador de servicios.

clase SurfaceFlinger: público BnSurfaceComposer,

// En frameworks\native/services\surfaceflinger\main_surfaceflinger.cpp,

// publicar Surfaceflinger.cpp.p >

// Liberar deflector de superficie

splt; ()), flinger, false);

vi usa el servicio

// Primero obtenga el BpSurfaceComposer del lado del agente

splt;ISurfaceComposer?gt; (ComposerService: :gt; compositor(ComposerService::getComposerService());

//Invocar la interfaz del proxy BpSurfaceComposer directamente

splt;IGraphicBufferAllocgt ; alloc( compositor-gt; createGraphicBufferAlloc());

donde getComposerService() se implementa como,

/*static*/ splt;ISurfaceComposergt;

ComposerServiceamp; instancia = ComposerService::getInstance();

Mutex::Autolock _l( instancia.mLock);

if (instance.mComposerService == NULL) {

ComposerService:: getInstance().connectLocked();

afirmar( instancia.mComposerService ! = NULL

ALOGD("ComposerService reconectado); ");

}

return instancia.mComposerService;

}

void ComposerService::connectLocked() {

const String16 name("SurfaceFlinger");

//Obtiene el servicio y devuelve mComposerService como BpSurfaceComposer, con Bp puedes llamar a la interfaz proxy directamente

<

p> while (getService(nombre, amp; mComposerService) != NO_ERROR) {

usleep(250000

}

afirmar(mComposerService! = NULL); );

// Crea el detector de muerte.

class DeathObserver: public IBinder::DeathRecipient {

ComposerServiceamp.mComposerService;

virtual void binderDied(const wplt;IBindergt;amp; who) {

ALOGW("ComposerService remoto (surfaceflinger) murió [p]",

who.unsafe_get());

mComposerService.composerServiceDied();

}

público:

DeathObserver( ComposerServiceamp; mgr): mComposerService(mgr) { }

};

mDeathObserver = new DeathObserver(*const_castlt; ComposerService*gt; (esto));

mComposerService-gt; asBinder()-gt; (mDeathObserver);

}

Adición de servicios JAVA

Para comodidad de los desarrolladores, Android proporciona herramientas AIDL para simplificar la dificultad de escribir servicios. El siguiente es un ejemplo de cómo agregar TestService como servicio

① Escriba un archivo AIDL

paquete android.app;

interfaz ITestService {

boolean enableWifi(boolean enable);

}

El archivo AIDL de TestService proporciona una interfaz enableWifi().

② Cree el servicio TestService

El servicio TestService debe heredar la clase ITestService.Stub, que se genera procesando el archivo AIDL ① con la herramienta AIDL

<. p>class TestService extiende ITestService.Stub {

//Implementar la interfaz

public boolean enableWifi(boolean enable)

{

..... .

}

}

③ Agregue la cadena de nombre del servicio en Context.java

// Agregar Context.java Cadena de nombre de servicio

④ Agregar cadena de nombre de servicio en Context.java