Skip to content

Most visited

Recently visited

navigation

Android インターフェース定義言語(AIDL)

AIDL(Android インターフェース定義言語)は、広く使用されている IDL の一種で、 クライアントとサービスがプロセス間通信(IPC)で相互に通信するために双方が合意する必要があるプログラミング インターフェースを定義するものです。 通常、Android のプロセスは、別のプロセスのメモリにアクセスすることはできません。 そのため、相互に通信を行うには、オペレーティング システムが理解できるプリミティブにオブジェクトを分解し、プロセスの境界をまたいでから再度オブジェクトとしてまとめなおす(マーシャルする)必要があります。 このマーシャル処理を実行するコードを毎回記述するのは非効率なので、Android が AIDL を利用してその処理を代行するようになっています。

注: AIDL の利用が必須となるのは、クライアントが別のアプリケーションから IPC を実行し、かつサービスがマルチスレッド対応である場合のみです。 別のアプリケーションから並列に IPC を行う必要がない場合は、Binder を実装してインターフェースを作成します。また、IPC を実行してもマルチスレッドに対応する必要がない場合は、Messenger を使用してインターフェースを実装します。いずれの場合も、AIDL を実装する前にバインドされたサービスについて理解するようにしてください。

AIDL インターフェースの設計を始める前に、AIDL インターフェースの呼び出しは直接関数呼び出しであることに注意する必要があります。 どのスレッドから呼び出されるかを仮定することはできません。 ローカル プロセスのスレッドからの呼び出しか、リモート プロセスのスレッドからの呼び出しかによって、実行される処理は異なります。 特に次の点に注意が必要です。

AIDL インターフェースの定義

AIDL インターフェースは、Java プログラミング言語の構文を使用して .aidl ファイルで定義します。このファイルは、サービスをホストするアプリと、サービスにバインドするすべてのアプリのソースコード(src/ ディレクトリ内)に保存します。

.aidl ファイルを含むアプリをビルドすると、Android SDK ツールが .aidl ファイルに基づいて IBinder インターフェースを生成し、その結果をプロジェクトの gen/ ディレクトリに保存します。 サービスは、必要に応じて IBinder インターフェースを実装します。 その後、クライアント アプリケーションをサービスにバインドし、IBinder からメソッドを呼び出して IPC を実行できるようになります。

AIDL を使用してバインドされたサービスを作成するには、次の手順に従います。

  1. .aidl ファイルを作成する

    このファイルでは、メソッド シグネチャを使ってプログラミング インターフェースを定義します。

  2. インターフェースを実装する

    Android SDK ツールが .aidl ファイルに基づいて Java プログラミング言語でインターフェースを生成します。 このインターフェースには、Stub という名前の内部抽象クラスがあります。これは Binder を拡張したクラスで、AIDL インターフェースで定義されたメソッドを実装しています。 この Stub クラスを拡張してメソッドを実装します。

  3. インターフェースをクライアントに公開する

    Service を実装して onBind() をオーバーライドし、Stub クラスの実装を返すようにします。

警告: 最初のリリース後に AIDL インターフェースを変更する場合は、サービスを利用する他のアプリケーションで問題が発生しないように、下方互換性を持たせる必要があります。 サービスのインターフェースにアクセスするアプリは .aidl ファイルのコピーを保持しています。そのため、元のインターフェースを維持する必要があります。

1 .aidl ファイルを作成する

AIDL では、パラメータと戻り値を持つ 1 つまたは複数のメソッドでインターフェースを宣言できる簡単な構文を使用します。 パラメータと戻り値には任意の型を指定できます。他の AIDL が生成するインターフェースを使用することもできます。

まず、Java プログラミング言語で記述した .aidl ファイルを作成する必要があります。.aidl ファイルでは、1 つのインターフェースを宣言します。必要となるのは、インターフェースの宣言とメソッドのシグネチャのみです。

AIDL はデフォルトで次のデータ型をサポートします。

ここに記載されていないその他の型を使用する場合は、import 文が必要になります。インターフェースと同じパッケージで定義されている場合でも、インポート宣言が必要です。

サービス インターフェースを定義する際には、次の点に注意してください。

.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, to do evil things with it. */
    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);
}

.aidl ファイルは、プロジェクトの src/ ディレクトリに保存します。アプリをビルドすると、SDK ツールがプロジェクトの gen/ ディレクトリに IBinder インターフェース ファイルを生成します。 生成されたファイル名は .aidl ファイルの名前と同じですが、拡張子は .java になります。たとえば、IRemoteService.aidl から IRemoteService.java が生成されます。

