このページは Cloud Translation API によって翻訳されました。

SDK ランタイムデベロッパーガイド

Android 版プライバシーサンドボックスのドキュメントをご覧になる際は、[デベロッパープレビュー] または [ベータ版] ボタンで対象のプログラムバージョンを選択してください（手順が異なる場合があります）。

SDK ランタイムを使用すると、呼び出し元アプリとは別の専用のサンドボックスで SDK を実行でき、ユーザーデータの収集に関する安全性と確実性が向上します。SDK ランタイムは、実行環境を変更してデータアクセス権と許可された権限セットを制限することでこれを実現しています。SDK ランタイムの詳細については設計案をご覧ください。

このページでは、呼び出し元アプリにリモートでレンダリングできるウェブベースのビューを定義するランタイム対応の SDK を作成する手順について説明します。

既知の制限事項

SDK ランタイムに関する開発中の機能の一覧については、リリースノートをご覧ください。

以下の制限事項は、Android プラットフォームの次回のメジャーリリースで修正される予定です。

スクロール可能なビュー内での広告レンダリング。たとえば、RecyclerView は正しく機能しません。
- サイズ変更時にジャンクが発生することがあります。
- ユーザーのタッチスクロールイベントがランタイムに正しく渡されません。
Storage API
- Android 13 では、SDK ごとのストレージは使用できません。

以下の問題は 2023 年に修正される予定です。

getAdId API と getAppSetId API は、サポートがまだ有効になっていないため正しく機能しません。

始める前に

まず、次の手順を実施します。

Android 版プライバシーサンドボックス用に開発環境をセットアップします。SDK ランタイムをサポートするツールは現在開発中であるため、このガイドでは Android Studio の最新の Canary バージョンを使用すると想定しています。このバージョンの Android Studio は、使用する他のバージョンと並行して実行できるため、この要件が適していない場合は、Google までお知らせください。
サポート対象のデバイスにシステムイメージをインストールするか、Android 版プライバシーサンドボックスのサポートを含むエミュレータをセットアップします。

Android Studio でプロジェクトをセットアップする

SDK ランタイムを試すには、クライアントサーバーモデルに似たモデルを使用します。主な違いは、アプリ（クライアント）と SDK（サーバー）が同じデバイス上で実行されることです。

プロジェクトにアプリモジュールを追加します。このモジュールは SDK を動作させるクライアントとして機能します。
アプリモジュールで、SDK ランタイムを有効にし、必要な権限を宣言して、API 固有の広告サービスを構成します。
プロジェクトにライブラリモジュールを 1 つ追加します。このモジュールには SDK コードが含まれています。
SDK モジュールで、必要な権限を宣言します。API 固有の広告サービスをこのモジュールで構成する必要はありません。
SDK が使用していないライブラリモジュールの build.gradle ファイルから dependencies を削除します。ほとんどの場合、すべての依存関係を削除できます。これを行うには、SDK に対応する名前の新しいディレクトリを作成します。
com.android.privacy-sandbox-sdk タイプを使用して新しいモジュールを手動で作成します。これには、デバイスにデプロイ可能な APK を作成するための SDK コードがバンドルされています。これを行うには、SDK に対応する名前の新しいディレクトリを作成します。空の build.gradle ファイルを追加します。このファイルの内容は、このガイドの後半で追加します。
gradle.properties ファイルに次のスニペットを追加します。
```
android.experimental.privacysandboxsdk.enable=true
```
Tiramisu（Extension Level 4）エミュレータイメージをダウンロードし、このイメージを使用して Play ストアを含むエミュレータを作成します。

SDK デベロッパーなのかアプリデベロッパーなのかによって、最終的なセットアップが前の段落の内容と異なる場合があります。

アプリをインストールする場合と同様に、Android Studio または Android Debug Bridge（ADB）を使用してテストデバイスに SDK をインストールします。簡単に始められるよう、Kotlin と Java プログラミング言語を使用して作成したサンプルアプリを GitHub リポジトリで公開しています。README ファイルとマニフェストファイルには、Android Studio の安定版でサンプルを実行するために変更が必要な点について説明したコメントがあります。

