Einführung in diesen Abschnitt:
In diesem Abschnitt setzen wir die Untersuchung der Service-Komponente fort. Wir werden einige Konzepte der AIDL-prozessübergreifenden Kommunikation in Android kennenlernen. Wir gehen nicht tief auf die Quellcode-Ebene ein; im Moment reicht es zu wissen, was es ist und wie man es verwendet! Beginnen wir mit dem Inhalt dieses Abschnitts. Die offizielle Dokumentation zu diesem Abschnitt:Binder
1. Erster Blick auf den Binder-Mechanismus
1) Was zum Teufel sind IBinder und Binder?
Schauen wir, was die offizielle Dokumentation sagt:

Chinesische Übersetzung:
IBinder ist die Basisschnittstelle für Remote-Objekte und der Kernbestandteil eines leichtgewichtigen Mechanismus für Remote-Aufrufe, der auf hohe Leistung ausgelegt ist. Er wird jedoch nicht nur für Remote-Aufrufe verwendet, sondern auch für prozessinterne Aufrufe. Diese Schnittstelle definiert das Protokoll für die Interaktion mit Remote-Objekten. Implementieren Sie diese Schnittstelle jedoch nicht direkt; stattdessenerbt von(extends)Binder。
Die Haupt-API von IBinder isttransact(), und die entsprechende API istBinder.onTransact(). Durch Erstere können Sie Aufrufe an ein entferntes IBinder-Objekt senden, und Letztere ermöglicht es Ihrem entfernten Objekt, auf empfangene Aufrufe zu antworten. Die APIs von IBinder sind alleSynchronausgeführt, zum Beispieltransact(), bis der MethodenaufrufBinder.onTransact()der anderen Seite beendet ist, bevor zurückgekehrt wird.IPCmithilfe von, derselbe Effekt wird erzielt.
Durchtransact()sind die gesendeten DatenParcel, Parcel ist ein Allzweckpuffer, der zusätzlich zu Daten auch einige Metadaten trägt, die seinen Inhalt beschreiben. Die Metadaten werden verwendet, um Referenzen auf IBinder-Objekte zu verwalten, sodass diese Referenzen erhalten bleiben, wenn der Puffer von einem Prozess in einen anderen verschoben wird. Dadurch wird sichergestellt, dass, wenn ein IBinder in ein Parcel geschrieben und an einen anderen Prozess gesendet wird und der andere Prozess die Referenz auf denselben IBinder an den ursprünglichen Prozess zurücksendet, der ursprüngliche Prozess die Referenz auf diesen IBinder empfangen kann, die er ausgesendet hat. Dieser Mechanismus verwaltet IBinder und Binder über Prozesse hinweg wie eindeutige Identifikatoren.
Das System unterhält für jeden Prozess einen Thread-Pool, der Interaktions-Threads speichert. Diese Interaktions-Threads werden verwendet, um alle von anderen Prozessen gesendeten IPC-Aufrufe weiterzuleiten. Zum Beispiel: Wenn ein IPC von Prozess A an Prozess B gesendet wird, blockiert der Thread in A, der den Aufruf ausgesendet hat (dieser Thread sollte sich nicht im Thread-Pool befinden), beitransact(). Ein Thread im Interaktions-Thread-Pool von Prozess B empfängt diesen Aufruf und ruftBinder.onTransact() auf, und nach Abschluss gibt er ein Parcel als Ergebnis zurück. Dann kann der wartende Thread in Prozess A nach Empfang des zurückgegebenen Parcel weiter ausgeführt werden. Tatsächlich sieht ein anderer Prozess wie ein Thread des aktuellen Prozesses aus, wurde aber nicht vom aktuellen Prozess erstellt.
Der Binder-Mechanismus unterstützt auch rekursive Aufrufe zwischen Prozessen. Zum Beispiel führt Prozess A transact() seines eigenen IBinder aus, um das Binder von Prozess B aufzurufen, und Prozess B verwendet in seinem Binder.onTransact() transact(), um einen Aufruf an Prozess A zu initiieren. Dann verwendet Prozess A, während er auf die Rückkehr seines ausgegebenen Aufrufs wartet, ebenfalls Binder.onTransact(), um auf transact() von Prozess B zu reagieren. Kurz gesagt, das Ergebnis von Binder ist, dass wir das Gefühl haben, prozessübergreifende Aufrufe unterscheiden sich nicht von Aufrufen innerhalb eines Prozesses.
Beim Arbeiten mit entfernten Objekten müssen Sie oft prüfen, ob sie gültig sind. Es gibt drei Methoden, die Sie verwenden können:
- 1. Die Methode transact() wirft eine RemoteException, wenn der Prozess, in dem sich der IBinder befindet, nicht mehr existiert.
- 2. Wenn der Zielprozess nicht existiert, gibt der Aufruf von pingBinder() false zurück.
- 3. Sie können die Methode linkToDeath() verwenden, um einen IBinder.DeathRecipient beim IBinder zu registrieren, der aufgerufen wird, wenn der durch den IBinder repräsentierte Prozess beendet wird.
PS: Die chinesische Übersetzung ist entnommen aus:Android-Entwicklung: Was ist IBinder
Nun, nachdem Sie diesen ganzen Text gelesen haben, sind Sie vielleicht verwirrt. Hier ist eine kurze Zusammenfassung:
IBinder ist eine Schnittstelle für die Interprozesskommunikation, die uns von Android bereitgestellt wird, und wir implementieren diese Schnittstelle normalerweise nicht direkt. Stattdessen implementieren wir die Interprozesskommunikation durch Erben der Klasse Binder! Es ist eine Möglichkeit, IPC (Interprozesskommunikation) in Android zu implementieren!
2) Kurze Analyse des Binder-Mechanismus
Der Binder-Mechanismus in Android besteht aus einer Reihe von Systemkomponenten:Client, Server, Service Manager und Binder-Treiber
Der ungefähre Aufrufablauf ist wie folgt. Außerdem ist der Service Manager recht komplex, daher werden wir ihn hier nicht im Detail untersuchen!