Android Studio を使用している場合、増分ビルドによりバインダクラスがほぼ瞬時に生成されます。Android Studio を使用していない場合は、次にアプリをビルドする際に Gradle ツールがバインダクラスを生成します。生成されるクラスにコードをリンクできるように、.aidl ファイルの記述後、できるだけ早くプロジェクトのビルドを行ってください。プロジェクトのビルドは、gradle assembleDebug(または gradle assembleRelease)で実行します。

2 インターフェースを実装する

アプリをビルドすると、Android SDK ツールは .aidl ファイルと同じ名前の .java インターフェース ファイルを生成します。 生成されたインターフェースには、Stub という名前のサブクラスが含まれています。このクラス(たとえば、YourInterface.Stub)は、親インターフェースを実装する抽象クラスであり、.aidl ファイルのすべてのメソッドが宣言されています。

注: Stub には、いくつかのヘルパー メソッドも定義されています。中でも有用なのが asInterface() です。このメソッドは、IBinder(通常は、クライアントの onServiceConnected() コールバック メソッドに渡されるもの)を受け取り、AIDL で定義されたインターフェースのインスタンスを返します。 このメソッドの詳細については、IPC メソッドの呼び出しのセクションをご覧ください。

.aidl から生成されたインターフェースを実装するには、生成された Binder インターフェース(たとえば、YourInterface.Stub)を拡張し、そのクラスで .aidl ファイルから継承されたメソッドを実装します。

次の例では、IRemoteService インターフェース(前述の IRemoteService.aidl の例で定義したもの)を匿名インスタンスで実装しています。

private final IRemoteService.Stub mBinder = new IRemoteService.Stub() {
    public int getPid(){
        return Process.myPid();
    }
    public void basicTypes(int anInt, long aLong, boolean aBoolean,
        float aFloat, double aDouble, String aString) {
        // Does nothing
    }
};

これによって、mBinderStub クラスのインスタンスが代入されます。このクラスは Binder を継承しており、サービスへの RPC インターフェースが定義されています。 次のステップでは、このインスタンスをクライアントに公開し、クライアントがサービスと通信できるようにします。

AIDL インターフェースを実装する場合、次のルールに注意する必要があります。

3 インターフェースをクライアントに公開する

実装したサービスのインターフェースは、公開してクライアントがバインドできるようにします。 サービスのインターフェースを公開するには、Service を拡張して onBind() を実装し、生成された Stub を実装するクラス(前のセクションで作成したクラス)のインスタンスを返すようにします。 次に、IRemoteService サンプル インターフェースをクライアントに公開するサービスの例を示します。

public class RemoteService extends Service {
    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent) {
        // Return the interface
        return mBinder;
    }

    private final IRemoteService.Stub mBinder = new IRemoteService.Stub() {
        public int getPid(){
            return Process.myPid();
        }
        public void basicTypes(int anInt, long aLong, boolean aBoolean,
            float aFloat, double aDouble, String aString) {
            // Does nothing
        }
    };
}

クライアント(アクティビティなど)がこのサービスに接続するために bindService() を呼び出すと、クライアントは onServiceConnected() コールバックで、サービスの onBind() メソッドが返す mBinder インスタンスを受信します。

クライアントはインターフェースのクラスにアクセスできる必要があります。そのため、クライアントとサービスが別のアプリである場合は、クライアント アプリの src/ ディレクトリに .aidl ファイルのコピーを置く必要があります。そうすることによって android.os.Binder インターフェースが生成され、クライアントが AIDL のメソッドにアクセスできるようになります。

onServiceConnected() コールバックで IBinder を受信した後、クライアントは YourServiceInterface.Stub.asInterface(service) を呼び出し、受け取ったパラメータを YourServiceInterface 型にキャストします。 次に例を示します。

IRemoteService mIRemoteService;
private ServiceConnection mConnection = new ServiceConnection() {
    // Called when the connection with the service is established
    public void onServiceConnected(ComponentName className, IBinder service) {
        // Following the example above for an AIDL interface,
        // this gets an instance of the IRemoteInterface, which we can use to call on the service
        mIRemoteService = IRemoteService.Stub.asInterface(service);
    }

    // Called when the connection with the service disconnects unexpectedly
    public void onServiceDisconnected(ComponentName className) {
        Log.e(TAG, "Service has unexpectedly disconnected");
        mIRemoteService = null;
    }
};

他のサンプルコードについては、ApiDemosRemoteService.java クラスをご覧ください。

IPC によるオブジェクトの受け渡し

IPC インターフェースでは、プロセス間でクラスを受け渡しすることもできます。 その場合、クラスは Parcelable インターフェースを実装し、IPC の通信相手側もクラスのコードを利用できる必要があります。 Parcelable インターフェースを実装すると、Android システムはオブジェクトをプリミティブに分解し、プロセスをまたいでからマーシャルすることができるようになるため、この実装は重要です。

Parcelable プロトコルをサポートするクラスを作成するには、以下の手順に従います。

  1. クラスで Parcelable インターフェースを実装します。
  2. writeToParcel メソッドを実装します。このメソッドで、オブジェクトの現在の状態を取得して Parcel に書き込みます。
  3. クラスに CREATOR という静的フィールドを追加します。これは、Parcelable.Creator インターフェースを実装するオブジェクトです。
  4. 最後に、.aidl ファイルを作成し、Parcelable を実装したクラスを宣言します(下記の Rect.aidl ファイルを参照)。

    カスタム ビルドプロセスを使用している場合は、ビルド対象に .aidl ファイルを追加しないでください。 C 言語のヘッダー ファイルと同様に、.aidl ファイルはコンパイルするものではありません。

AIDL は、生成されたコードのメソッドやフィールドを利用して、オブジェクトのマーシャルやアンマーシャルを行います。

たとえば、次の例は Parcelable な Rect クラスを作成する Rect.aidl ファイルです。

package android.graphics;

// Declare Rect so AIDL can find it and knows that it implements
// the parcelable protocol.
parcelable Rect;

また、次の例は Rect クラスで Parcelable プロトコルを実装する方法を示しています。

import android.os.Parcel;
import android.os.Parcelable;

public final class Rect implements Parcelable {
    public int left;
    public int top;
    public int right;
    public int bottom;

    public static final Parcelable.Creator<Rect> CREATOR = new
Parcelable.Creator<Rect>() {
        public Rect createFromParcel(Parcel in) {
            return new Rect(in);
        }

        public Rect[] newArray(int size) {
            return new Rect[size];
        }
    };

    public Rect() {
    }

    private Rect(Parcel in) {
        readFromParcel(in);
    }

    public void writeToParcel(Parcel out) {
        out.writeInt(left);
        out.writeInt(top);
        out.writeInt(right);
        out.writeInt(bottom);
    }

    public void readFromParcel(Parcel in) {
        left = in.readInt();
        top = in.readInt();
        right = in.readInt();
        bottom = in.readInt();
    }
}

Rect クラスのマーシャル処理は、非常に簡単です。Parcel に書き込むことができる他のタイプの値については、Parcel の他のメソッドをご確認ください。

警告: 他のプロセスからデータを受け取ることによるセキュリティ面での影響も考慮するようにしてください。 この場合、RectParcel から数値を読み出しますが、呼び出し元が指定した数値が有効な値の範囲に収まっているかどうかは、受信側で確認する必要があります。 アプリケーションをマルウェアから保護する方法の詳細については、セキュリティとパーミッションをご覧ください。

IPC メソッドの呼び出し

次に、AIDL で定義されたリモート インターフェースを呼び出す際に、呼び出し側のクラスが従う必要がある手順を示します。

  1. プロジェクトの src/ ディレクトリに .aidl ファイルを置きます。
  2. AIDL に基づいて生成される IBinder インターフェースのインスタンスを宣言します。
  3. ServiceConnection を実装する。
  4. Context.bindService() を呼び出します。その際に、ServiceConnection の実装を渡します。
  5. 実装した onServiceConnected()IBinder インスタンス(service パラメータ)が渡されます。 YourInterfaceName.Stub.asInterface((IBinder)service) を呼び出して、受け取ったパラメータを YourInterface 型に変換します。
  6. インターフェースで定義したメソッドを呼び出します。接続が切れたときにスローされる DeadObjectException に対する例外処理は必ず行ってください。リモート メソッドからスローされるのは、この例外のみです。
  7. 接続を切断するには、インターフェースのインスタンスを指定して Context.unbindService() を呼び出します。

IPC サービスを呼び出す際は、次の点に注意してください。

サービスへのバインドの詳細については、バインドされたサービスをご覧ください。

次に示すのは、AIDL によって作成されたサービスを呼び出すサンプルコードです。このコードは、ApiDemos プロジェクトのリモート サービス サンプルからの抜粋です。

public static class Binding extends Activity {
    /** The primary interface we will be calling on the service. */
    IRemoteService mService = null;
    /** Another interface we use on the service. */
    ISecondary mSecondaryService = null;

    Button mKillButton;
    TextView mCallbackText;

    private boolean mIsBound;

