Introduction à cette section :

Dans cette section, nous continuons d'étudier le composant Service. Nous allons apprendre quelques concepts de la communication inter-processus AIDL sous Android. Nous n'entrerons pas dans les détails du code source ; pour l'instant, sachez simplement ce que c'est et comment l'utiliser ! Commençons le contenu de cette section. La documentation officielle correspondant à cette section :Binder


1. Premier aperçu du mécanisme Binder


1) Que diable sont IBinder et Binder ?

Voyons ce que dit la documentation officielle :

Traduction chinoise :

IBinder est l'interface de base pour les objets distants, et constitue la partie centrale d'un mécanisme léger d'invocation à distance conçu pour la haute performance. Mais il n'est pas utilisé uniquement pour les appels distants, mais aussi pour les appels intra-processus. Cette interface définit le protocole d'interaction avec les objets distants. Toutefois, n'implémentez pas directement cette interface ; à la placehérite(extends)Binder。

L'API principale d'IBinder esttransact(), et l'API correspondante estBinder.onTransact(). Grâce à la première, vous pouvez envoyer des appels à un objet IBinder distant, et la seconde permet à votre objet distant de répondre aux appels reçus. Les API d'IBinder sont toutesSynchronesexécutées, par exempletransact()jusqu'à ce que l'appel de méthodeBinder.onTransact()de l'autre partie se termine avant de retourner.IPC, grâce auquel le même effet est obtenu.

Viatransact()les données envoyées sontParcel, Parcel est un tampon polyvalent qui, en plus des données, transporte également certaines métadonnées décrivant son contenu. Les métadonnées servent à gérer les références aux objets IBinder, afin que ces références puissent être préservées lorsque le tampon est déplacé d'un processus à un autre. Cela garantit que lorsqu'un IBinder est écrit dans un Parcel et envoyé à un autre processus, si l'autre processus renvoie la référence au même IBinder au processus d'origine, alors le processus d'origine peut recevoir la référence à cet IBinder qu'il a envoyée. Ce mécanisme gère IBinder et Binder entre les processus comme des identifiants uniques.

Le système maintient un pool de threads pour chaque processus qui stocke les threads d'interaction. Ces threads d'interaction servent à répartir tous les appels IPC envoyés depuis d'autres processus. Par exemple : lorsqu'un IPC est envoyé du processus A au processus B, le thread de A qui a émis l'appel (ce thread ne doit pas être dans le pool de threads) se bloque surtransact(). Un thread du pool de threads d'interaction du processus B reçoit cet appel, et il appelleBinder.onTransact(), puis, une fois terminé, renvoie un Parcel comme résultat. Ensuite, le thread en attente du processus A peut continuer à s'exécuter après avoir reçu le Parcel renvoyé. En fait, un autre processus ressemble à un thread du processus courant, mais il n'a pas été créé par le processus courant.

Le mécanisme Binder prend également en charge les appels récursifs entre processus. Par exemple, le processus A exécute le transact() de son propre IBinder pour appeler le Binder du processus B, et le processus B, dans son Binder.onTransact(), utilise transact() pour initier un appel au processus A. Ensuite, le processus A, pendant qu'il attend le retour de l'appel qu'il a émis, utilisera aussi Binder.onTransact() pour répondre au transact() du processus B. En bref, le résultat du Binder est qu'il nous donne l'impression que les appels inter-processus ne sont pas différents des appels intra-processus.

Lorsque vous opérez sur des objets distants, vous devez souvent vérifier s'ils sont valides. Trois méthodes s'offrent à vous :

  • 1. La méthode transact() lèvera une RemoteException lorsque le processus dans lequel réside l'IBinder n'existe plus.
  • 2. Si le processus cible n'existe pas, l'appel à pingBinder() renvoie false.
  • 3. Vous pouvez utiliser la méthode linkToDeath() pour enregistrer un IBinder.DeathRecipient auprès de l'IBinder, qui est appelé lorsque le processus représenté par l'IBinder se termine.

PS : La traduction chinoise est extraite de :Développement Android : Qu'est-ce qu'IBinder

Eh bien, après avoir lu tout ce contenu, vous êtes peut-être perplexe. Voici un bref résumé :

IBinder est une interface de communication inter-processus fournie par Android, et nous n'implémentons généralement pas cette interface directement. À la place, nous implémentons la communication inter-processus en héritant de la classe Binder ! C'est l'un des moyens de mettre en œuvre l'IPC (communication inter-processus) dans Android !


2) Brève analyse du mécanisme Binder

Le mécanisme Binder d'Android se compose d'une série de composants système :Client, Serveur, Service Manager et pilote Binder

Le déroulement approximatif des appels est le suivant. De plus, Service Manager est assez complexe, nous ne l'étudierons donc pas en détail ici !

Analyse du déroulement :

->Lorsque le Client appelle une méthode dans une interface proxy, la méthode de l'interface proxy encapsule les paramètres passés par le Client dans un objet Parcel ;
->Ensuite, l'interface proxy envoie l'objet Parcel au pilote Binder dans le noyau ;;
->Ensuite, le Serveur lit les données de requête dans le pilote Binder. Si elles lui sont envoyées, il désempaquette l'objet Parcel, le traite et renvoie le résultat ;
PS : Les méthodes définies dans l'interface proxy correspondent une à une aux méthodes définies dans le Serveur. De plus, l'ensemble du processus d'appel est synchrone, c'est-à-dire que pendant que le Serveur traite, le Client sera bloqué (verrouillé) ! Et la définition de l'interface proxy mentionnée ici est ce que nous allons aborder ensuite :AIDL(Android Interface Definition Language) !


3) Pourquoi Android utilise-t-il le mécanisme Binder pour la communication entre processus ?

  1. Fiabilité: Sur les appareils mobiles, une méthode de communication basée sur Client-Serveur est généralement adoptée pour assurer la communication interne entre Internet et l'appareil. Actuellement, les IPC pris en charge par Linux comprennent les tubes traditionnels, les IPC System V, à savoir les files de messages/la mémoire partagée/les sémaphores, et les sockets. Parmi ceux-ci, seules les sockets prennent en charge la méthode de communication Client-Serveur. Le système Android fournit aux développeurs une multitude d'interfaces fonctionnelles pour la communication entre processus, telles que la lecture multimédia, les capteurs et la transmission sans fil. Ces fonctions sont gérées par différents serveurs. Les développeurs n'ont qu'à se préoccuper d'établir la communication entre le client de leur application et le serveur pour utiliser ce service. Sans aucun doute, si un ensemble de protocoles est mis en place au niveau de la couche sous-jacente pour implémenter la communication Client-Serveur, cela augmente la complexité du système. Implémenter un environnement aussi complexe sur un téléphone aux ressources limitées rend la fiabilité difficile à garantir.
  2. Performances de transmission: Socket est principalement utilisé pour la communication inter-processus à travers les réseaux et entre processus sur la même machine, mais son efficacité de transmission est faible et son surcoût élevé. Les files de messages et les tubes utilisent une méthode de stockage et de transfert, c'est-à-dire que les données sont d'abord copiées depuis le tampon de l'émetteur vers un tampon ouvert dans le noyau, puis copiées depuis le tampon du noyau vers le tampon du récepteur. Ce processus implique au moins deux copies. Bien que la mémoire partagée ne nécessite aucune copie, son contrôle est complexe. Comparez le nombre de copies de données pour diverses méthodes IPC. Mémoire partagée : 0 fois. Binder : 1 fois. Socket/tube/file de messages : 2 fois.
  3. Sécurité: Android est une plate-forme ouverte, donc garantir la sécurité des applications est très important. Android attribue un UID/PID à chaque application installée, où l'UID du processus peut être utilisé pour identifier l'identité du processus. Traditionnellement, les utilisateurs ne pouvaient remplir que l'UID/PID dans le paquet de données, ce qui n'est pas fiable et facilement exploité par des programmes malveillants. Nous demandons au noyau d'ajouter des UID fiables. Par conséquent, pour la fiabilité, les performances de transmission et la sécurité, Android a établi une nouvelle méthode de communication inter-processus. — Extrait de :Brève présentation du mécanisme Binder dans Android

Bien sûr, en tant que développeurs juniors, nous ne nous soucions pas de ce qui précède. Le bénéfice le plus direct que le mécanisme Binder nous apporte est :Nous n'avons pas besoin de nous soucier de la façon dont la couche sous-jacente est implémentée. Nous avons seulement besoin de définir un fichier d'interface selon les règles AIDL, puis appeler les méthodes de l'interface pour réaliser la communication entre deux processus !


2. Explication détaillée de l'utilisation d'AIDL


1) Qu'est-ce qu'AIDL ?