Ablaufanalyse:
->Wenn der Client eine Methode in einer Proxy-Schnittstelle aufruft, verpackt die Methode der Proxy-Schnittstelle die vom Client übergebenen Parameter in ein Parcel-Objekt;
->Dann sendet die Proxy-Schnittstelle das Parcel-Objekt an den Binder-Treiber im Kernel;;
->Dann liest der Server die Anfragedaten im Binder-Treiber. Wenn sie an ihn selbst gesendet wurden, entpackt er das Parcel-Objekt, verarbeitet es und gibt das Ergebnis zurück;
PS: Die in der Proxy-Schnittstelle definierten Methoden entsprechen eins zu eins den im Server definierten Methoden. Darüber hinaus ist der gesamte Aufrufprozess synchron, das heißt, während der Server verarbeitet, wird der Client blockiert (gesperrt)! Und die hier erwähnte Definition der Proxy-Schnittstelle ist das, was wir als Nächstes besprechen werden:AIDL(Android Interface Definition Language)!
3) Warum verwendet Android den Binder-Mechanismus für die Interprozesskommunikation?
- Zuverlässigkeit: Auf mobilen Geräten wird üblicherweise eine Client-Server-basierte Kommunikationsmethode verwendet, um die interne Kommunikation zwischen dem Internet und dem Gerät zu ermöglichen. Derzeit umfassen von Linux unterstützte IPC traditionelle Pipes, System V IPC, nämlich Nachrichtenwarteschlangen/Shared Memory/Semaphoren, und Sockets. Von diesen unterstützen nur Sockets die Client-Server-Kommunikationsmethode. Das Android-System bietet Entwicklern eine Fülle funktionaler Schnittstellen für die Interprozesskommunikation, wie Medienwiedergabe, Sensoren und drahtlose Übertragung. Diese Funktionen werden von verschiedenen Servern verwaltet. Entwickler müssen sich nur darum kümmern, die Kommunikation zwischen dem Client ihrer Anwendung und dem Server herzustellen, um diesen Dienst zu nutzen. Zweifellos erhöht es die Komplexität des Systems, wenn eine Reihe von Protokollen in der zugrunde liegenden Schicht eingerichtet wird, um Client-Server-Kommunikation zu implementieren. Die Implementierung einer so komplexen Umgebung auf einem Telefon mit begrenzten Ressourcen macht die Zuverlässigkeit schwer zu garantieren.
- Übertragungsleistung: Socket wird hauptsächlich für die Interprozesskommunikation über Netzwerke hinweg und zwischen Prozessen auf derselben Maschine verwendet, aber es hat eine geringe Übertragungseffizienz und einen hohen Overhead. Nachrichtenwarteschlangen und Pipes verwenden ein Store-and-Forward-Verfahren, das heißt, Daten werden zuerst vom Puffer des Senders in einen im Kernel geöffneten Puffer kopiert und dann vom Kernel-Puffer in den Puffer des Empfängers kopiert. Dieser Vorgang umfasst mindestens zwei Kopien. Obwohl Shared Memory keine Kopie erfordert, ist es komplex zu steuern. Vergleichen Sie die Anzahl der Datenkopien für verschiedene IPC-Methoden. Shared Memory: 0 Mal. Binder: 1 Mal. Socket/Pipe/Nachrichtenwarteschlange: 2 Mal.
- Sicherheit: Android ist eine offene Plattform, daher ist die Gewährleistung der Anwendungssicherheit sehr wichtig. Android weist jeder installierten Anwendung eine UID/PID zu, wobei die Prozess-UID zur Identifizierung der Prozessidentität verwendet werden kann. Traditionell konnten Benutzer nur UID/PID in das Datenpaket eintragen, was unzuverlässig ist und leicht von bösartigen Programmen ausgenutzt werden kann. Wir verlangen vom Kernel, zuverlässige UIDs hinzuzufügen. Daher hat Android aus Gründen der Zuverlässigkeit, Übertragungsleistung und Sicherheit eine neue Methode der Interprozesskommunikation etabliert. — Auszug aus:Ein kurzes Verständnis des Binder-Mechanismus in Android
Natürlich kümmern uns als Junior-Entwickler die oben genannten Dinge nicht. Der direkteste Vorteil, den der Binder-Mechanismus für uns bringt, ist:Wir müssen uns nicht darum kümmern, wie die zugrunde liegende Schicht implementiert ist. Wir müssen nur eine Schnittstellendatei gemäß den AIDL-Regeln definieren, und dann die Methoden in der Schnittstelle aufrufen, um die Kommunikation zwischen zwei Prozessen abzuschließen!
2. Ausführliche Erklärung der AIDL-Nutzung
1) Was ist AIDL?
Hehe, vorhin haben wirIPCdiesen Begriff erwähnt. Sein vollständiger Name ist:Interprozesskommunikation, Denn im Android-System läuft jede Anwendung in ihrem eigenen Prozess, und im Allgemeinen können Prozesse nicht direkt Daten miteinander austauschen. Um prozessübergreifende Kommunikation zu erreichen, stellt Android uns den oben erwähnten Binder-Mechanismus bereit, und die von diesem Mechanismus verwendete Schnittstellensprache ist:AIDL(Android Interface Definition Language). Seine Syntax ist sehr einfach, und diese Schnittstellensprache ist keine echte Programmiersprache; sie definiert nur die Kommunikationsschnittstelle zwischen zwei Prozessen! Der Java-Code, der dem Kommunikationsprotokoll entspricht, wird von demaidl.exeTool. Die entsprechende Schnittstellendatei wird im gen-Verzeichnis generiert, normalerweise eine Schnittstelle wie Xxx.java! Und diese Schnittstelle enthält eineStubinnere Klasse. In dieser Klasse implementiert sieIBinderdie Schnittstelle und die benutzerdefinierte Kommunikationsschnittstelle. Diese Klasse dient als Callback-Klasse des entfernten Service — sie implementiert die IBinder-Schnittstelle, kann also als Rückgabewert der onBind()-Methode von Service verwendet werden!
2) AIDL implementiert einfache Kommunikation zwischen zwei Prozessen
Bevor wir AIDL-Schnittstellendateien schreiben, müssen wir einige zu beachtende Punkte beim Schreiben von AIDL kennen:
Zu beachtende Punkte bei AIDL:
- Der Schnittstellenname muss mit dem AIDL-Dateinamen übereinstimmen.
- Vor Schnittstellen und Methoden,dürfen keine Zugriffsmodifikatoren hinzugefügt werden,wie public, private, protected usw., und static final darf nicht verwendet werden!
- Die von AIDL standardmäßig unterstützten Typen umfassenJava-Primitivtypen.,String,List,Map,CharSequenceDarüber hinaus benötigen alle anderen Typen Import-Deklarationen. Für benutzerdefinierte Typen, die als Parameter oder Rückgabewerte verwendet werden, muss der benutzerdefinierte Typ das Parcelable-Interface implementieren. Einzelheiten finden Sie im späteren Abschnitt über die Übergabe komplexer Datentypen.
- Benutzerdefinierte Typen und andere von AIDL generierte Schnittstellentypen sollten in der AIDL-Beschreibungsdatei explizit importiert werden, auch wenn sich diese Klassen im selben Paket wie das definierte Paket befinden.
Wenn der Compiler, den du zum Schreiben von AIDL verwendest, außerdem Eclipse ist, achte darauf: Erstelle nicht direkt eine neue Datei und richte sie ein! Wenn du das tust, kann die Datei nicht geöffnet werden, sodass du keinen Code schreiben kannst!
① Erstelle direkt eine neue txt-Datei, schreibe den Inhalt, speichere sie im .aidl-Format und kopiere sie dann in den entsprechenden Pfad.
② Da AIDL einer Schnittstelle ähnelt, kannst du direkt eine neue Schnittstelle erstellen, den Inhalt schreiben, dann in das Verzeichnis wechseln, in dem sich die entsprechende Java-Datei befindet, und die Dateiendung ändern.Wenn du Android Studio verwendest, wirst du anders als bei Eclipse, wenn du eine AIDL-Datei auf dieselbe Weise wie in Eclipse erstellst, feststellen, dass die entsprechende XXX.java-Datei nicht kompiliert wird. Um eine AIDL-Datei in Android Studio zu erstellen, musst du einen neuen aidl-Ordner unter dem Hauptverzeichnis erstellen, ein Paket mit demselben Namen wie das AIDL-Paket definieren und schließlich eine aidl-Datei erstellen. Drücke dann ctrl + F9, um neu zu kompilieren, und das war's!
Die Ergebnisse einer erfolgreichen Kompilierung der beiden oben genannten Methoden sind wie folgt; die entsprechenden AIDL-Dateien findest du in den entsprechenden Verzeichnissen.
![]()
1. Serverseite:
Schritt 1:Eine AIDL-Datei erstellen:
IPerson.aidl
package com.jay.aidl;
interface IPerson {
String queryPerson(int num);
}
Lass uns IPerson.java öffnen und den Code darin ansehen:
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;
}
Hier interessieren uns nur **asInterface(IBinder)** und die **queryPerson()**-Methode, die wir in der Schnittstelle definiert haben!
Diese Methode konvertiert ein Objekt vom Typ IBinder in den Typ IPerson und erzeugt bei Bedarf ein Proxy-Objekt, um das Ergebnis zurückzugeben!
Wir können den Rest ignorieren und direkt zum nächsten Schritt springen.
Schritt 2: **Passen Sie unsere Service-Klasse an und führen Sie die folgenden Operationen aus:**
1) Erben Sie von der Service-Klasse und definieren Sie außerdem eine benutzerdefinierte Klasse PersonQueryBinder, umvon der Klasse IPerson.Stub zu erben,das heißt,die IPerson-Schnittstelle und die IBinder-Schnittstelle zu implementieren.
2) Instanziieren Sie die benutzerdefinierte Stub-Klasse, überschreiben Sie die onBind-Methode des Service und geben Sie ein Binder-Objekt zurück!
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);
}
}
}
Schritt 3:Registrieren Sie den Service in der Datei 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>
Hier stellen wir keine Activity-Oberfläche bereit, aber der von dieser App bereitgestellte Service kann von anderen Apps aufgerufen werden!
2. Client-Seite:
Kopieren Sie diese AIDL-Datei direkt von der Serverseite, dann schließen wir sie direkt in MainActivity ab. Dies ähnelt dem Vorgang, einen lokalen Service zu binden,
und der Prozess ist wie folgt:
1) Definieren Sie eine benutzerdefinierte Klasse PersonConnection, die die ServiceConnection-Schnittstelle implementiert.
2) Verwende das PersonConnection-Objekt als Parameter und rufe bindService auf, um den Remote-Service zu binden.
bindService(service,conn,BIND_AUTO_CREATE);
Hinweis: Der dritte Parameter legt fest, dass der Service automatisch erstellt wird, wenn er nicht gestartet ist.
3) Anders als bei einem lokalen Service kann die ServiceConnection, die einen Remote-Service bindet, das von der onBind()-Methode des Service zurückgegebene IBinder-Objekt nicht direkt erhalten; sie kann nur zurückgebenthe ServiceConnection that binds a remote Service cannot directly obtain the IBinder object returned by the Service's onBind() method; it can only return
das zurückgegebene IBinder-Objekt, aber tatsächlich nur das von der MethodeonBind( )zurückgegebene Objekt, nämlich dasProxy-Objekt.Die folgende Verarbeitung ist erforderlich:
iPerson = IPerson.Stub.asInterface(service);
Dann schließe die Initialisierung und die Button-Events ab, und das war's.
Der spezifische Code sieht wie folgt aus:
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;
}
}
}
Starte als Nächstes zuerst AIDLService, dann AIDLClient, gib die Abfragesequenznummer ein, und du kannst den entsprechenden Namen erhalten! Natürlich kannst du auch direkt AIDLClient starten und denselben Effekt erzielen:
Das Effektdiagramm ist wie folgt:

