Obtenga el objeto proxy del servidor a través del método bindService y luego llame al método definido en el archivo aidl. El proceso esencial es la transferencia del objeto vinculante, y el objeto vinculante del servidor se pasa al cliente a través de AMS
lado del servidor
MathService.aidl
paquete com.sunday.aidl;
Interfaz IMathService
{
añadir largo (largo a, largo b);
}
El archivo IMathService.java se generará automáticamente en el directorio gen
MathService .java
paquete com.sunday.aidl;
importar android.app.Service;
importar android.content.Intent;
importar android.os.IBinder;
público de clase MathService extiende Servicio
{
público de clase MathServiceImpl extiende IMathService.Stub
{
@Anular
public long add ( larga a, larga b)
{
return a + b;
}
}
@Anular
public IBinder onBind (Intención)
{
return new MathServiceImpl ();
}
}
Agregar registro de servicio en AndroidManifest.xml
lado del cliente
MainActivity .java
La clase pública MainActivity extiende ActionBarActivity implementa OnClickListener {
privada myConnection serviceConnection = nueva myConnection ();
privado IMathService myService = null ;
público de clase MyConnection implementos ServiceConnection
{
@Anular
public void onServiceConnected (nombre ComponentName, servicio IBinder)
{
myService = IMathService.Stub. asInterface (servicio);
}
@Anular
public void onServiceDisconnected (nombre de ComponentName)
{
}
}
@Anular
public void onClick (Ver vista)
{
prueba {
long ret = myService .add (2017, 1);
Tostada. makeText ( esto ,
"El resultado es" + ret, Toast. LENGTH_LONG ) .show ();
} captura (Excepción e) {
// TODO : manejar excepción
}
}
@Anular
protected void onCreate (Bundle SavedInstanceState) {
super .onCreate (SavedInstanceState);
setContentView (R.layout. activity_main );
bindService ( new Intent ( "com.sunday.aidl.IMathService" ),
serviceConnection , BIND_AUTO_CREATE );
Botón aButton = (Botón) findViewById (R.id. Button1 );
aButton.setOnClickListener ( esto );
}
Ver proceso
1 | Desconocido: / # ps | grep aidl
u0_a103 28072608 1771868 71060 SyS_epoll_ 792c011794 S com.example.aidlclient
u0_a102 28108608 1715168 46232 SyS_epoll_ 792c011794 S com.sunday.aidl
Cada paso es una llamada de comunicación vinculante
Teoría de la consagración
Estudie el procesamiento de bindService y verifique la teoría de apertura
El servidor obtiene el objeto IBinder del servicio de usuario, y luego lo devuelve al cliente para su uso. El cliente puede usarlo. Esta es la entrega del objeto IBinder.
myServer.cpp
#include <stdio.h>
#include <binder / IInterface.h>
#include <binder / Parcel.h>
#include <binder / IBinder.h>
#include <binder / Binder.h>
#include <binder / ProcessState.h>
#include <binder / IPCThreadState.h>
#include <binder / IServiceManager.h>
usando el espacio de nombres de Android;
//
sp <IBinder> aBinder = NULL;
clase myBinder: BBinder público
{
público:
volcado de status_t (int fd, const Vector <String16> & args)
{
write (fd, "myBinder dump llamado", 22);
return NO_ERROR;
}
status_t onTransact (
uint32_t código, const Parcela y datos, Parcel * respuesta, uint32_t / * banderas * /
{
cambiar (código) {
caso DUMP_TRANSACTION: {
printf ("volcado llamado \ n");
int fd = data.readFileDescriptor ();
int argc = data.readInt32 ();
Vector <String16> args;
para (int i = 0; i <argc && data.dataAvail ()> 0; i ++) {
args.add (data.readString16 ());
}
return dump (fd, args);
}
caso 2: {
int num = data.readInt32 ();
printf ("onTransact llamado, caso 2, num =% d \ n", num);
responder-> writeInt32 (num * 2);
return NO_ERROR;
}
caso 3: {
printf ("onTransact llamado, caso 3 \ n");
responder-> writeStrongBinder (aBinder);
return NO_ERROR;
}
}
return NO_ERROR;
}
};
int main ()
{
sp <ProcessState> proc (ProcessState :: self ());
sp <IServiceManager> sm = defaultServiceManager ();
// obtener servicio
sp <IBinder> service = sm-> checkService (String16 ("usuario"));
if (service! = NULL) {
printf ("obtener servicio \ n");
de ahí = servicio;
}
sm-> addService (String16 ("myService"), new myBinder ());
printf ("agregar myService \ n");
ProcessState :: self () -> startThreadPool ();
IPCThreadState :: self () -> joinThreadPool ();
return 0;
}
myClient.cpp
#include <binder / Parcel.h>
#include <binder / ProcessState.h>
#include <binder / IServiceManager.h>
#include <binder / TextOutput.h>
#include <utils / Vector.h>
#include <binder / BpBinder.h> //
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
usando el espacio de nombres de Android;
int main (int argc, char * const argv [])
{
sp <IServiceManager> sm = defaultServiceManager ();
fflush (salida estándar);
si (sm == NULL)
{
ALOGE ("¡No se puede obtener el administrador de servicios predeterminado!");
aerr << "dumpsys: ¡No se puede obtener el administrador de servicios predeterminado!" << endl;
return 20;
}
Vector <String16> args;
sp <IBinder> service = sm-> checkService (String16 ("myService"));
int err = service-> dump (STDOUT_FILENO, args);
si (err! = 0) {
aerr << "Error al volcar la información del servicio: (" << strerror (err)
<< ")" << endl;
}
si (argc <= 1)
{
// printf ("argc <= 1 \ n");
return 1;
}
int num = atoi (argv [1]);
printf ("num =% d \ n", num);
Datos de parcela;
Respuesta de paquete;
data.writeInt32 (num);
err = servicio-> transacción (3, datos y respuesta, 0);
si (err == NO_ERROR)
{
// responder.setDataPosition (0);
printf ("\ nobtener respuesta \ n");
sp <IBinder> sBinder = reply.readStrongBinder ();
// Se llamará al método de volcado del servicio de usuario
sBinder-> dump (STDOUT_FILENO, args);
}
return 0;
}
Android.mk
LOCAL_PATH: = $ (llamar a mi-dir)
incluir $ (CLEAR_VARS)
LOCAL_SRC_FILES: = \
myServer.cpp
LIBRERÍAS_COMPARTIDAS_LOCALES: = \
libbase \
libutils \
liblog \
libbinder
ifeq ($ (TARGET_OS), linux)
LOCAL_CFLAGS + = -DXP_UNIX
#LOCAL_SHARED_LIBRARIES + = librt
terminara si
LOCAL_MODULE: = bServer
incluir $ (BUILD_EXECUTABLE)
incluir $ (CLEAR_VARS)
LOCAL_SRC_FILES: = \
myClient.cpp
LIBRERÍAS_COMPARTIDAS_LOCALES: = \
libbase \
libutils \
liblog \
libbinder
ifeq ($ (TARGET_OS), linux)
LOCAL_CFLAGS + = -DXP_UNIX
#LOCAL_SHARED_LIBRARIES + = librt
terminara si
LOCAL_MODULE: = bClient
incluir $ (BUILD_EXECUTABLE)
prueba
Desconocido: / data / local / tmp # ./bServer
obtener servicio
agregar myService
volcado llamado
onTransact llamado, caso 3
Desconocido: / data / local / tmp # ./bClient 0
volcado myBinder llamado num = 0
obtener respuesta
Usuarios:
UserInfo {0: null: 13} serialNo = 0
Creado: <desconocido>
Último inicio de sesión: Hace + 13d1h6m53s828ms
Se ejecuta el método de volcado del servicio de usuario.