Héhé, plus tôt nous avons mentionnéIPCce terme. Son nom complet est :Communication inter-processus, Parce que dans le système Android, chaque application s'exécute dans son propre processus, et généralement les processus ne peuvent pas échanger directement des données entre eux. Pour réaliser une communication inter-processus, Android nous fournit le mécanisme Binder mentionné ci-dessus, et le langage d'interface utilisé par ce mécanisme est :AIDL(Langage de définition d'interface Android). Sa syntaxe est très simple, et ce langage d'interface n'est pas un véritable langage de programmation ; il définit seulement l'interface de communication entre deux processus ! Le code Java conforme au protocole de communication est généré par leaidl.exeoutil. Le fichier d'interface correspondant est généré dans le répertoire gen, généralement une interface comme Xxx.java ! Et cette interface contient uneStubclasse interne. Dans cette classe, elle implémenteIBinderl'interface et l'interface de communication personnalisée. Cette classe servira de classe de rappel du Service distant — elle implémente l'interface IBinder, donc elle peut être utilisée comme valeur de retour de la méthode onBind() de Service !


2) AIDL réalise une communication simple entre deux processus

Avant d'écrire des fichiers d'interface AIDL, nous devons connaître quelques points d'attention lors de l'écriture d'AIDL :

Points d'attention d'AIDL :

  • Le nom de l'interface doit être le même que le nom du fichier AIDL.
  • Devant les interfaces et les méthodes,n'ajoutez pas de modificateurs d'accès,tels que public, private, protected, etc., et ne pouvez pas utiliser static final !
  • Les types pris en charge par AIDL par défaut incluentles types primitifs Java.,String,List,Map,CharSequenceÀ part ceux-ci, tous les autres types nécessitent des déclarations d'import. Pour les types personnalisés utilisés comme paramètres ou valeurs de retour, le type personnalisé doit implémenter l'interface Parcelable. Pour plus de détails, voir la section ultérieure sur le passage de types de données complexes.
  • Les types personnalisés et les autres types d’interface générés par AIDL doivent être explicitement importés dans le fichier de description AIDL, même si ces classes se trouvent dans le même package que le package défini.

De plus, si le compilateur que vous utilisez pour écrire de l’AIDL est Eclipse, faites attention : ne créez pas directement un nouveau fichier et ne le configurez pas ! Si vous le faites, le fichier ne pourra pas être ouvert, donc vous ne pourrez pas écrire de code !
① Créez directement un nouveau fichier txt, écrivez le contenu, enregistrez-le au format .aidl, puis copiez-le vers le chemin correspondant.
② Comme AIDL est similaire à une interface, vous pouvez directement créer une nouvelle interface, écrire le contenu, puis aller dans le répertoire où se trouve le fichier Java correspondant et modifier l’extension du fichier.

Si vous utilisez Android Studio, contrairement à Eclipse, si vous créez un fichier AIDL de la même manière qu’avec Eclipse, vous constaterez que le fichier XXX.java correspondant n’est pas compilé. Pour créer un fichier AIDL dans Android Studio, vous devez créer un nouveau dossier aidl sous le répertoire main, définir un package du même nom que le package AIDL, et enfin créer un fichier aidl. Ensuite, appuyez sur ctrl + F9 pour recompiler, et c’est tout !

Les résultats d’une compilation réussie des deux méthodes ci-dessus sont les suivants ; vous pouvez trouver les fichiers AIDL correspondants dans les répertoires correspondants.


1. Côté serveur :

Étape 1 :Créer un fichier AIDL :

IPerson.aidl

package com.jay.aidl;

interface IPerson {
    String queryPerson(int num);
}

Ouvrons IPerson.java et regardons le code qu’il contient :

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;
}

Ici, nous ne nous intéressons qu’à **asInterface(IBinder)** et à la méthode **queryPerson()** que nous avons définie dans l’interface !

Cette méthode convertit un objet de type IBinder en type IPerson, et génère un objet proxy pour renvoyer le résultat lorsque nécessaire !

Nous pouvons ignorer le reste et passer directement à l'étape suivante.

Étape 2 : **Personnalisez notre classe Service et effectuez les opérations suivantes :**

1) Héritez de la classe Service, et définissez également une classe PersonQueryBinder personnalisée pourhériter de la classe IPerson.Stub,c'est-à-dire,implémenter l'interface IPerson et l'interface IBinder.

2) Instanciez la classe Stub personnalisée, redéfinissez la méthode onBind du Service et renvoyez un objet 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);
        }
    }
}