3) AIDL-Service zur Übergabe komplexer Daten
Im obigen Beispiel haben wir nur einen Parameter vom Typ int übergeben, und der Server gab einen Parameter vom Typ String zurück. Es scheint unsere grundlegenden Anforderungen zu erfüllen, aber in der tatsächlichen Entwicklung müssen wir möglicherweise die Übergabe komplexer Datentypen in Betracht ziehen! Im Folgenden lernen wir, wie man komplexe Daten an den Server übergibt! Bevor wir beginnen, wollen wir zunächstdie Parcelable-Schnittstelle kennenlernen.!
——Einführung in die Parcelable-Schnittstelle:
Ich glaube, jeder, der Serialisierung verwendet hat, kennt diese Schnittstelle im Grunde. Daneben gibt es noch eine weitere, Serializable, die ebenfalls zur Serialisierung verwendet wird. Parcelable ist jedoch leichtgewichtiger und schneller! Aber das Schreiben ist etwas mühsam. Natürlich kann man, wenn man Android Studio (AS) verwendet, Plugins benutzen, um die Serialisierung zu erledigen, wie zum Beispiel:Android Parcelable Code GeneratorNatürlich werden wir Ihnen hier trotzdem Schritt für Schritt zeigen, wie Sie diese Schnittstelle implementieren~
Zuerst,müssen Sie implementieren:writeToParcelundreadFromPacelDie write-Methode schreibt das Objekt in das Parcel, und die read-Methode liest das Objekt aus dem Parcel. Beachten Sie, dass die Reihenfolge beim Schreiben der Eigenschaften dieselbe sein muss wie die Reihenfolge beim Lesen.
Als Nächstesmüssen Sie in dieser Klasse ein Feld namensCREATORalsstatic finalAttribut hinzufügen. Dieses Attribut muss implementieren: android.os.Parcelable.Creator
Dann,müssen Sie die beiden Methoden in der Schnittstelle überschreiben:createFromParcelDie Methode (Parcel source): implementiert die Funktion, aus source eine JavaBean-Instanz zu erstellen.newArray(int size): erstellt ein Array vom Typ T mit der Länge size. Sie hat nur ein einfaches `return new T[size];` (Hier ist T die Klasse Person).
Schließlich, describeContents(): Ich weiß auch nicht, wofür das gut ist; geben Sie einfach 0 zurück! Sie müssen sich keine Gedanken darüber machen.
——Außerdem,,unter den nicht-primitiven Typen,außerStringundCharSequencealle anderen erfordern einenRichtungsindikator.Die Richtungsindikatoren umfassenin、out、und inout.`in` bedeutet, vom Client gesetzt zu werden, `out` bedeutet, vom Server gesetzt zu werden, und `inout` bedeutet, dass der Wert sowohl vom Client als auch vom Server gesetzt wird.
Okay, als Nächstes schreiben wir Code und probieren es aus (In Android Studio gibt es bei benutzerdefinierten Typen noch einige ungelöste Probleme, also wechseln wir zurück zu Eclipse~):
Codebeispiel:
Definiere zwei benutzerdefinierte Objekttypen: Person und Salary. Person wird als Parameter für den Aufruf des Remote-Dienstes verwendet, und Salary wird als Rückgabewert verwendet! Als Erstes müssen also die Klassen Person und Salary erstellt werden, und sie müssen die Parcelable-Schnittstelle implementieren.
1. —Serverseite
Schritt 1: Erstelle die Dateien Person.aidl und Salary.aidl. Da sie die Parcelable-Schnittstelle implementieren müssen, genügt die folgende eine Anweisung:
Person.aidl: parcelable Person; Salary.aidl: parcelable Salary;Schritt 2: Erstelle die Klasse Person und die Klasse Salary getrennt, implementiere die Parcelable-Schnittstelle und überschreibe die entsprechenden Methoden!
PS: Da wir später Daten aus der Map-Sammlung anhand des Person-Objekts abrufen werden, haben wir die Methoden hashCode und equals in Person.java überschrieben; die Klasse Salary benötigt dies nicht!
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;
}
}
Schritt 3: Erstelle eine ISalary.aidl-Datei und schreibe eine einfache Methode hinein, um Gehaltsinformationen abzurufen:
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:Hier, denke daran, dass du, wenn du benutzerdefinierte Datentypen verwendest, sie importieren musst!!! Behalte es im Hinterkopf!!!
Schritt 4:Schreiben des Kern-Service: Definiere eine SalaryBinder-Klasse, die von Stub erbt und dadurch die Schnittstellen ISalary und IBinder implementiert; definiere eine Map-Sammlung zum Speichern von Informationen; überschreibe die onBind-Methode und gib eine Instanz der Klasse SalaryBinder zurück!
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();
}
}
Den Service registrieren:
<service android:name=".AidlService">
<intent-filter>
<action android:name="android.intent.action.AIDLService" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</service>
2 — Clientseitige Programmierung
Schritt 1:Kopieren Sie die AIDL-Datei des Servers. Das Verzeichnis nach dem Kopieren sieht wie folgt aus:

Schritt 2Schreiben Sie ein einfaches Layout und implementieren Sie dann die zentrale MainActivity. Definieren Sie ein ServiceConnection-Objekt, überschreiben Sie die entsprechenden Methoden, ähnlich wie bei den vorherigen normalen Daten. Rufen Sie dann bindService auf und holen Sie im Klickereignis des Button das Salary-Objekt und zeigen Sie es an!
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);
}
}
Screenshot der Ausführung:

PS:Dieser Code wurde früher mit Eclipse geschrieben. Benutzerdefinierte Typen haben unter Android Studio einige Probleme. Ich habe noch keine Lösung gefunden. Wenn jemand eine kennt, lassen Sie es mich bitte wissen! Sehr dankbar! Die Probleme sind wie folgt:
Download-Links für den Code der beiden Beispiele (basierend auf Eclipse):
1)Verwendung von AIDL zur Realisierung einer einfachen Interprozesskommunikation
2)Implementierung eines AIDL-Service zur Übergabe komplexer Daten
3. Direkte Durchführung der prozessübergreifenden Kommunikation über Binders onTransact
Wie oben erwähnt, kann Android die onTransact-Methode von Binder zur Kommunikation verwenden. Probieren wir es im Folgenden einfach aus. Weiterhin das vorherige Beispiel der Abfrage eines Namens anhand des Index:
Serverseitige Implementierung:
/**
* 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;
}
}
Clientseitige Implementierung:
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();
}
}
}
}
Screenshot der Ausführung:

Der Code ist relativ einfach, daher werde ich nicht viel erklären. Ändern Sie ihn einfach nach Bedarf für Ihre Verwendung!PSCode-Referenz:Eine kurze Analyse des Android-AIDL-Binder-Frameworks
4. Zu beachtende Punkte beim Service nach Android 5.0:
Heute bin ich beim impliziten Starten eines Service auf dieses Problem gestoßen
Dann stürzte das Programm ab, sobald es startete. Nach langer Zeit fand ich heraus, dass es an Android 5.0 lag. Es stellte sich heraus, dass es nach 5.0 eine neue Funktion gibt, nämlich:Service Intent muss explizit sein!Nun, man kann einen Service einfach nicht implizit starten. Die Lösung ist auch sehr einfach! Zum Beispiel für startService:
startService(new Intent(getApplicationContext(), "com.aaa.xxxserver"));Wenn man es so schreibt, führt das direkt zum Absturz des Programms. Es sollte so geschrieben werden:startService(new Intent(getApplicationContext(), LoadContactsService.class));
Wenn es für bindService ist:Intent service = new Intent("android.intent.action.AIDLService");Fügen Sie darauf aufbauend den Paketnamen hinzu:service.setPackage("com.jay.ipcserver");Das reicht~
Offizielle Dokumentation:http://developer.android.com/intl/zh-cn/guide/components/intents-filters.html#TypesErklärung der Dokumentation:
Zusammenfassung dieses Abschnitts:
Also, das war alles zum letzten Abschnitt über Service. In diesem Abschnitt wurden die grundlegenden Konzepte von Binder und zwei Möglichkeiten zur Implementierung der Interprozesskommunikation erklärt: die prozessübergreifende Kommunikation durch AIDL und Binder.onTransact()! Schließlich wurde auch der Hinweis erklärt, dass nach Android 5.0 Services nicht implizit gestartet werden können! Das war alles, danke~


Dann stürzte das Programm ab, sobald es startete. Nach langer Zeit fand ich heraus, dass es an Android 5.0 lag. Es stellte sich heraus, dass es nach 5.0 eine neue Funktion gibt, nämlich:Service Intent muss explizit sein!Nun, man kann einen Service einfach nicht implizit starten. Die Lösung ist auch sehr einfach! Zum Beispiel für startService: