Introducción a esta sección:
En esta sección, continuamos estudiando el componente Service (servicio). Aprenderemos algunos conceptos sobre la comunicación entre procesos mediante AIDL en Android. No profundizaremos en el nivel del código fuente; por ahora basta con saber qué es y saber usarlo. ¡Comencemos con el contenido de esta sección! Documentación oficial correspondiente a esta sección:Binder
1. Primer acercamiento al mecanismo Binder
1) ¿Qué diablos son IBinder y Binder?
Veamos qué dice la documentación oficial:

Traducción:
IBinder es la interfaz básica de los objetos remotos y es la parte central de un mecanismo ligero de invocación remota diseñado para alto rendimiento. Pero no solo se utiliza para la invocación remota, sino también para la invocación dentro del proceso. Esta interfaz define el protocolo de interacción con objetos remotos. Pero no implementes esta interfaz directamente, sino queheredar(extends)Binder。
La API principal de IBinder estransact(), y la API correspondiente esBinder.onTransact(). Mediante la primera, puedes enviar llamadas a objetos IBinder remotos; la segunda permite que tu objeto remoto responda a las llamadas recibidas. Las APIs de IBinder se ejecutan de formaSyncronous (síncrona), por ejemplo,transact()hasta que laBinder.onTransact()llamada al método del otro lado haya terminadoIPCantes de retornar.
Mediantetransact()los datos enviados sonParcelun Parcel. Parcel es un búfer general que, además de datos, contiene metadatos que describen su contenido.
El sistema mantiene un grupo de hilos de interacción para cada proceso. Estos hilos de interacción se utilizan para despachar todas las llamadas IPC provenientes de otros procesos. Por ejemplo, cuando se envía una IPC desde el proceso A al proceso B, el hilo que emitió la llamada en A (que probablemente no esté en el grupo de hilos) se bloquea entransact()transact(). Un hilo del grupo de hilos de interacción del proceso B recibe esta llamada e invocaBinder.onTransact()Binder.onTransact(). Una vez completada, devuelve el resultado usando un Parcel. Luego, el hilo en espera en el proceso A continúa su ejecución tras recibir el Parcel resultante. De hecho, el otro proceso parece ser un hilo del proceso actual, aunque no fue creado por el proceso actual.
El mecanismo Binder también admite llamadas recursivas entre procesos. Por ejemplo, el proceso A ejecuta el transact() de su propio IBinder para llamar al Binder del proceso B, y el proceso B, dentro de su Binder.onTransact(), usa transact() para realizar una llamada al proceso A; entonces el proceso A, mientras espera el retorno de la llamada que emitió, también responderá al transact() del proceso B usando Binder.onTransact(). En resumen, el resultado del Binder es hacernos sentir que las llamadas entre procesos no son diferentes de las llamadas dentro de un mismo proceso.
Cuando operas con objetos remotos, a menudo necesitas comprobar si siguen siendo válidos. Hay tres métodos que puedes usar:
- 1) El método transact() lanzará una excepción RemoteException cuando el proceso donde reside el IBinder no exista.
- 2) Si el proceso de destino no existe, pingBinder() devolverá false al ser llamado.
- 3) Puedes usar el método linkToDeath() para registrar un IBinder.DeathRecipient en el IBinder; este será llamado cuando el proceso representado por el IBinder salga.
PD: La traducción al chino está extraída de:Desarrollo de Android: ¿Qué es IBinder?
Bien, probablemente después de leer todo este lío estés algo confundido. Aquí hay un breve resumen:
IBinder es una interfaz de comunicación entre procesos que Android nos proporciona, y normalmente no implementamos esta interfaz directamente, sino que implementamos la comunicación entre procesos heredando la clase Binder. ¡Es una forma de implementar IPC (comunicación entre procesos) en Android!
2) Breve análisis del mecanismo Binder
El mecanismo Binder en Android está compuesto por una serie de componentes del sistema:Client, Server, Service Manager y el controlador Binder (Binder driver)
El flujo de llamada aproximado es el siguiente. Además, Service Manager es bastante complejo, así que no lo estudiaremos en detalle aquí.