SDK を準備する

モジュールレベルのディレクトリを手動で作成します。これは、SDK APK をビルドする実装コードのラッパーとして機能します。新しいディレクトリに build.gradle ファイルを追加し、このファイルに次のスニペットを入力します。ランタイム対応 SDK（RE-SDK）に一意の名前を使用し、バージョンを指定します。dependencies セクションにライブラリモジュールを含めます。
```
plugins {
    id 'com.android.privacy-sandbox-sdk'
}

android {
    compileSdk 33
    compileSdkExtension 4
    minSdk 33
    targetSdk 33
    namespace = "com.example.example-sdk"

    bundle {
        packageName = "com.example.privacysandbox.provider"
        sdkProviderClassName = "com.example.sdk_implementation.SdkProviderImpl"
        setVersion(1, 0, 0)
    }
}

dependencies {
    include project(':<your-library-here>')
}
```
実装ライブラリ内に、SDK のエントリポイントとして機能するクラスを作成します。クラスの名前は sdkProviderClassName の値にマッピングされ、SandboxedSdkProvider を拡張する必要があります。

SDK のエントリポイントは SandboxedSdkProvider を拡張します。SandboxedSdkProvider には SDK の Context オブジェクトが含まれています。このオブジェクトには、getContext() を呼び出してアクセスできます。このコンテキストにアクセスする必要があるのは、onLoadSdk() が呼び出されたときのみです。

SDK アプリをコンパイルするには、SDK ライフサイクルを処理するメソッドをオーバーライドする必要があります。

onLoadSdk()

サンドボックスで SDK を読み込み、SDK がリクエストを処理する準備ができたら、新しい SandboxedSdk オブジェクト内にラップされる IBinder オブジェクトとしてインターフェースを渡して呼び出し元アプリに通知します。バインドされたサービスに関するガイドで、IBinder を提供するさまざまな方法について説明しています。方法は柔軟に選択できますが、SDK と呼び出し元アプリで一貫している必要があります。

たとえば AIDL を使用する場合、アプリと共有されて使用される IBinder を提示する AIDL ファイルを定義する必要があります。

// ISdkInterface.aidl
interface ISdkInterface {
    // the public functions to share with the App.
    int doSomething();
}

getView()

広告のビューを作成してセットアップし、他の Android ビューと同じように初期化して、指定された幅と高さ（ピクセル単位）のウィンドウにリモートでレンダリングするためのビューを返します。

次のコードスニペットは、これらのメソッドをオーバーライドする方法を示しています。

Kotlin

class SdkProviderImpl : SandboxedSdkProvider() {
    override fun onLoadSdk(params: Bundle?): SandboxedSdk {
        // Returns a SandboxedSdk, passed back to the client. The IBinder used
        // to create the SandboxedSdk object is used by the app to call into the
        // SDK.
        return SandboxedSdk(SdkInterfaceProxy())
    }

    override fun getView(windowContext: Context, bundle: Bundle, width: Int,
            height: Int): View {
        val webView = WebView(windowContext)
        val layoutParams = LinearLayout.LayoutParams(width, height)
        webView.setLayoutParams(layoutParams)
        webView.loadUrl("https://developer.android.com/privacy-sandbox")
        return webView
    }

    private class SdkInterfaceProxy : ISdkInterface.Stub() {
        fun doSomething() {
            // Implementation of the API.
        }
    }
}

Java

public class SdkProviderImpl extends SandboxedSdkProvider {
    @Override
    public SandboxedSdk onLoadSdk(Bundle params) {
        // Returns a SandboxedSdk, passed back to the client. The IBinder used
        // to create the SandboxedSdk object is used by the app to call into the
        // SDK.
        return new SandboxedSdk(new SdkInterfaceProxy());
    }

    @Override
    public View getView(Context windowContext, Bundle bundle, int width,
            int height) {
        WebView webView = new WebView(windowContext);
        LinearLayout.LayoutParams layoutParams =
                new LinearLayout.LayoutParams(width, height);
        webView.setLayoutParams(layoutParams);
        webView.loadUrl("https://developer.android.com/privacy-sandbox");
        return webView;
    }

    private static class SdkInterfaceProxy extends ISdkInterface.Stub {
        @Override
        public void doSomething() {
            // Implementation of the API.
        }
    }
}

SDK ランタイムで動画プレーヤーをテストする

バナー広告のサポートに加え、プライバシーサンドボックスは、SDK ランタイム内で動作する動画プレーヤーのサポートも行っています。

動画プレーヤーをテストするフローは、バナー広告をテストする場合と似ています。返される View オブジェクトに動画プレーヤーが含まれるように、SDK のエントリポイントの getView() メソッドを変更します。プライバシーサンドボックスでサポートされると思われる動画プレーヤーのフローをすべてテストします。なお、動画のライフサイクルに関する SDK とクライアントアプリ間の通信は対象外であるため、この機能に関してフィードバックはまだ必要ありません。

テストとフィードバックを行うことで、お使いの動画プレーヤーのユースケースがすべて SDK ランタイムでサポートされるようになります。

次のコードスニペットは、URL から読み込むシンプルな動画ビューを返す方法を示しています。

Kotlin

    class SdkProviderImpl : SandboxedSdkProvider() {

        override fun getView(windowContext: Context, bundle: Bundle, width: Int,
                height: Int): View {
            val videoView = VideoView(windowContext)
            val layoutParams = LinearLayout.LayoutParams(width, height)
            videoView.setLayoutParams(layoutParams)
            videoView.setVideoURI(Uri.parse("https://test.website/video.mp4"))
            videoView.setOnPreparedListener { mp -> mp.start() }
            return videoView
        }
    }

Java

    public class SdkProviderImpl extends SandboxedSdkProvider {

        @Override
        public View getView(Context windowContext, Bundle bundle, int width,
                int height) {
            VideoView videoView = new VideoView(windowContext);
            LinearLayout.LayoutParams layoutParams =
                    new LinearLayout.LayoutParams(width, height);
            videoView.setLayoutParams(layoutParams);
            videoView.setVideoURI(Uri.parse("https://test.website/video.mp4"));
            videoView.setOnPreparedListener(mp -> {
                mp.start();
            });
            return videoView;
        }
    }

SDK でのストレージ API の使用

SDK ランタイムの SDK は、アプリの内部ストレージに対するアクセス、読み取り、書き込みができなくなります。その逆も同様です。SDK ランタイムには独自の内部ストレージ領域が割り当てられるため、アプリから切り離されます。

SDK は、SandboxedSdkProvider#getContext() によって返される Context オブジェクトのファイルストレージ API を使用して、この個別の内部ストレージにアクセスできます。SDK は内部ストレージのみを使用できるため、Context.getFilesDir() や Context.getCacheDir() などの内部ストレージ API のみが機能します。その他の例については、内部ストレージからアクセスするをご覧ください。

SDK ランタイムから外部ストレージへのアクセスはサポートされていません。API を呼び出して外部ストレージにアクセスすると、例外がスローされるか、null が返されます。次に例を示します。

ストレージアクセスフレームワークを使用してファイルにアクセスすると、SecurityException がスローされます。
getExternalFilsDir() は常に null を返します。

Android 13 では、SDK ランタイムのすべての SDK が、SDK ランタイムに割り当てられた内部ストレージを共有します。ストレージは、クライアントアプリをアンインストールするかクライアントアプリのデータをクリーンアップするまで、保持されます。

ストレージには、SandboxedSdkProvider.getContext() から返される Context を使用する必要があります。アプリコンテキストなど、他の Context オブジェクトインスタンスでファイルストレージ API を使用すると、あらゆる状況または将来において想定どおりに動作するとは限りません。

次のコードスニペットは、SDK ランタイムでストレージを使用する方法を示しています。

Kotlin

    private static class SdkInterfaceStorage extends ISdkInterface.Stub {
    override fun doSomething() {
        val filename = "myfile"
        val fileContents = "content"
        try {
            getContext().openFileOutput(filename, Context.MODE_PRIVATE).use {
                it.write(fileContents.toByteArray())
            } catch (e: Exception) {
                throw RuntimeException(e)
            }
        }
    }
}