    /**
     * Standard initialization of this activity.  Set up the UI, then wait
     * for the user to poke it before doing anything.
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.remote_service_binding);

        // Watch for button clicks.
        Button button = (Button)findViewById(R.id.bind);
        button.setOnClickListener(mBindListener);
        button = (Button)findViewById(R.id.unbind);
        button.setOnClickListener(mUnbindListener);
        mKillButton = (Button)findViewById(R.id.kill);
        mKillButton.setOnClickListener(mKillListener);
        mKillButton.setEnabled(false);

        mCallbackText = (TextView)findViewById(R.id.callback);
        mCallbackText.setText("Not attached.");
    }

    /**
     * Class for interacting with the main interface of the service.
     */
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            // This is called when the connection with the service has been
            // 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);
            mKillButton.setEnabled(true);
            mCallbackText.setText("Attached.");

            // We want to monitor the service for as long as we are
            // connected to it.
            try {
                mService.registerCallback(mCallback);
            } catch (RemoteException e) {
                // In this case the service has crashed before we could even
                // 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(Binding.this, R.string.remote_service_connected,
                    Toast.LENGTH_SHORT).show();
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service has been
            // unexpectedly disconnected -- that is, its process crashed.
            mService = null;
            mKillButton.setEnabled(false);
            mCallbackText.setText("Disconnected.");

            // As part of the sample, tell the user what happened.
            Toast.makeText(Binding.this, R.string.remote_service_disconnected,
                    Toast.LENGTH_SHORT).show();
        }
    };

    /**
     * Class for interacting with the secondary interface of the service.
     */
    private ServiceConnection mSecondaryConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            // Connecting to a secondary interface is the same as any
            // other interface.
            mSecondaryService = ISecondary.Stub.asInterface(service);
            mKillButton.setEnabled(true);
        }

        public void onServiceDisconnected(ComponentName className) {
            mSecondaryService = null;
            mKillButton.setEnabled(false);
        }
    };

    private OnClickListener mBindListener = new OnClickListener() {
        public void onClick(View v) {
            // Establish a couple connections with the service, binding
            // by interface names.  This allows other applications to be
            // installed that replace the remote service by implementing
            // the same interface.
            Intent intent = new Intent(Binding.this, RemoteService.class);
            intent.setAction(IRemoteService.class.getName());
            bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
            intent.setAction(ISecondary.class.getName());
            bindService(intent, mSecondaryConnection, Context.BIND_AUTO_CREATE);
            mIsBound = true;
            mCallbackText.setText("Binding.");
        }
    };

    private OnClickListener mUnbindListener = new OnClickListener() {
        public void onClick(View v) {
            if (mIsBound) {
                // If we have received the service, and hence registered with
                // it, then now is the time to unregister.
                if (mService != null) {
                    try {
                        mService.unregisterCallback(mCallback);
                    } catch (RemoteException e) {
                        // There is nothing special we need to do if the service
                        // has crashed.
                    }
                }

                // Detach our existing connection.
                unbindService(mConnection);
                unbindService(mSecondaryConnection);
                mKillButton.setEnabled(false);
                mIsBound = false;
                mCallbackText.setText("Unbinding.");
            }
        }
    };

    private OnClickListener mKillListener = new OnClickListener() {
        public void onClick(View v) {
            // To kill the process hosting our service, we need to know its
            // PID.  Conveniently our service has a call that will return
            // to us that information.
            if (mSecondaryService != null) {
                try {
                    int pid = mSecondaryService.getPid();
                    // Note that, though this API allows us to request to
                    // kill any process based on its PID, the kernel will
                    // still impose standard restrictions on which PIDs you
                    // are actually able to 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 will also be able to kill each
                    // other's processes.
                    Process.killProcess(pid);
                    mCallbackText.setText("Killed service process.");
                } catch (RemoteException ex) {
                    // Recover gracefully from the process hosting the
                    // server dying.
                    // Just for purposes of the sample, put up a notification.
                    Toast.makeText(Binding.this,
                            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 IRemoteServiceCallback mCallback = new 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 will
         * NOT be running in our main thread like most other things -- so,
         * to update the UI, we need to use a Handler to hop over there.
         */
        public void valueChanged(int value) {
            mHandler.sendMessage(mHandler.obtainMessage(BUMP_MSG, value, 0));
        }
    };

    private static final int BUMP_MSG = 1;

    private Handler mHandler = new Handler() {
        @Override public void handleMessage(Message msg) {
            switch (msg.what) {
                case BUMP_MSG:
                    mCallbackText.setText("Received from service: " + msg.arg1);
                    break;
                default:
                    super.handleMessage(msg);
            }
        }

    };
}

This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a one-minute survey?
Help us improve Android tools and documentation.