Análisis del flujo:
->Cuando el Client llama a un método de una interfaz proxy, el método de la interfaz proxy empaqueta los parámetros pasados por el Client en un objeto Parcel;
->Luego la interfaz proxy envía ese objeto Parcel al controlador Binder (Binder driver) en el kernel;
->Luego el Server lee los datos de solicitud del Binder Driver; si están dirigidos a él, desempaqueta el objeto Parcel, lo procesa y devuelve el resultado;
PD: Los métodos definidos en la interfaz proxy se corresponden uno a uno con los métodos definidos en el Server. Además, todo el proceso de llamada es síncrono, es decir, mientras el Server está procesando, el Client se bloquea (Block). Y la definición de la interfaz proxy de la que se habla aquí es la que se explicará a continuación:AIDL¡(Lenguaje de descripción de interfaces de Android)!
3) ¿Por qué Android usa el mecanismo Binder para lograr la comunicación entre procesos?
- Fiabilidad: En los dispositivos móviles, normalmente se adopta una comunicación basada en Client-Server para lograr la comunicación entre Internet y el dispositivo. Actualmente, Linux soporta IPC, incluidas las tuberías tradicionales, System V IPC, es decir, colas de mensajes/memoria compartida/semáforos, y sockets; de estos, solo los sockets admiten la comunicación Client-Server. El sistema Android proporciona a los desarrolladores una gran cantidad de interfaces funcionales para la comunicación entre procesos, como reproducción de multimedia, sensores, transmisión inalámbrica. Todas estas funciones son gestionadas por diferentes servidores. Los desarrolladores solo necesitan establecer la comunicación entre el cliente de su aplicación y el servidor para poder usar este servicio. Sin duda, si se instala un protocolo en la capa inferior para lograr la comunicación Client-Server, se aumenta la complejidad del sistema. Es difícil garantizar la fiabilidad al implementar este entorno complejo en un teléfono con recursos limitados.
- Rendimiento de transmisión: El socket se utiliza principalmente para la comunicación entre procesos a través de la red y entre procesos en la misma máquina, pero su eficiencia de transmisión es baja y su sobrecarga es alta. Las colas de mensajes y las tuberías usan el método de almacenamiento y reenvío, es decir, los datos se copian primero desde el búfer del remitente a un búfer asignado en el kernel, y luego desde el búfer del kernel al búfer del receptor; el proceso implica al menos dos copias. Aunque la memoria compartida no requiere copia, su control es complejo. Comparemos el número de copias de datos de varios métodos IPC. Memoria compartida: 0 veces. Binder: 1 vez. Socket/pipe/cola de mensajes: 2 veces.
- Seguridad: Android es una plataforma abierta, por lo que es muy importante garantizar la seguridad de las aplicaciones. Android asigna un UID/PID a cada aplicación instalada; el UID del proceso se puede usar para identificar la identidad del proceso. Tradicionalmente, solo se podía rellenar el UID/PID en el paquete de datos por parte del usuario, lo cual no es confiable y puede ser explotado fácilmente por programas maliciosos. En cambio, requerimos que el kernel agregue un UID confiable. Por lo tanto, por fiabilidad, rendimiento de transmisión y seguridad, Android estableció un nuevo método de comunicación entre procesos. — Extraído de:Comprensión breve del mecanismo Binder en Android
Por supuesto, como desarrolladores principiantes no nos preocupan estas cosas. El beneficio más directo que el mecanismo Binder nos aporta es:No necesitamos preocuparnos por cómo se implementa en el nivel inferior; solo debemos seguir las reglas de AIDL para definir un archivo de interfaz personalizado, luego llamar a los métodos de la interfaz y podremos completar la comunicación entre dos procesos.
2. Explicación detallada del uso de AIDL
1) ¿Qué es AIDL?
Jeje, antes mencionamosIPCeste término. Su nombre completo es:comunicación entre procesos (interprocess communication), debido a que en el sistema Android cada aplicación se ejecuta en su propio proceso, generalmente los procesos no pueden intercambiar datos directamente; para lograr la comunicación entre procesos, Android nos proporciona el mecanismo Binder mencionado anteriormente, y el lenguaje de interfaz que usa este mecanismo es:AIDL(Android Interface Definition Language) Su sintaxis es muy simple, y este lenguaje de interfaz no es un verdadero lenguaje de programación, solo define la interfaz de comunicación entre dos procesos. El código Java que genera el protocolo de comunicación es generado por la herramienta en el directorio platform-tools del Android SDK.aidl.exeLa herramienta genera el archivo de interfaz correspondiente en el directorio gen, generalmente una interfaz Xxx.java. Y en esa interfaz se incluye unStubclase interna, en la cual se implementaIBinderla interfaz y la interfaz de comunicación personalizada. Esta clase actuará como la clase de devolución de llamada del Service remoto: implementa la interfaz IBinder, por lo que puede usarse como valor de retorno del método onBind() del Service.
2) AIDL para implementar una comunicación simple entre dos procesos
Antes de empezar a escribir el archivo de interfaz AIDL, necesitamos conocer algunas consideraciones al escribir AIDL:
Consideraciones sobre AIDL:
- El nombre de la interfaz debe ser el mismo que el nombre del archivo aidl
- Ante la interfaz y los métodosno agregues modificadores de acceso: public, private, protected, etc., tampoco se puede usar static final!
- Los tipos que AIDL soporta por defecto incluyentipos básicos de Java,String,List,Map,CharSequenceAdemás de estos, los demás tipos requieren una declaración import. Para usar tipos personalizados como parámetros o valores de retorno, el tipo personalizado debe implementar la interfaz Parcelable. Para más detalles, consulta la sección sobre transferencia de tipos de datos complejos más adelante.
- Los tipos personalizados y otros tipos de interfaz generados por AIDL deben importarse explícitamente en el archivo descriptivo aidl, incluso si la clase y el paquete definido están en el mismo paquete.
Además, si el compilador que usas para escribir aidl es Eclipse, presta atención: no crees directamente un new file. Si lo haces, no podrás abrir el archivo y, por lo tanto, no podrás escribir código.
① Crea directamente un archivo txt, después de escribirlo guárdalo con formato .aidl y luego cópialo a la ruta correspondiente.
② Como aidl es similar a una interfaz, crea directamente una interfaz (new interface). Después de escribir el contenido, ve al directorio donde se encuentra el archivo java correspondiente y modifica la extensión del archivo.Si usas Android Studio, a diferencia de Eclipse, si creas un archivo AIDL de la misma manera que en Eclipse, descubrirás que no se genera el archivo XXX.java correspondiente. En Android Studio (AS), para crear AIDL debes crear una carpeta aidl en el directorio main, luego definir un paquete con el mismo nombre que el paquete del aidl, y finalmente crear un archivo aidl. Después presiona Ctrl+F9 para recompilar, ¡y listo!
El resultado de compilar exitosamente ambos métodos anteriores es el siguiente: puedes encontrar los archivos AIDL correspondientes en los directorios respectivos.
![]()
1. Servidor:
Step 1:Crear el archivo AIDL:
IPerson.aidl
package com.jay.aidl;
interface IPerson {
String queryPerson(int num);
}
Abrimos IPerson.java y veamos el código que contiene:
IPerson.java
/*
* This file is auto-generated. DO NOT MODIFY.
* Original file: C:\\Code\\ASCode\\AIDLServer\\app\\src\\main\\aidl\\com\\jay\\aidl\\IPerson.aidl
*/
package com.jay.aidl;
public interface IPerson extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.jay.aidl.IPerson
{
private static final java.lang.String DESCRIPTOR = "com.jay.aidl.IPerson";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.jay.aidl.IPerson interface,
* generating a proxy if needed.
*/
public static com.jay.aidl.IPerson asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.jay.aidl.IPerson))) {
return ((com.jay.aidl.IPerson)iin);
}
return new com.jay.aidl.IPerson.Stub.Proxy(obj);
}
@Override public android.os.IBinder asBinder()
{
return this;
}
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_queryPerson:
{
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
java.lang.String _result = this.queryPerson(_arg0);
reply.writeNoException();
reply.writeString(_result);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.jay.aidl.IPerson
{
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote)
{
mRemote = remote;
}
@Override public android.os.IBinder asBinder()
{
return mRemote;
}
public java.lang.String getInterfaceDescriptor()
{
return DESCRIPTOR;
}
@Override public java.lang.String queryPerson(int num) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.lang.String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(num);
mRemote.transact(Stub.TRANSACTION_queryPerson, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
}
static final int TRANSACTION_queryPerson = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
}
public java.lang.String queryPerson(int num) throws android.os.RemoteException;
}
Aquí solo nos interesan **asInterface(IBinder)** y el método **queryPerson()** de la interfaz que definimos.
Este método convierte un objeto de tipo IBinder al tipo IPerson y, cuando es necesario, genera un objeto proxy para devolver el resultado.
Podemos ignorar lo demás y saltar directamente al siguiente paso.
Paso 2: **Personaliza nuestra clase Service y realiza las siguientes operaciones:
1) Hereda de la clase Service y también define una clase PersonQueryBinder paraheredar de la clase IPerson.Stubes decir,implementa la interfaz IPerson y la interfaz IBinder
2) Instancia la clase Stub personalizada y sobrescribe el método onBind de Service, devolviendo un objeto binder.
AIDLService.java
package com.jay.aidlserver;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import com.jay.aidl.IPerson.Stub;
/**
* Created by Jay on 2015/8/18 0018.
*/
public class AIDLService extends Service {
private IBinder binder = new PersonQueryBinder();
private String[] names = {"B神","艹神","基神","J神","翔神"};
private String query(int num)
{
if(num > 0 && num < 6){
return names[num - 1];
}
return null;
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
private final class PersonQueryBinder extends Stub{
@Override
public String queryPerson(int num) throws RemoteException {
return query(num);
}
}
}
Step 3:Registra el Service en el archivo AndroidManifest.xml
<service android:name=".AIDLService">
<intent-filter>
<action android:name="android.intent.action.AIDLService" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</service>
Aquí no proporcionamos una interfaz Activity, pero el Service que ofrece la aplicación puede ser invocado por otras apps.
2. Cliente
Copia directamente el archivo aidl del servidor, luego lo completamos directamente en MainActivity. Esto es similar a la operación de enlazar un Service local.
es un poco similar, el proceso es el siguiente:
1) Define la clase PersonConnection personalizadaimplementa la interfaz ServiceConnection
2) Usa el objeto PersonConnection como parámetro y llama a bindService para enlazar el Service remoto
bindService(service,conn,BIND_AUTO_CREATE);
Nota: el tercer parámetro configura que, si el servicio no se ha iniciado, se cree automáticamente.
3) A diferencia del Service local,el ServiceConnection que enlaza el Service remoto no puede obtener directamente el método onBind() del Service
el objeto IBinder devuelto, solo puede devolveronBind( )lo que devuelve el métodoobjeto proxy, de la siguiente manera:
iPerson = IPerson.Stub.asInterface(service);
Luego completa la inicialización y los eventos de botón, y eso es todo.
El código específico es el siguiente:
MainActivity.java
package com.jay.aidlclient;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import com.jay.aidl.IPerson;
public class MainActivity extends AppCompatActivity implements View.OnClickListener{
private EditText edit_num;
private Button btn_query;
private TextView txt_name;
private IPerson iPerson;
private PersonConnection conn = new PersonConnection();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
bindViews();
//绑定远程Service
Intent service = new Intent("android.intent.action.AIDLService");
service.setPackage("com.jay.aidlserver");
bindService(service, conn, BIND_AUTO_CREATE);
btn_query.setOnClickListener(this);
}
private void bindViews() {
edit_num = (EditText) findViewById(R.id.edit_num);
btn_query = (Button) findViewById(R.id.btn_query);
txt_name = (TextView) findViewById(R.id.txt_name);
}
@Override
public void onClick(View v) {
String number = edit_num.getText().toString();
int num = Integer.valueOf(number);
try {
txt_name.setText(iPerson.queryPerson(num));
} catch (RemoteException e) {
e.printStackTrace();
}
edit_num.setText("");
}
private final class PersonConnection implements ServiceConnection {
public void onServiceConnected(ComponentName name, IBinder service) {
iPerson = IPerson.Stub.asInterface(service);
}
public void onServiceDisconnected(ComponentName name) {
iPerson = null;
}
}
}
A continuación, primero inicia AIDLServivce, luego inicia AIDLClient, ingresa el número de consulta y obtendrás el nombre correspondiente. Por supuesto, también puedes iniciar AIDLClient directamente y el efecto será el mismo:
La captura del efecto es la siguiente:

3) Servicio AIDL para transmitir datos complejos
En el ejemplo anterior, solo pasamos un parámetro de tipo int y el servidor devuelve un parámetro de tipo String, lo que parece satisfacer nuestras necesidades básicas. Pero en el desarrollo real, ¡puede que necesitemos considerar el caso de transferir tipos de datos complejos! A continuación, aprendamos cómo transferir datos de tipos complejos al servidor. Antes de empezar, primero entendamosla interfaz Parcelable!
——Introducción a la interfaz Parcelable:
Creo que quienes han usado serialización básicamente conocen esta interfaz. Además, existe otra, Serializable, que también se usa para serialización, solo que Parcelable es más ligera y más rápida. Pero escribirla es un poco complicado. Por supuesto, si usas Android Studio, puedes usar el plugin para completar la serialización, por ejemplo:Android Parcelable Code GeneratorPor supuesto, aquí te enseñaremos paso a paso a implementar esta interfaz.
Primeronecesitas implementar:writeToParcelyreadFromPacelmétodos. El método de escritura escribe el objeto en el Parcel, y el método de lectura lee el objeto desde el Parcel. Ten en cuenta que el orden de escritura de las propiedades debe ser el mismo que el orden de lectura.
Luegoes necesario agregar en la clase un atributo llamadoCREATORdestatic finalatributo. Este atributo debe implementar: android.os.Parcelable.Creator
Despuésnecesitas sobrescribir dos métodos de la interfaz:createFromParcelmétodo (Parcel source): implementa la función de crear una instancia de JavaBean a partir de source.newArraymétodo (int size): crea un array de tipo T y tamaño size, solo tiene un simple return new T[size]; (aquí T es la clase Person).
Finalmente, describeContents(): No sé para qué sirve esto, simplemente devuelve 0. No le prestes atención.
——Además,En los tipos no primitivos,exceptoStringyCharSequencetodos los demás necesitan unindicador de dirección.Los indicadores de dirección incluyen inin、out、y inout. in significa que lo establece el cliente, out significa que lo establece el servidor, e inout significa que tanto el cliente como el servidor establecen ese valor.
Bien, continuemos escribiendo código para probar. (En Android Studio hay un pequeño problema con los tipos personalizados que aún no se ha resuelto, así que vuelvo a usar Eclipse~):
Ejemplo de código:
Define dos tipos de objetos personalizados: Person y Salary. Person se usa como parámetro para llamar al Service remoto, y Salary como valor de retorno. Entonces, lo primero que hay que hacer es crear las clases Person y Salary, y también implementar la interfaz Parcelable.
1.——Servidor
Step 1: Crea los archivos Person.aidl y Salary.aidl. Como necesitan implementar la interfaz Parcelable, solo contiene la siguiente declaración:
Person.aidl: parcelable Person; Salary.aidl: parcelable Salary;Step 2: Crea las clases Person y Salary respectivamente. Deben implementar la interfaz Parcelable y sobrescribir los métodos correspondientes.
Nota: como más adelante obtenemos los datos del Map basándonos en el objeto Person, en Person.java sobrescribimos los métodos hashCode y equals; la clase Salary no los necesita.
Person.java:
package com.jay.example.aidl;
import android.os.Parcel;
import android.os.Parcelable;
/**
* Created by Jay on 2015/8/18 0018.
*/
public class Person implements Parcelable{
private Integer id;
private String name;
public Person() {}
public Person(Integer id, String name) {
this.id = id;
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
//实现Parcelable必须实现的方法,不知道拿来干嘛的,直接返回0就行了
@Override
public int describeContents() {
return 0;
}
//写入数据到Parcel中的方法
@Override
public void writeToParcel(Parcel dest, int flags) {
//把对象所包含的数据写入到parcel中
dest.writeInt(id);
dest.writeString(name);
}
//必须提供一个名为CREATOR的static final属性 该属性需要实现
//android.os.Parcelable.Creator<T>接口
public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {
//从Parcel中读取数据,返回Person对象
@Override
public Person createFromParcel(Parcel source) {
return new Person(source.readInt(),source.readString());
}
@Override
public Person[] newArray(int size) {
return new Person[size];
}
};
//因为我们集合取出元素的时候是根据Person对象来取得,所以比较麻烦,
//需要我们重写hashCode()和equals()方法
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj)
{
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (name == null)
{
if (other.name != null)
return false;
}
else if (!name.equals(other.name))
return false;
return true;
}
}
<pre><p><strong>Salary.java</strong>~照葫芦画瓢</p>
<pre>
package com.jay.example.aidl;
import android.os.Parcel;
import android.os.Parcelable;
/**
* Created by Jay on 2015/8/18 0018.
*/
public class Salary implements Parcelable {
private String type;
private Integer salary;
public Salary() {
}
public Salary(String type, Integer salary) {
this.type = type;
this.salary = salary;
}
public String getType() {
return type;
}
public Integer getSalary() {
return salary;
}
public void setType(String type) {
this.type = type;
}
public void setSalary(Integer salary) {
this.salary = salary;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(type);
dest.writeInt(salary);
}
public static final Parcelable.Creator<Salary> CREATOR = new Parcelable.Creator<Salary>() {
//从Parcel中读取数据,返回Person对象
@Override
public Salary createFromParcel(Parcel source) {
return new Salary(source.readString(), source.readInt());
}
@Override
public Salary[] newArray(int size) {
return new Salary[size];
}
};
public String toString() {
return "工作:" + type + " 薪水: " + salary;
}
}
Step 3: Crea un archivo ISalary.aidl y escribe en él un método simple para obtener la información salarial:
package com.jay.example.aidl;
import com.jay.example.aidl.Salary;
import com.jay.example.aidl.Person;
interface ISalary
{
//定义一个Person对象作为传入参数
//接口中定义方法时,需要制定新参的传递模式,这里是传入,所以前面有一个in
Salary getMsg(in Person owner);
}
ps:Recuerda que si se usan tipos de datos personalizados, necesitas importarlos. ¡¡¡Recuerda esto!!!
Step 4:Escritura del Service central: Define una clase SalaryBinder que herede de Stub, implementando así las interfaces ISalary e IBinder; define una colección Map para almacenar información; sobrescribe el método onBind y devuelve una instancia de la clase SalaryBinder.
AidlService.java
package com.jay.example.aidl_complexservice;
import java.util.HashMap;
import java.util.Map;
import com.jay.example.aidl.ISalary.Stub;
import com.jay.example.aidl.Person;
import com.jay.example.aidl.Salary;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
public class AidlService extends Service {
private SalaryBinder salaryBinder;
private static Map<Person,Salary> ss = new HashMap<Person, Salary>();
//初始化Map集合,这里在静态代码块中进行初始化,当然你可也以在构造方法中完成初始化
static
{
ss.put(new Person(1, "Jay"), new Salary("码农", 2000));
ss.put(new Person(2, "GEM"), new Salary("歌手", 20000));
ss.put(new Person(3, "XM"), new Salary("学生", 20));
ss.put(new Person(4, "MrWang"), new Salary("老师", 2000));
}
@Override
public void onCreate() {
super.onCreate();
salaryBinder = new SalaryBinder();
}
@Override
public IBinder onBind(Intent intent) {
return salaryBinder;
}
//同样是继承Stub,即同时实现ISalary接口和IBinder接口
public class SalaryBinder extends Stub
{
@Override
public Salary getMsg(Person owner) throws RemoteException {
return ss.get(owner);
}
}
@Override
public void onDestroy() {
System.out.println("服务结束!");
super.onDestroy();
}
}
Registra el Service:
<service android:name=".AidlService">
<intent-filter>
<action android:name="android.intent.action.AIDLService" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</service>
2——Escritura del cliente
Step 1:Copia el archivo AIDL del servidor; después de copiarlo, el directorio queda así:

Step 2: Escribe un diseño simple, luego viene la implementación de la MainActivity principal. Define un objeto ServciceConnection, sobrescribe los métodos correspondientes, similar a los datos normales anteriores. Luego llama a bindService, y después en el evento de clic del Button obtén el objeto Salary y muéstralo.
MainActivity.java
package com.jay.example.aidl_complexclient;
import com.jay.example.aidl.ISalary;
import com.jay.example.aidl.Person;
import com.jay.example.aidl.Salary;
import android.app.Activity;
import android.app.Service;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
public class MainActivity extends Activity {
private ISalary salaryService;
private Button btnquery;
private EditText editname;
private TextView textshow;
private ServiceConnection conn = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
salaryService = null;
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//返回的是代理对象,要调用这个方法哦!
salaryService = ISalary.Stub.asInterface(service);
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnquery = (Button) findViewById(R.id.btnquery);
editname = (EditText) findViewById(R.id.editname);
textshow = (TextView) findViewById(R.id.textshow);
Intent it = new Intent();
it.setAction("com.jay.aidl.AIDL_SERVICE");
bindService(it, conn, Service.BIND_AUTO_CREATE);
btnquery.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
try
{
String name = editname.getText().toString();
Salary salary = salaryService.getMsg(new Person(1,name));
textshow.setText(name + salary.toString());
}catch(RemoteException e){e.printStackTrace();}
}
});
}
@Override
protected void onDestroy() {
super.onDestroy();
this.unbindService(conn);
}
}
Captura de ejecución:

