L'Android Interface Definition Language (AIDL) è simile ad altri IDL: consente di definire l'interfaccia di programmazione concordata sia dal client che dal servizio per comunicare tra loro utilizzando la comunicazione tra processi (IPC).
Su Android, un processo non può normalmente accedere alla memoria di un altro processo. Per comunicare, devono scomporre i loro oggetti in primitive che il sistema operativo può comprendere e organizzare gli oggetti attraverso questo confine per te. Il codice per eseguire questo marshalling è noioso da scrivere, quindi Android lo gestisce per te con AIDL.
Nota: AIDL è necessario solo se consenti ai client di diverse applicazioni di accedere al tuo servizio per l'IPC e vuoi gestire il multithreading nel tuo servizio. Se non hai bisogno di eseguire IPC simultanee tra
diverse applicazioni, crea l'interfaccia implementando un
Binder.
Se vuoi eseguire l'IPC, ma non hai bisogno di gestire il multi-threading, implementa l'interfaccia utilizzando un Messenger.
In ogni caso, assicurati di comprendere i servizi associati prima di implementare un AIDL.
Prima di iniziare a progettare l'interfaccia AIDL, tieni presente che le chiamate a un'interfaccia AIDL sono chiamate di funzione dirette. Non fare supposizioni sul thread in cui avviene la chiamata. Il risultato varia a seconda che la chiamata provenga da un thread nel processo locale o in un processo remoto:
- Le chiamate effettuate dal processo locale vengono eseguite nello stesso thread che effettua la chiamata. Se questo è il thread dell'interfaccia utente principale, il thread continua a essere eseguito nell'interfaccia AIDL. Se si tratta di un altro thread, è quello che esegue il tuo codice nel servizio. Pertanto, se solo i thread locali accedono al servizio, puoi controllare completamente quali thread vengono eseguiti al suo interno. In questo caso, non utilizzare AIDL, ma crea l'interfaccia implementando un
Binder. - Le chiamate da un processo remoto vengono inviate da un pool di thread gestito dalla piattaforma all'interno del tuo processo. Preparati a ricevere chiamate in arrivo da thread sconosciuti, con più chiamate contemporaneamente. In altre parole, un'implementazione di un'interfaccia AIDL deve essere completamente thread-safe. Le chiamate effettuate da un thread sullo stesso oggetto remoto arrivano in ordine sul lato del ricevitore.
- La parola chiave
onewaymodifica il comportamento delle chiamate remote. Quando viene utilizzata, una chiamata remota non si blocca. Invia i dati della transazione e restituisce immediatamente il risultato. L'implementazione dell'interfaccia riceve questa chiamata come una normale chiamata dal pool di threadBindercome una normale chiamata remota. Seonewayviene utilizzato con una chiamata locale, non ci sono impatti e la chiamata rimane sincrona.
Definizione di un'interfaccia AIDL
Definisci l'interfaccia AIDL in un file .aidl utilizzando la sintassi del linguaggio di programmazione Java, quindi salvala nel codice sorgente, nella directory src/, sia dell'applicazione che ospita il servizio sia di qualsiasi altra applicazione che si associa al servizio.
Quando crei ogni applicazione che contiene il file .aidl, gli strumenti SDK Android generano un'interfaccia IBinder basata sul file .aidl e la salvano nella directory gen/ del progetto. Il servizio deve implementare l'interfaccia IBinder in base alle esigenze. Le applicazioni client possono quindi associarsi al servizio e chiamare i metodi da IBinder per eseguire l'IPC.
Per creare un servizio associato utilizzando AIDL, segui questi passaggi, descritti nelle sezioni seguenti:
- Crea il file
.aidlQuesto file definisce l'interfaccia di programmazione con le firme dei metodi.
- Implementa l'interfaccia
Gli strumenti SDK Android generano un'interfaccia nel linguaggio di programmazione Java in base al tuo file
.aidl. Questa interfaccia ha una classe astratta interna denominataStubche estendeBindere implementa i metodi della tua interfaccia AIDL. Devi estendere la classeStube implementare i metodi. - Esponi l'interfaccia ai client
Implementa un
Serviceed esegui l'override dionBind()per restituire l'implementazione della classeStub.
Attenzione: tutte le modifiche apportate all'interfaccia AIDL dopo la prima release devono rimanere compatibili con le versioni precedenti per evitare di interrompere altre applicazioni che utilizzano il tuo servizio. In altre parole, poiché il file .aidl deve essere copiato in altre applicazioni per consentire loro di accedere all'interfaccia del tuo servizio, devi mantenere il supporto per l'interfaccia originale.
Crea il file .aidl
AIDL utilizza una sintassi semplice che consente di dichiarare un'interfaccia con uno o più metodi che possono accettare parametri e restituire valori. I parametri e i valori restituiti possono essere di qualsiasi tipo, anche altre interfacce generate da AIDL.
Devi creare il file .aidl utilizzando il linguaggio di programmazione Java. Ogni file .aidl deve definire una singola interfaccia e richiede solo la dichiarazione dell'interfaccia e le firme dei metodi.
Per impostazione predefinita, AIDL supporta i seguenti tipi di dati:
- Tutti i tipi primitivi, ad eccezione di
short, nel linguaggio di programmazione Java (ad esempioint,long,char,booleane così via) - Array di qualsiasi tipo, ad esempio
int[]oMyParcelable[] StringCharSequenceListTutti gli elementi in
Listdevono essere uno dei tipi di dati supportati in questo elenco o una delle altre interfacce o parcelable generati da AIDL che dichiari. UnListpuò essere utilizzato facoltativamente come classe di tipo parametrizzato, ad esempioList<String>. La classe concreta effettiva ricevuta dall'altro lato è sempre unArrayList, anche se il metodo è generato per utilizzare l'interfacciaList.MapTutti gli elementi in
Mapdevono essere uno dei tipi di dati supportati in questo elenco o una delle altre interfacce o parcelable generati da AIDL che dichiari. Le mappe dei tipi parametrizzati, come quelle della formaMap<String,Integer>, non sono supportate. La classe concreta effettiva che l'altro lato riceve è sempre unHashMap, anche se il metodo è generato per utilizzare l'interfacciaMap. Valuta la possibilità di utilizzare unBundlein alternativa aMap.
Devi includere un'istruzione import per ogni tipo aggiuntivo non elencato in precedenza, anche se è definito nello stesso pacchetto dell'interfaccia.
Quando definisci l'interfaccia del servizio, tieni presente che:
- I metodi possono accettare zero o più parametri e possono restituire un valore o void.
- Tutti i parametri non primitivi richiedono un tag direzionale che indica la direzione dei dati:
in,outoinout(vedi l'esempio di seguito).Le primitive,
String,IBindere le interfacce generate da AIDL sonoinper impostazione predefinita e non possono essere altrimenti.Attenzione: limita la direzione a ciò che è veramente necessario, perché il marshalling dei parametri è costoso.
- Tutti i commenti al codice inclusi nel file
.aidlsono inclusi nell'interfacciaIBindergenerata, ad eccezione dei commenti prima delle istruzioni di importazione e del pacchetto. - Le costanti stringa e int possono essere definite nell'interfaccia AIDL, ad esempio
const int VERSION = 1;. - Le chiamate ai metodi vengono inviate da un
codice
transact(), che normalmente si basa su un indice dei metodi nell'interfaccia. Poiché questo rende difficile il controllo delle versioni, puoi assegnare manualmente il codice della transazione a un metodo:void method() = 10;. - Gli argomenti e i tipi restituiti che ammettono valori null devono essere annotati utilizzando
@nullable.
Ecco un esempio di file .aidl:
// IRemoteService.aidl package com.example.android; // Declare any non-default types here with import statements. /** Example service interface. */ interface IRemoteService { /** Request the process ID of this service. */ int getPid(); /** Demonstrates some basic types that you can use as parameters * and return values in AIDL. */ void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString); }
Salva il file .aidl nella directory src/ del progetto. Quando crei l'applicazione, gli strumenti SDK generano il file di interfaccia IBinder nella directory gen/ del progetto. Il nome del file generato corrisponde al nome del file .aidl, ma con un'estensione .java. Ad esempio, IRemoteService.aidl restituisce IRemoteService.java.
Se utilizzi Android Studio, la build incrementale genera la classe binder quasi immediatamente.
Se non utilizzi Android Studio, lo strumento Gradle genera la classe binder la prossima volta che crei l'applicazione. Crea il progetto con gradle assembleDebug o gradle assembleRelease non appena hai finito di scrivere il file .aidl, in modo che il codice possa essere collegato alla classe generata.
Implementa l'interfaccia
Quando crei l'applicazione, gli strumenti SDK Android generano un file di interfaccia .java
con il nome del file .aidl. L'interfaccia generata include una sottoclasse denominata Stub, che è un'implementazione astratta della relativa interfaccia principale, ad esempio YourInterface.Stub, e dichiara tutti i metodi del file .aidl.
Nota:Stub definisce anche alcuni metodi di supporto, in particolareasInterface(), che richiede unIBinder, di solito quello passato al metodo di callback di un clientonServiceConnected() , e restituisce un'istanza dell'interfaccia stub. Per maggiori dettagli su come eseguire questo cast, consulta la sezione Chiamata di un metodo IPC.
Per implementare l'interfaccia generata da .aidl, estendi l'interfaccia Binder generata, ad esempio YourInterface.Stub, e implementa i metodi ereditati dal file .aidl.
Ecco un esempio di implementazione di un'interfaccia denominata IRemoteService, definita dall'esempio IRemoteService.aidl precedente, utilizzando un'istanza anonima:
private val binder = object : IRemoteService.Stub() { override fun getPid(): Int = Process.myPid() override fun basicTypes( anInt: Int, aLong: Long, aBoolean: Boolean, aFloat: Float, aDouble: Double, aString: String ) { // Does nothing. } }
Ora binder è un'istanza della classe Stub (un Binder),
che definisce l'interfaccia IPC per il servizio. Nel passaggio successivo, questa istanza viene esposta ai client in modo che possano interagire con il servizio.
Tieni presente alcune regole quando implementi l'interfaccia AIDL:
- Non è garantito che le chiamate in arrivo vengano eseguite sul thread principale, quindi devi pensare al multithreading fin dall'inizio e creare correttamente il tuo servizio in modo che sia thread-safe.
- Per impostazione predefinita, le chiamate IPC sono sincrone. Se sai che il servizio impiega più di qualche millisecondo per completare una richiesta, non chiamarlo dal thread principale dell'attività. Potrebbe bloccare l'applicazione, causando la visualizzazione di una finestra di dialogo "L'applicazione non risponde" da parte di Android. Chiamalo da un thread separato nel client.
- Solo i tipi di eccezione elencati nella documentazione di riferimento per
Parcel.writeException()vengono inviati al chiamante.
Esporre l'interfaccia ai client
Dopo aver implementato l'interfaccia per il tuo servizio, devi esporla ai client in modo che possano associarla. Per esporre l'interfaccia per il tuo servizio, estendi Service e implementa onBind() per restituire un'istanza della tua classe che implementa l'interfaccia Stub generata, come descritto nella sezione precedente. Ecco un esempio di servizio che espone l'interfaccia di esempio IRemoteService ai client.
class RemoteService : Service() { override fun onCreate() { super.onCreate() } override fun onBind(intent: Intent): IBinder { // Return the interface. return binder } private val binder = object : IRemoteService.Stub() { override fun getPid(): Int { return Process.myPid() } override fun basicTypes( anInt: Int, aLong: Long, aBoolean: Boolean, aFloat: Float, aDouble: Double, aString: String ) { // Does nothing. } } }
Ora, quando un client, ad esempio un'attività, chiama bindService() per connettersi a questo servizio, il callback onServiceConnected() del client riceve l'istanza binder restituita dal metodo onBind() del servizio.
Il client deve avere accesso anche alla classe di interfaccia. Quindi, se il client e il servizio si trovano in applicazioni separate, l'applicazione del client deve avere una copia del file .aidl nella directory src/, che genera l'interfaccia android.os.Binder, fornendo al client l'accesso ai metodi AIDL.
Quando il client riceve IBinder
nel callback onServiceConnected(), deve chiamare
YourServiceInterface.Stub.asInterface(service) per eseguire il cast del parametro restituito
al tipo YourServiceInterface:
var iRemoteService: IRemoteService? = null val mConnection = object : ServiceConnection { // Called when the connection with the service is established. override fun onServiceConnected(className: ComponentName, service: IBinder) { // Following the preceding example for an AIDL interface, // this gets an instance of the IRemoteInterface, which we can use to call on the service. iRemoteService = IRemoteService.Stub.asInterface(service) } // Called when the connection with the service disconnects unexpectedly. override fun onServiceDisconnected(className: ComponentName) { Log.e(TAG, "Service has unexpectedly disconnected") iRemoteService = null } }
Per altri esempi di codice campione, consulta la classe RemoteService.java in ApiDemos.
Passaggio di oggetti tramite IPC
In Android 10 (livello API 29 o versioni successive), puoi definire gli oggetti Parcelable direttamente in AIDL. Anche i tipi supportati come argomenti dell'interfaccia AIDL e altri parcelable sono supportati qui. In questo modo si evita il lavoro aggiuntivo di scrivere manualmente il codice di marshalling e una classe personalizzata. Tuttavia, questo crea anche una struttura vuota. Se vuoi utilizzare funzioni di accesso personalizzate o altre funzionalità, implementa Parcelable.
package android.graphics;
// Declare Rect so AIDL can find it and knows that it implements
// the parcelable protocol.
parcelable Rect {
int left;
int top;
int right;
int bottom;
}
L'esempio di codice precedente genera automaticamente una classe Java con i campi interi left, top, right e bottom. Tutto il codice di marshalling pertinente viene implementato automaticamente e l'oggetto può essere utilizzato direttamente senza dover aggiungere alcuna implementazione.
Puoi anche inviare una classe personalizzata da un processo a un altro tramite un'interfaccia IPC. Tuttavia, assicurati che il codice della tua classe sia disponibile per l'altro lato del canale IPC e che la tua classe supporti l'interfaccia Parcelable. Il supporto di Parcelable è importante perché consente al sistema Android di scomporre gli oggetti in primitive che possono essere sottoposte a marshalling tra i processi.
Per creare una classe personalizzata che supporti Parcelable, segui questi passaggi:
- Fai in modo che la tua classe implementi l'interfaccia
Parcelable. - Implementa
writeToParcel, che prende lo stato attuale dell'oggetto e lo scrive in unParcel. - Aggiungi alla tua classe un campo statico denominato
CREATOR, che è un oggetto che implementa l'interfacciaParcelable.Creator. - Infine, crea un file
.aidlche dichiari la classe parcelable, come mostrato per il seguente fileRect.aidl.Se utilizzi un processo di build personalizzato, non aggiungere il file
.aidlalla build. Analogamente a un file di intestazione nel linguaggio C, questo file.aidlnon viene compilato.
AIDL utilizza questi metodi e campi nel codice che genera per eseguire il marshalling e l'unmarshalling dei tuoi oggetti.
Ad esempio, ecco un file Rect.aidl per creare una classe Rect che è
parcelable:
package android.graphics; // Declare Rect so AIDL can find it and knows that it implements // the parcelable protocol. parcelable Rect;
Ecco un esempio di come la classe Rect implementa il protocollo Parcelable.
// import android.os.Parcel // import android.os.Parcelable class Rect() : Parcelable { var left: Int = 0 var top: Int = 0 var right: Int = 0 var bottom: Int = 0 companion object CREATOR : Parcelable.Creator<Rect> { override fun createFromParcel(parcel: Parcel): Rect { return Rect(parcel) } override fun newArray(size: Int): Array<Rect?> { return Array(size) { null } } } private constructor(inParcel: Parcel) : this() { readFromParcel(inParcel) } override fun writeToParcel(outParcel: Parcel, flags: Int) { outParcel.writeInt(left) outParcel.writeInt(top) outParcel.writeInt(right) outParcel.writeInt(bottom) } private fun readFromParcel(inParcel: Parcel) { left = inParcel.readInt() top = inParcel.readInt() right = inParcel.readInt() bottom = inParcel.readInt() } override fun describeContents(): Int { return 0 } }
Il marshalling nella classe Rect è semplice. Dai un'occhiata agli altri metodi su Parcel per vedere gli altri tipi di valori che puoi scrivere in un Parcel.
Avviso: ricorda le implicazioni di sicurezza della ricezione di dati da altri processi. In questo caso, Rect legge quattro numeri da Parcel, ma spetta a te assicurarti che rientrino nell'intervallo di valori accettabile per qualsiasi operazione che il chiamante sta tentando di eseguire. Per ulteriori informazioni su come proteggere la tua applicazione dal malware, consulta i Suggerimenti per la sicurezza.
Metodi con argomenti Bundle contenenti Parcelable
Se un metodo accetta un oggettoBundle che dovrebbe contenere
parcelable, assicurati di impostare il classloader di Bundle
chiamando Bundle.setClassLoader(ClassLoader) prima di tentare di leggere
da Bundle. In caso contrario, viene generato un errore ClassNotFoundException anche se il parcelable è definito correttamente nella tua applicazione.
Ad esempio, considera il seguente file .aidl di esempio:
// IRectInsideBundle.aidl package com.example.android; /** Example service interface. */ interface IRectInsideBundle { /** Rect parcelable is stored in the bundle with key "rect". */ void saveRect(in Bundle bundle); }
ClassLoader viene impostato esplicitamente in Bundle prima di leggere Rect:
private val binder = object : IRectInsideBundle.Stub() { override fun saveRect(bundle: Bundle) { bundle.classLoader = classLoader val rect = BundleCompat.getParcelable(bundle, "rect", Rect::class.java) process(rect) // Do more with the parcelable. } }
Chiamata di un metodo IPC
Per chiamare un'interfaccia remota definita con AIDL, segui questi passaggi nella classe di chiamata:
- Includi il file
.aidlnella directorysrc/del progetto. - Dichiara un'istanza dell'interfaccia
IBinder, che viene generata in base all'AIDL. - Implementa
ServiceConnection. - Chiama
Context.bindService(), passando l'implementazione diServiceConnection. - Nella tua implementazione di
onServiceConnected(), ricevi un'istanzaIBinder, chiamataservice. ChiamaYourInterfaceName.Stub.asInterface((IBinder)service)per eseguire il cast del parametro restituito al tipoYourInterface. - Chiama i metodi definiti nell'interfaccia. Intercetta sempre le eccezioni
DeadObjectException, che vengono generate quando la connessione si interrompe. Inoltre, intercetta le eccezioniSecurityException, che vengono generate quando i due processi coinvolti nella chiamata al metodo IPC hanno definizioni AIDL in conflitto. - Per disconnetterti, chiama
Context.unbindService()con l'istanza della tua interfaccia.
Tieni presente questi punti quando chiami un servizio IPC:
- Gli oggetti vengono conteggiati per riferimento tra i processi.
- Puoi inviare oggetti anonimi come argomenti del metodo.
Per saperne di più sull'associazione a un servizio, consulta la panoramica dei servizi associati.
Ecco un codice campione che mostra la chiamata di un servizio creato con AIDL, tratto dall'esempio di servizio remoto nel progetto ApiDemos.
private const val BUMP_MSG = 1 class Binding : Activity() { /** The primary interface you call on the service. */ private var mService: IRemoteService? = null /** Another interface you use on the service. */ internal var secondaryService: ISecondary? = null private lateinit var killButton: Button private lateinit var callbackText: TextView private lateinit var handler: InternalHandler private var isBound: Boolean = false /** * Class for interacting with the main interface of the service. */ private val mConnection = object : ServiceConnection { override fun onServiceConnected(className: ComponentName, service: IBinder) { // This is called when the connection with the service is // established, giving us the service object we can use to // interact with the service. We are communicating with our // service through an IDL interface, so get a client-side // representation of that from the raw service object. mService = IRemoteService.Stub.asInterface(service) killButton.isEnabled = true callbackText.text = "Attached." // We want to monitor the service for as long as we are // connected to it. try { mService?.registerCallback(mCallback) } catch (e: RemoteException) { // In this case, the service crashes before we can // do anything with it. We can count on soon being // disconnected (and then reconnected if it can be restarted) // so there is no need to do anything here. } // As part of the sample, tell the user what happened. Toast.makeText( this@Binding, R.string.remote_service_connected, Toast.LENGTH_SHORT ).show() } override fun onServiceDisconnected(className: ComponentName) { // This is called when the connection with the service is // unexpectedly disconnected—that is, its process crashed. mService = null killButton.isEnabled = false callbackText.text = "Disconnected." // As part of the sample, tell the user what happened. Toast.makeText( this@Binding, R.string.remote_service_disconnected, Toast.LENGTH_SHORT ).show() } } /** * Class for interacting with the secondary interface of the service. */ private val secondaryConnection = object : ServiceConnection { override fun onServiceConnected(className: ComponentName, service: IBinder) { // Connecting to a secondary interface is the same as any // other interface. secondaryService = ISecondary.Stub.asInterface(service) killButton.isEnabled = true } override fun onServiceDisconnected(className: ComponentName) { secondaryService = null killButton.isEnabled = false } } private val mBindListener = View.OnClickListener { // Establish a couple connections with the service, binding // by interface names. This lets other applications be // installed that replace the remote service by implementing // the same interface. val intent = Intent(this@Binding, RemoteService::class.java) intent.action = IRemoteService::class.java.name bindService(intent, mConnection, Context.BIND_AUTO_CREATE) intent.action = ISecondary::class.java.name bindService(intent, secondaryConnection, Context.BIND_AUTO_CREATE) isBound = true callbackText.text = "Binding." } private val unbindListener = View.OnClickListener { if (isBound) { // If we have received the service, and hence registered with // it, then now is the time to unregister. try { mService?.unregisterCallback(mCallback) } catch (e: RemoteException) { // There is nothing special we need to do if the service // crashes. } // Detach our existing connection. unbindService(mConnection) unbindService(secondaryConnection) killButton.isEnabled = false isBound = false callbackText.text = "Unbinding." } } private val killListener = View.OnClickListener { // To kill the process hosting the service, we need to know its // PID. Conveniently, the service has a call that returns // that information. try { secondaryService?.pid?.also { pid -> // Note that, though this API lets us request to // kill any process based on its PID, the kernel // still imposes standard restrictions on which PIDs you // can actually kill. Typically this means only // the process running your application and any additional // processes created by that app, as shown here. Packages // sharing a common UID are also able to kill each // other's processes. Process.killProcess(pid) callbackText.text = "Killed service process." } } catch (ex: RemoteException) { // Recover gracefully from the process hosting the // server dying. // For purposes of this sample, put up a notification. Toast.makeText(this@Binding, R.string.remote_call_failed, Toast.LENGTH_SHORT).show() } } // ---------------------------------------------------------------------- // Code showing how to deal with callbacks. // ---------------------------------------------------------------------- /** * This implementation is used to receive callbacks from the remote * service. */ private val mCallback = object : IRemoteServiceCallback.Stub() { /** * This is called by the remote service regularly to tell us about * new values. Note that IPC calls are dispatched through a thread * pool running in each process, so the code executing here is * NOT running in our main thread like most other things. So, * to update the UI, we need to use a Handler to hop over there. */ override fun valueChanged(value: Int) { handler.sendMessage(handler.obtainMessage(BUMP_MSG, value, 0)) } } /** * Standard initialization of this activity. Set up the UI, then wait * for the user to interact with it before doing anything. */ override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.remote_service_binding) // Watch for button taps. var button: Button = findViewById(R.id.bind) button.setOnClickListener(mBindListener) button = findViewById(R.id.unbind) button.setOnClickListener(unbindListener) killButton = findViewById(R.id.kill) killButton.setOnClickListener(killListener) killButton.isEnabled = false callbackText = findViewById(R.id.callback) callbackText.text = "Not attached." handler = InternalHandler(callbackText) } private class InternalHandler( textView: TextView, private val weakTextView: WeakReference<TextView> = WeakReference(textView) ) : Handler() { override fun handleMessage(msg: Message) { when (msg.what) { BUMP_MSG -> weakTextView.get()?.text = "Received from service: ${msg.arg1}" else -> super.handleMessage(msg) } } } }