Cómo agregar servicios del sistema en Android
①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