Java

    private static class SdkInterfaceStorage extends ISdkInterface.Stub {
    @Override
    public void doSomething() {
        final filename = "myFile";
        final String fileContents = "content";
        try (FileOutputStream fos = getContext().openFileOutput(filename, Context.MODE_PRIVATE)) {
            fos.write(fileContents.toByteArray());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

SDK ごとのストレージ

各 SDK ランタイムの個別の内部ストレージ内に、各 SDK に独自のストレージディレクトリがあります。SDK ごとのストレージは、SDK ランタイムの内部ストレージを論理的に分離したもので、各 SDK が使用するストレージの量を把握するのに役立ちます。

Android 13 では、SDK ごとのストレージへのパスを返す API は 1 つだけです（Context#getDataDir()）。

Android 14 では、Context オブジェクトのすべての内部ストレージ API が、各 SDK のストレージパスを返します。場合によっては、次の adb コマンドを実行して、この機能を有効にする必要があります。

adb shell device_config put adservices sdksandbox_customized_sdk_context_enabled true

Google Play 開発者サービスから提供された広告 ID にアクセスする

Google Play 開発者サービスから提供された広告 ID に SDK がアクセスする必要がある場合、以下のようにします。

SDK のマニフェストで android.permission.ACCESS_ADSERVICES_AD_ID 権限を宣言します。
AdIdManager#getAdId() を使用して値を非同期で取得します。

Google Play 開発者サービスが提供するアプリセット ID にアクセスする

SDK が Google Play 開発者サービスから提供されたアプリセット ID にアクセスする必要がある場合、以下のようにします。

AppSetIdManager#getAppSetId() を使用して値を非同期で取得します。

クライアントアプリを更新する

SDK ランタイムで実行されている SDK を呼び出すには、呼び出し元のクライアントアプリを次のように変更します。

INTERNET 権限と ACCESS_NETWORK_STATE 権限をアプリマニフェストに追加します。

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

広告を含むアプリのアクティビティで、SdkSandboxManager への参照、SDK が読み込まれているかどうかを示すブール値、リモートレンダリング用の SurfaceView オブジェクトを宣言します。

Kotlin

    private lateinit var mSdkSandboxManager: SdkSandboxManager
    private lateinit var mClientView: SurfaceView
    private var mSdkLoaded = false

    companion object {
        private const val SDK_NAME = "com.example.privacysandbox.provider"
    }

Java

    private static final String SDK_NAME = "com.example.privacysandbox.provider";

    private SdkSandboxManager mSdkSandboxManager;
    private SurfaceView mClientView;
    private boolean mSdkLoaded = false;

デバイスで SDK ランタイムプロセスが利用可能かどうかを確認します。
1. SdkSandboxState の定数（getSdkSandboxState()）を確認します。SDK_SANDBOX_STATE_ENABLED_PROCESS_ISOLATION は、SDK ランタイムが使用可能であることを示します。
2. loadSdk() の呼び出しが成功したことを確認します。例外がスローされず、レシーバが SandboxedSdk のインスタンスであれば成功です。
  - フォアグラウンドから loadSdk() を呼び出します。バックグラウンドから呼び出されると、SecurityException がスローされます。
  - OutcomeReceiver の SandboxedSdk のインスタンスで LoadSdkException がスローされているかどうかを確認します。例外は、SDK ランタイムが利用できない可能性があることを示します。
SdkSandboxState または loadSdk の呼び出しが失敗した場合、SDK ランタイムは使用できなくなり、呼び出しは既存の SDK にフォールバックされます。

OutcomeReceiver を実装することでコールバッククラスを定義し、SDK が読み込まれたらランタイムで SDK を操作します。以下の例では、クライアントはコールバックを使用して SDK が正常に読み込まれるまで待ち、その後で SDK からウェブビューをレンダリングしようとします。コールバックはこのステップで後ほど定義します。

Kotlin

    private inner class LoadSdkOutcomeReceiverImpl private constructor() :
            OutcomeReceiver {

      override fun onResult(sandboxedSdk: SandboxedSdk) {
          mSdkLoaded = true

          val binder: IBinder = sandboxedSdk.getInterface()
          if (!binderInterface.isPresent()) {
              // SDK is not loaded anymore.
              return
          }
          val sdkInterface: ISdkInterface = ISdkInterface.Stub.asInterface(binder)
          sdkInterface.doSomething()

          Handler(Looper.getMainLooper()).post {
              val bundle = Bundle()
              bundle.putInt(SdkSandboxManager.EXTRA_WIDTH_IN_PIXELS, mClientView.getWidth())
              bundle.putInt(SdkSandboxManager.EXTRA_HEIGHT_IN_PIXELS, mClientView.getHeight())
              bundle.putInt(SdkSandboxManager.EXTRA_DISPLAY_ID, display!!.displayId)
              bundle.putInt(SdkSandboxManager.EXTRA_HOST_TOKEN, mClientView.getHostToken())
              mSdkSandboxManager!!.requestSurfacePackage(
                      SDK_NAME, bundle, { obj: Runnable -> obj.run() },
                      RequestSurfacePackageOutcomeReceiverImpl())
          }
      }

      override fun onError(error: LoadSdkException) {
              // Log or show error.
      }
    }

Java

    import static android.app.sdksandbox.SdkSandboxManager.EXTRA_DISPLAY_ID;
    import static android.app.sdksandbox.SdkSandboxManager.EXTRA_HEIGHT_IN_PIXELS;
    import static android.app.sdksandbox.SdkSandboxManager.EXTRA_HOST_TOKEN;
    import static android.app.sdksandbox.SdkSandboxManager.EXTRA_WIDTH_IN_PIXELS;

    private class LoadSdkOutcomeReceiverImpl
            implements OutcomeReceiver {
        private LoadSdkOutcomeReceiverImpl() {}

        @Override
        public void onResult(@NonNull SandboxedSdk sandboxedSdk) {
            mSdkLoaded = true;

            IBinder binder = sandboxedSdk.getInterface();
            if (!binderInterface.isPresent()) {
                // SDK is not loaded anymore.
                return;
            }
            ISdkInterface sdkInterface = ISdkInterface.Stub.asInterface(binder);
            sdkInterface.doSomething();

            new Handler(Looper.getMainLooper()).post(() -> {
                Bundle bundle = new Bundle();
                bundle.putInt(EXTRA_WIDTH_IN_PIXELS, mClientView.getWidth());
                bundle.putInt(EXTRA_HEIGHT_IN_PIXELS, mClientView.getHeight());
                bundle.putInt(EXTRA_DISPLAY_ID, getDisplay().getDisplayId());
                bundle.putInt(EXTRA_HOST_TOKEN, mClientView.getHostToken());

                mSdkSandboxManager.requestSurfacePackage(
                        SDK_NAME, bundle, Runnable::run,
                        new RequestSurfacePackageOutcomeReceiverImpl());
            });
        }

        @Override
        public void onError(@NonNull LoadSdkException error) {
            // Log or show error.
        }
    }

requestSurfacePackage() を呼び出しつつランタイムで SDK からリモートビューを取得するには、OutcomeReceiver<Bundle, RequestSurfacePackageException> インターフェースを実装します。

Kotlin

    private inner class RequestSurfacePackageOutcomeReceiverImpl :
            OutcomeReceiver {
        fun onResult(@NonNull result: Bundle) {
            Handler(Looper.getMainLooper())
                    .post {
                        val surfacePackage: SurfacePackage = result.getParcelable(
                                EXTRA_SURFACE_PACKAGE,
                                SurfacePackage::class.java)
                        mRenderedView.setChildSurfacePackage(surfacePackage)
                        mRenderedView.setVisibility(View.VISIBLE)
                    }
        }

        fun onError(@NonNull error: RequestSurfacePackageException?) {
            // Error handling
        }
    }

Java

    import static android.app.sdksandbox.SdkSandboxManager.EXTRA_SURFACE_PACKAGE;

    private class RequestSurfacePackageOutcomeReceiverImpl
            implements OutcomeReceiver {
        @Override
        public void onResult(@NonNull Bundle result) {
            new Handler(Looper.getMainLooper())
                    .post(
                            () -> {
                                SurfacePackage surfacePackage =
                                        result.getParcelable(
                                                EXTRA_SURFACE_PACKAGE,
                                                SurfacePackage.class);
                                mRenderedView.setChildSurfacePackage(surfacePackage);
                                mRenderedView.setVisibility(View.VISIBLE);
                            });
        }
        @Override
        public void onError(@NonNull RequestSurfacePackageException error) {
            // Error handling
        }
    }

ビューの表示が完了したら、以下を呼び出して SurfacePackage を解放します。

surfacePackage.notifyDetachedFromWindow()

onCreate() で、SdkSandboxManager と必要なコールバックを初期化し、SDK の読み込みをリクエストします。

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    mSdkSandboxManager = applicationContext.getSystemService(
            SdkSandboxManager::class.java
    )

    mClientView = findViewById(R.id.rendered_view)
    mClientView.setZOrderOnTop(true)

    val loadSdkCallback = LoadSdkCallbackImpl()
    mSdkSandboxManager.loadSdk(
            SDK_NAME, Bundle(), { obj: Runnable -> obj.run() }, loadSdkCallback
    )
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    mSdkSandboxManager = getApplicationContext().getSystemService(
            SdkSandboxManager.class);

    mClientView = findViewById(R.id.rendered_view);
    mClientView.setZOrderOnTop(true);

    LoadSdkCallbackImpl loadSdkCallback = new LoadSdkCallbackImpl();
    mSdkSandboxManager.loadSdk(
            SDK_NAME, new Bundle(), Runnable::run, loadSdkCallback);
}

SDK サンドボックスプロセスが予期せず終了した場合に対処するために、SdkSandboxProcessDeathCallback インターフェースの実装を定義します。

Kotlin

    private inner class SdkSandboxLifecycleCallbackImpl() : SdkSandboxProcessDeathCallback {
        override fun onSdkSandboxDied() {
            // The SDK runtime process has terminated. To bring back up the
            // sandbox and continue using SDKs, load the SDKs again.
            val loadSdkCallback = LoadSdkOutcomeReceiverImpl()
            mSdkSandboxManager.loadSdk(
                      SDK_NAME, Bundle(), { obj: Runnable -> obj.run() },
                      loadSdkCallback)
        }
    }

Java

      private class SdkSandboxLifecycleCallbackImpl
              implements SdkSandboxProcessDeathCallback {
          @Override
          public void onSdkSandboxDied() {
              // The SDK runtime process has terminated. To bring back up
              // the sandbox and continue using SDKs, load the SDKs again.
              LoadSdkOutcomeReceiverImpl loadSdkCallback =
                      new LoadSdkOutcomeReceiverImpl();
              mSdkSandboxManager.loadSdk(
                          SDK_NAME, new Bundle(), Runnable::run, loadSdkCallback);
          }
      }

このコールバックを登録し、SDK サンドボックスがいつ終了したかに関する情報を受け取るには、任意のタイミングで次の行を追加します。

Kotlin

    mSdkSandboxManager.addSdkSandboxProcessDeathCallback({ obj: Runnable -> obj.run() },
            SdkSandboxLifecycleCallbackImpl())

Java

    mSdkSandboxManager.addSdkSandboxProcessDeathCallback(Runnable::run,
            new SdkSandboxLifecycleCallbackImpl());

サンドボックスの状態はそのプロセスが終了すると失われます。そのため、SDK によってリモートでレンダリングされたビューが正しく機能しなくなる可能性があります。SDK の操作を継続するには、これらのビューを再度読み込んで、新しいサンドボックスプロセスを開始する必要があります。

SDK モジュールの依存関係をクライアントアプリの build.gradle に追加します。
```
dependencies {
    ...
    implementation project(':<your-sdk-module>')
    ...
}
```

アプリをテストする

クライアントアプリを実行するには、Android Studio またはコマンドラインを使用して、テストデバイスに SDK アプリとクライアントアプリをインストールします。

Android Studio を使用してデプロイする

Android Studio を使用してデプロイする手順は次のとおりです。

クライアントアプリの Android Studio プロジェクトを開きます。
[Run] > [Edit Configurations] に移動します。[Run/Debug Configuration] ウィンドウが表示されます。
[Launch Options] で、[Launch] を [Specified Activity] に設定します。
[Activity] の横にあるその他メニューをクリックし、クライアントの [Main Activity] を選択します。
[Apply]、[OK] の順にクリックします。
実行ボタンをクリックして、テストデバイスにクライアントアプリと SDK をインストールします。

コマンドラインでデプロイする

コマンドラインを使用してデプロイする場合の手順は次のとおりです。このセクションでは、SDK アプリモジュールの名前が sdk-app であり、クライアントアプリモジュールの名前が client-app であると仮定しています。

コマンドラインターミナルで、プライバシーサンドボックス SDK APK をビルドします。
```
./gradlew :client-app:buildPrivacySandboxSdkApksForDebug
```
これにより、生成された APK の場所が出力されます。この APK はローカルのデバッグ鍵で署名されています。このパスは次のコマンドで必要になります。
デバイスに APK をインストールします。
```
adb install -t /path/to/your/standalone.apk
```
Android Studio で、[Run] > [Edit Configurations] をクリックします。[Run/Debug Configuration] ウィンドウが表示されます。
[Installation Options] で [Deploy] を [Default APK] に設定します。
[Apply]、[OK] の順にクリックします。
[Run] をクリックして、テストデバイスに APK バンドルをインストールします。

アプリをデバッグする

クライアントアプリをデバッグするには、Android Studio でデバッグボタンをクリックします。

SDK アプリをデバッグするには、[Run] > [Attach to Process] に移動します。ポップアップ画面（下図）が表示されます。[Show all processes] チェックボックスをオンにします。表示されたリストの中から CLIENT_APP_PROCESS_sdk_sandbox というプロセスを探します。このオプションを選択し、SDK アプリのコードにブレークポイントを追加して、SDK のデバッグを開始します。

SDK アプリのプロセスはダイアログ下部のリストビューに表示される — デバッグする SDK アプリを選択できる [**Choose process**] 画面。

コマンドラインから SDK ランタイムを起動および停止する

アプリの SDK ランタイムプロセスを開始するには、次のシェルコマンドを使用します。

adb shell cmd sdk_sandbox start [--user <USER_ID> | current] <CLIENT_APP_PACKAGE>

同様に、SDK ランタイムプロセスを停止するには、次のコマンドを実行します。

adb shell cmd sdk_sandbox stop [--user <USER_ID> | current] <CLIENT_APP_PACKAGE>

制限事項

SDK ランタイムに関する開発中の機能の一覧については、リリースノートをご覧ください。

コードサンプル

GitHub の SDK ランタイムとプライバシー保護 API のリポジトリには、SDK ランタイムの初期化方法と呼び出し方法を示すサンプルなど、使用を開始するために役立つ個別の Android Studio プロジェクトのセットが含まれています。

バグと問題を報告する

皆様からのフィードバックは、Android 版プライバシーサンドボックスに欠かせない要素です。問題が見つかった場合や Android 版プライバシーサンドボックスを改善するためのアイデアがありましたらお知らせください。

あなたへのおすすめ

注: JavaScript がオフになっている場合はリンクテキストが表示されます
SDK ランタイム
リリースノート
Android 版 Protected Audience API デベロッパーガイド

SDK ランタイム デベロッパー ガイド

既知の制限事項

始める前に

Android Studio でプロジェクトをセットアップする

SDK を準備する

Kotlin

Java

SDK ランタイムで動画プレーヤーをテストする

Kotlin

Java

SDK でのストレージ API の使用

Kotlin

Java

SDK ごとのストレージ

Google Play 開発者サービスから提供された広告 ID にアクセスする

Google Play 開発者サービスが提供するアプリセット ID にアクセスする

クライアント アプリを更新する

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

アプリをテストする

Android Studio を使用してデプロイする

コマンドラインでデプロイする

アプリをデバッグする

コマンドラインから SDK ランタイムを起動および停止する

制限事項

コードサンプル

バグと問題を報告する

あなたへのおすすめ

SDK ランタイムデベロッパーガイド

クライアントアプリを更新する