Étape 3:Enregistrez le Service dans le fichier 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>

Ici, nous ne fournissons pas d'interface Activity, mais le Service fourni par cette application peut être appelé par d'autres applications !


2. Côté client :
Copiez directement ce fichier AIDL depuis le côté serveur, puis nous le complétons directement dans MainActivity. Cela est similaire à l'opération de liaison d'un Service local,
et le processus est le suivant :
1) Définissez une classe PersonConnection personnaliséeimplémentant l'interface ServiceConnection.
2) Utilisez l'objet PersonConnection comme paramètre et appelez bindService pour lier le service distant.
bindService(service,conn,BIND_AUTO_CREATE);
ps : le troisième paramètre sert à définir que si le service n'est pas démarré, il sera créé automatiquement.
3) Contrairement à un service local,le ServiceConnection qui lie un service distant ne peut pas obtenir directement l'objet IBinder renvoyé par la méthode onBind() du service ; il peut seulement renvoyer
l'objet IBinder renvoyé, mais en réalité seulement l'onBind( )objet renvoyé par la méthode, à savoir l'objet proxy.Le traitement suivant est nécessaire :
iPerson = IPerson.Stub.asInterface(service);
Ensuite, complétez l'initialisation et les événements de bouton, et c'est tout.

Le code spécifique est le suivant :

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;
        }
    }
}

Ensuite, démarrez d'abord AIDLService, puis AIDLClient, saisissez le numéro de séquence de la requête, et vous pouvez obtenir le nom correspondant ! Bien sûr, vous pouvez aussi démarrer directement AIDLClient et obtenir le même effet :

Le schéma d’effet est le suivant :


3) Service AIDL pour le passage de données complexes

Dans l'exemple ci-dessus, nous n'avons passé qu'un paramètre de type int, et le serveur a renvoyé un paramètre de type String. Cela semble répondre à nos besoins de base, mais dans le développement réel, nous pouvons avoir besoin d'envisager de transmettre des types de données complexes ! Ci-dessous, nous allons apprendre comment transmettre des données complexes au serveur ! Avant de commencer, comprenons d'abordl'interface Parcelable.!

——Introduction à l'interface Parcelable :

Je pense que tous ceux qui ont utilisé la sérialisation connaissent essentiellement cette interface. À côté de celle-ci, il y en a une autre, Serializable, également utilisée pour la sérialisation. Cependant, Parcelable est plus léger et plus rapide ! Mais l'écrire est un peu pénible. Bien sûr, si vous utilisez Android Studio (AS), vous pouvez utiliser des plugins pour effectuer la sérialisation, tels que :Android Parcelable Code GeneratorBien sûr, ici nous allons quand même vous apprendre étape par étape à implémenter cette interface~

Tout d'abord,vous devez implémenter :writeToParceletreadFromPacLa méthode d'écriture écrit l'objet dans le parcel, et la méthode de lecture lit l'objet depuis le parcel. Notez que l'ordre d'écriture des propriétés doit être le même que l'ordre de lecture.

Ensuite,vous devez ajouter un champ dans cette classe, appeléCREATOR, un attributstatic final. Cet attribut doit implémenter : android.os.Parcelable.Creatorl'interface.

Ensuite,vous devez redéfinir les deux méthodes de l'interface :createFromParcelLa méthode (Parcel source) : implémente la fonction de création d'une instance de JavaBean à partir de source.newArray(int size) : crée un tableau de type T de longueur size. Elle ne contient qu'un simple `return new T[size];` (Ici T est la classe Person).

Enfin, describeContents(): je ne sais pas non plus à quoi cela sert ; retournez simplement 0 ! Pas besoin de vous en soucier.

——De plus,,parmi les types non primitifs,saufStringetCharSequencetous les autres nécessitent unindicateur de direction.Les indicateurs de direction incluentin、out、et inout.`in` signifie défini par le client, `out` signifie défini par le serveur, et `inout` signifie défini à la fois par le client et le serveur.


D'accord, ensuite écrivons du code et essayons-le (Dans Android Studio, certains types personnalisés ne sont pas encore résolus, donc nous revenons à Eclipse~) :

Exemple de code :

Définissez deux types d'objets personnalisés : Person et Salary. Person est utilisé comme paramètre pour appeler le Service distant, et Salary est utilisé comme valeur de retour ! Donc la première chose à faire est de créer les classes Person et Salary, et elles doivent implémenter l'interface Parcelable.

1. —Côté serveur

Étape 1: Créez les fichiers Person.aidl et Salary.aidl. Parce qu'ils doivent implémenter l'interface Parcelable, il suffit de la seule instruction suivante :

Person.aidl:     parcelable Person; 
Salary.aidl:     parcelable Salary; 
Étape 2: Créez séparément la classe Person et la classe Salary, implémentez l'interface Parcelable et redéfinissez les méthodes correspondantes !

PS : Comme plus tard nous récupérerons des données depuis la collection Map en fonction de l'objet Person, nous avons redéfini les méthodes hashCode et equals dans Person.java ; la classe Salary n'en a pas besoin !

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;
    }
}

Étape 3: Créez un fichier ISalary.aidl, et écrivez-y une méthode simple pour obtenir les informations de salaire :

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 :Ici, rappelez-vous que si vous utilisez des types de données personnalisés, vous devez les importer !!! Gardez-le en tête !!!

Étape 4:Écriture du Service principal : définissez une classe SalaryBinder héritant de Stub, implémentant ainsi les interfaces ISalary et IBinder ; définissez une collection Map pour stocker les informations ; redéfinissez la méthode onBind et retournez une instance de la classe 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();  
    }  
}  

Enregistrez le 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 — Codage côté client

Étape 1:Copiez le fichier AIDL du serveur. Le répertoire après copie est le suivant :

Étape 2Écrivez une mise en page simple, puis implémentez la MainActivity principale. Définissez un objet ServiceConnection, redéfinissez les méthodes correspondantes, comme pour les précédentes données ordinaires. Appelez ensuite bindService, et dans l'événement de clic du Button, obtenez l'objet Salary et affichez-le !

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);  
    }  
      
} 

Capture d'écran d'exécution :

PS:Ce code a été écrit auparavant avec Eclipse. Les types personnalisés présentent quelques problèmes sous Android Studio. Je n'ai pas encore trouvé de solution. Si quelqu'un sait, faites-le-moi savoir ! Extrêmement reconnaissant ! Les problèmes sont les suivants :

Liens de téléchargement du code des deux exemples (basés sur Eclipse) :
1) Utiliser AIDL pour réaliser une communication inter-processus simple
2)Implémentation d'un Service AIDL pour transmettre des données complexes


3. Réaliser directement une communication inter-processus via onTransact de Binder

Comme mentionné ci-dessus, Android peut utiliser la méthode onTransact de Binder pour communiquer. Essayons simplement ci-dessous. Toujours l'exemple précédent d'interrogation d'un nom par index :

Implémentation côté serveur:

/**
 * 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;
    }
}

Implémentation côté client:

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();
            }
        }
    }
}

Capture d'écran d'exécution :

Le code est relativement simple, je ne vais donc pas beaucoup l'expliquer. Modifiez-le simplement selon vos besoins !PSRéférence du code :Brève analyse du framework AIDL Binder d'Android


4. Points à noter concernant Service après Android 5.0 :

Aujourd'hui, en démarrant implicitement un Service, j'ai rencontré ce problèmeEnsuite, le programme a planté dès son démarrage. Après longtemps, j'ai découvert que c'était la faute d'Android 5.0. Il s'avère qu'après 5.0, il y a une nouvelle fonctionnalité, à savoir :L'Intent de Service doit être explicite !Eh bien, vous ne pouvez tout simplement pas démarrer un Service implicitement. La solution est aussi très simple ! Par exemple, pour startService :

startService(new Intent(getApplicationContext(), "com.aaa.xxxserver"));L'écrire de cette façon fera planter directement le programme. Il faut l'écrire comme ceci :startService(new Intent(getApplicationContext(), LoadContactsService.class));

S'il s'agit de bindService :Intent service = new Intent("android.intent.action.AIDLService");Sur cette base, ajoutez le nom du package :service.setPackage("com.jay.ipcserver");Ça fera l'affaire~

Documentation officielle :http://developer.android.com/intl/zh-cn/guide/components/intents-filters.html#TypesExplication de la documentation :


Résumé de cette section :

Très bien, c'est tout pour la dernière section sur Service. Cette section a expliqué les concepts de base de Binder et deux façons de mettre en œuvre la communication inter-processus : réaliser une communication inter-processus via AIDL et Binder.onTransact() ! Enfin, elle a aussi expliqué la remarque selon laquelle, après Android 5.0, les Services ne peuvent pas être démarrés implicitement ! C'est tout, merci~