PS:El código aquí fue escrito anteriormente con Eclipse. En Android Studio hay un problema con los tipos personalizados.
Todavía no he encontrado una solución. Si algún amigo lo sabe, por favor hágamelo saber. ¡¡¡Muy agradecido!!!
El problema que aparece es el siguiente:
Descarga del código de los dos ejemplos (basado en Eclipse):
1)Usar AIDL para completar una comunicación simple entre procesos
2)Implementación de un Service AIDL que transmite datos complejos
3. Completar la comunicación entre procesos directamente mediante onTransact de Binder
Arriba se mencionó que Android puede completar la comunicación mediante el método onTrensact de Binder. A continuación lo probaremos brevemente; sigue siendo el ejemplo anterior de consultar el nombre según el número de serie:
Implementación del servidor:
/**
* Created by Jay on 2015/8/18 0018.
*/
public class IPCService extends Service{
private static final String DESCRIPTOR = "IPCService";
private final String[] names = {"B神","艹神","基神","J神","翔神"};
private MyBinder mBinder = new MyBinder();
private class MyBinder extends Binder {
@Override
protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
switch (code){
case 0x001: {
data.enforceInterface(DESCRIPTOR);
int num = data.readInt();
reply.writeNoException();
reply.writeString(names[num]);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
}
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
}
Implementación del cliente:
public class MainActivity extends AppCompatActivity implements View.OnClickListener{
private EditText edit_num;
private Button btn_query;
private TextView txt_result;
private IBinder mIBinder;
private ServiceConnection PersonConnection = new ServiceConnection()
{
@Override
public void onServiceDisconnected(ComponentName name)
{
mIBinder = null;
}
@Override
public void onServiceConnected(ComponentName name, IBinder service)
{
mIBinder = service;
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
bindViews();
//绑定远程Service
Intent service = new Intent("android.intent.action.IPCService");
service.setPackage("com.jay.ipcserver");
bindService(service, PersonConnection, BIND_AUTO_CREATE);
btn_query.setOnClickListener(this);
}
private void bindViews() {
edit_num = (EditText) findViewById(R.id.edit_num);
btn_query = (Button) findViewById(R.id.btn_query);
txt_result = (TextView) findViewById(R.id.txt_result);
}
@Override
public void onClick(View v) {
int num = Integer.parseInt(edit_num.getText().toString());
if (mIBinder == null)
{
Toast.makeText(this, "未连接服务端或服务端被异常杀死", Toast.LENGTH_SHORT).show();
} else {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
String _result = null;
try{
_data.writeInterfaceToken("IPCService");
_data.writeInt(num);
mIBinder.transact(0x001, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
txt_result.setText(_result);
edit_num.setText("");
}catch (RemoteException e)
{
e.printStackTrace();
} finally
{
_reply.recycle();
_data.recycle();
}
}
}
}
Captura de ejecución:

El código es bastante simple, no explicaré mucho. ¡Úsalo y modifícalo tú mismo!PS: Referencia del código:Análisis breve del framework Binder de Android AIDL
4. Algunos aspectos a tener en cuenta sobre Service después de Android 5.0:
Hoy, al iniciar el Service de forma implícita, me encontré con este problema
Luego el programa se bloqueó al iniciar. Después de pensarlo mucho, descubrí que era culpa de Android 5.0. Resulta que después de 5.0 hay una nueva característica, que es:Service Intent must be explitict!Bien, simplemente no se puede iniciar un Service de forma implícita. La solución también es muy simple. Por ejemplo, para StartService:
startService(new Intent(getApplicationContext(), "com.aaa.xxxserver"));Escribir el programa así hace que se bloquee directamente; hay que escribirlo de la siguiente manera:startService(new Intent(getApplicationContext(), LoadContactsService.class));
Si es para BindService:Intent service = new Intent("android.intent.action.AIDLService");Sobre esa base, hay que añadir el nombre del paquete:service.setPackage("com.jay.ipcserver");Así ya funciona~
Documentación oficial:http://developer.android.com/intl/zh-cn/guide/components/intents-filters.html#TypesNota de la documentación:
Resumen de esta sección:
Bien, la última sección sobre Service termina aquí. En esta sección se explicaron los conceptos básicos de Binder y las dos formas de implementar la comunicación entre procesos: mediante AIDL y mediante Binder.onTransact() para lograr la comunicación entre procesos. Finalmente, también se explicaron las precauciones de no poder iniciar Service implícitamente después de Android 5.0. Llegamos al final, ¡gracias~


Luego el programa se bloqueó al iniciar. Después de pensarlo mucho, descubrí que era culpa de Android 5.0.
Resulta que después de 5.0 hay una nueva característica, que es:Service Intent must be explitict!Bien, simplemente no se puede iniciar un Service de forma implícita. La solución también es muy simple.
Por ejemplo, para StartService: