Guide du développeur pour le SDK Runtime

Lorsque vous lisez la documentation concernant la Privacy Sandbox sur Android, cliquez sur le bouton Preview développeur ou Bêta pour sélectionner la version du programme que vous utilisez, car les instructions peuvent varier.

Envoyer un commentaire

Le SDK Runtime permet aux SDK de s'exécuter dans un bac à sable dédié distinct de l'application appelante. Il offre des protections et des garanties améliorées concernant la collecte des données utilisateur. Pour cela, il utilise un environnement d'exécution modifié qui limite les droits d'accès aux données et l'ensemble des autorisations définies. Pour en savoir plus sur SDK Runtime, consultez la proposition de conception.

Cette page vous guide tout au long du processus de création d'un SDK compatible avec l'environnement d'exécution et qui définit une vue Web pouvant être affichée à distance dans une application appelante.

Limites connues

Pour obtenir la liste des fonctionnalités en cours de développement pour le SDK Runtime, consultez les notes de version.

Les limites suivantes devraient être corrigées dans la prochaine version majeure de la plate-forme Android.

  • Rendu des annonces dans une vue déroulante Par exemple, RecyclerView ne fonctionne pas comme prévu.
    • Vous risquez de rencontrer des à-coups lors du redimensionnement.
    • Les événements de défilement tactile de l'utilisateur ne sont pas correctement transmis dans l'environnement d'exécution.
  • API Storage

Le problème suivant sera résolu en 2023 :

  • Les API getAdId et getAppSetId ne fonctionnent pas encore correctement, car leur prise en charge n'a pas encore été activée.

Avant de commencer

Avant de commencer, procédez comme suit :

  1. Configurez votre environnement de développement pour la Privacy Sandbox sur Android. Les outils qui prennent en charge le SDK Runtime évoluent en permanence. Vous devez donc utiliser la dernière version Canary d'Android Studio. Vous pouvez exécuter cette version d'Android Studio parallèlement aux autres versions dont vous disposez. Toutefois, veuillez nous contacter si vous ne parvenez pas à remplir cette condition.

  2. Installez une image système sur un appareil compatible ou configurez un émulateur prenant en charge la Privacy Sandbox sur Android.

Configurer votre projet dans Android Studio

Pour tester le SDK Runtime, utilisez un modèle semblable au modèle client/serveur. La principale différence réside dans le fait que les applications (le "client") et les SDK (le "serveur") s'exécutent sur le même appareil.

  1. Ajoutez un module d'application à votre projet. Ce module servira de client pour piloter le SDK.
  2. Dans votre module d'application, activez le SDK Runtime, déclarez les autorisations nécessaires et configurez les services publicitaires spécifiques à l'API.
  3. Ajoutez un module de bibliothèque à votre projet. Ce module contient le code de votre SDK.
  4. Dans le module de votre SDK, déclarez les autorisations nécessaires. Vous n'avez pas besoin d'y configurer de services publicitaires spécifiques aux API.
  5. Supprimez les dependencies du fichier build.gradle du module de bibliothèque que le SDK n'utilise pas. Dans la plupart des cas, vous pouvez supprimer toutes les dépendances. Pour ce faire, créez un répertoire dont le nom correspond au SDK.

  6. Créez manuellement un module à l'aide du type com.android.privacy-sandbox-sdk. Fourni avec le code du SDK, il permet de générer un fichier APK qui pourra être déployé sur votre appareil. Pour ce faire, créez un répertoire dont le nom correspond au SDK. Ajoutez un fichier build.gradle vide. Le contenu de ce fichier sera renseigné plus loin dans ce guide.

  7. Ajoutez l'extrait suivant à votre fichier gradle.properties :

    android.experimental.privacysandboxsdk.enable=true

  8. Téléchargez l'image de l'émulateur Tiramisu (extension de niveau 4) et créez un émulateur avec cette image, qui inclura le Play Store.

Selon que vous êtes développeur de SDK ou d'application, la configuration finale peut être différente de celle décrite dans le paragraphe précédent.

Installez le SDK sur un appareil de test, comme vous le feriez pour une application, à l'aide d'Android Studio ou d'Android Debug Bridge (ADB). Pour vous aider à faire vos premiers pas, nous avons créé des applications exemples dans les langages de programmation Kotlin et Java. Vous les trouverez dans ce dépôt GitHub. Le fichier README et les fichiers manifestes contiennent des commentaires décrivant les éléments à modifier pour exécuter l'exemple dans les versions stables d'Android Studio.

Préparer votre SDK

  1. Créez manuellement un répertoire au niveau du module. Il servira de wrapper au code d'implémentation qui permettra de créer le fichier APK du SDK. Dans le nouveau répertoire, insérez un fichier build.gradle et ajoutez-lui l'extrait de code suivant. Attribuez un nom unique à votre SDK compatible avec l'environnement d'exécution (RE-SDK), puis indiquez une version. Incluez le module de bibliothèque dans la section 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>')
}

  2. Créez une classe dans la bibliothèque d'implémentation. Celle-ci servira de point d'entrée pour votre SDK. Le nom de la classe doit correspondre à la valeur de sdkProviderClassName et doit étendre SandboxedSdkProvider.

Le point d'entrée de votre SDK étend SandboxedSdkProvider. L'élément SandboxedSdkProvider contient un objet Context pour votre SDK, auquel vous pouvez accéder en appelant getContext(). Ce contexte ne doit être accessible qu'une fois qu'onLoadSdk() a été appelé.

Pour que votre application SDK effectue la compilation, vous devez remplacer les méthodes de gestion du cycle de vie du SDK :

onLoadSdk()

Charge le SDK dans le bac à sable et informe l'application appelante qu'il est prêt à gérer les requêtes en transmettant son interface en tant qu'objet IBinder encapsulé dans un nouvel objet SandboxedSdk. Le guide des services liés propose différentes manières de renvoyer un objet IBinder. Vous êtes libre de choisir votre méthode, mais elle doit être cohérente avec le SDK et l'application appelante.

En utilisant AIDL comme exemple, vous devez définir un fichier AIDL pour présenter l'objet IBinder qui sera partagé et utilisé par l'appli :

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

Crée et configure la vue pour votre annonce, l'initialise de la même manière que les autres vues Android, puis la renvoie pour qu'elle s'affiche à distance dans une fenêtre d'une largeur et d'une hauteur données en pixels.

L'extrait de code suivant montre comment remplacer ces méthodes :

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

Tester les lecteurs vidéo dans le SDK Runtime

En plus de prendre en charge les bannières publicitaires, la Privacy Sandbox vise à permettre l'exécution des lecteurs vidéo dans le SDK Runtime.

La procédure de test des lecteurs vidéo est semblable à celle des bannières. Modifiez la méthode getView() du point d'entrée de votre SDK pour inclure un lecteur vidéo dans l'objet View renvoyé. Testez tous les flux du lecteur vidéo qui devraient être pris en charge par la Privacy Sandbox. Notez que la communication entre le SDK et l'application cliente concernant le cycle de vie de la vidéo n'est pas prise en compte. Nous n'avons donc pas encore besoin de commentaires sur cette fonctionnalité.

Vos tests et vos retours permettent d'assurer que le SDK Runtime couvrira tous les cas d'utilisation de votre lecteur vidéo de prédilection.

L'extrait de code suivant montre comment renvoyer une vue simple d'une vidéo qui se charge depuis une 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;
        }
    }

Utiliser des API de stockage dans votre SDK

Les SDK exécutés dans le SDK Runtime ne peuvent plus accéder à la mémoire de stockage interne d'une application, et inversement. La lecture et l'écriture n'y sont pas possibles non plus. Le SDK Runtime dispose de sa propre zone de stockage interne. La séparation de l'application est donc garantie.

Les SDK accèdent à cette mémoire de stockage interne distincte à l'aide des API de stockage de fichiers au niveau de l'objet Context renvoyé par SandboxedSdkProvider#getContext(). Les SDK ne peuvent utiliser que la mémoire de stockage interne. Par conséquent, seules les API de stockage interne, telles que Context.getFilesDir() ou Context.getCacheDir(), fonctionnent. Consultez d'autres exemples dans la section Accès depuis la mémoire de stockage interne.

L'accès au stockage externe à partir du SDK Runtime n'est pas possible. L'appel d'API pour accéder à un stockage externe génère une exception ou renvoie null. Voici plusieurs exemples :

Dans Android 13, tous les SDK de SDK Runtime partagent la mémoire de stockage interne allouée à SDK Runtime. Le stockage est conservé jusqu'à ce que l'application cliente soit désinstallée ou que les données de l'application cliente soient nettoyées.

Vous devez utiliser l'objet Context renvoyé par SandboxedSdkProvider.getContext() pour le stockage. L'utilisation de l'API de stockage de fichiers sur une autre instance d'objet Context, telle que le contexte de l'application, ne fonctionnera pas forcément dans toutes les situations. De même, rien ne garantit qu'elle continuera à fonctionner à l'avenir.

L'extrait de code suivant montre comment utiliser le stockage dans SDK Runtime :

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

}

Stockage par SDK

Dans la mémoire de stockage interne distincte de chaque SDK Runtime, chaque SDK a son propre répertoire de stockage. Le stockage par SDK est une séparation logique de la mémoire de stockage interne du SDK Runtime, qui permet de prendre en compte la quantité d'espace de stockage utilisée par chaque SDK.

Sur Android 13, une seule API affiche un chemin d'accès vers le stockage par SDK : Context#getDataDir().

Sur Android 14, toutes les API de stockage interne de l'objet Context affichent un chemin de stockage pour chaque SDK. Vous devrez peut-être activer cette fonctionnalité en exécutant la commande adb suivante :

adb shell device_config put adservices sdksandbox_customized_sdk_context_enabled true

Accéder à l'identifiant publicitaire fourni par les services Google Play

Si votre SDK a besoin d'accéder à l'identifiant publicitaire fourni par les services Google Play :

  • Déclarez l'autorisation android.permission.ACCESS_ADSERVICES_AD_ID dans le fichier manifeste du SDK.
  • Utilisez AdIdManager#getAdId() pour récupérer la valeur de manière asynchrone.

Accéder à l'ID du groupe d'applications fourni par les services Google Play

Si votre SDK a besoin d'accéder à l'ID du groupe d'applications fourni par les services Google Play :

  • Utilisez AppSetIdManager#getAppSetId() pour récupérer la valeur de manière asynchrone.

Mettre à jour les applications clientes

Pour appeler un SDK qui s'exécute dans le SDK Runtime, apportez les modifications suivantes à l'application cliente appelante :

  1. Ajoutez les autorisations INTERNET et ACCESS_NETWORK_STATE au fichier manifeste de votre application :

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

  2. Dans l'activité de votre application qui inclut une annonce, déclarez une référence à SdkSandboxManager, une valeur booléenne permettant de savoir si le SDK est chargé, et un objet SurfaceView pour l'affichage à distance :

    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;

  3. Déterminez si SDK Runtime est disponible sur l'appareil.

    1. Vérifiez la constante SdkSandboxState (getSdkSandboxState()). SDK_SANDBOX_STATE_ENABLED_PROCESS_ISOLATION signifie que le SDK Runtime est disponible.

    2. Vérifiez que l'appel de loadSdk() a réussi. L'appel aboutit si aucune exception n'est générée et que le destinataire est l'instance de SandboxedSdk.

      • Appelez loadSdk() au premier plan. Si vous l'appelez en arrière-plan, une exception SecurityException sera générée.

      • Recherchez une instance de SandboxedSdk dans OutcomeReceiver pour vérifier si une exception LoadSdkException a été générée. Une exception peut indiquer que SDK Runtime n'est pas disponible.

    Si l'appel de SdkSandboxState ou loadSdk échoue, SDK Runtime n'est pas disponible, et l'appel devrait être renvoyé au SDK existant.

  4. Pour définir une classe de rappel, implémentez OutcomeReceiver afin de permettre l'interaction avec le SDK dans l'environnement d'exécution après son chargement. Dans l'exemple suivant, le client utilise un rappel pour attendre le chargement complet du SDK, puis tente d'afficher une vue Web à partir du SDK. Les rappels seront définis ultérieurement dans cette étape.

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

    Pour récupérer une vue à distance à partir du SDK dans l'environnement d'exécution tout en appelant requestSurfacePackage(), implémentez l'interface 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
        }
    }

    Lorsque vous avez terminé d'afficher la vue, n'oubliez pas de libérer SurfacePackage en appelant la méthode suivante :

    surfacePackage.notifyDetachedFromWindow()

  5. Dans onCreate(), initialisez SdkSandboxManager, les rappels nécessaires, puis exécutez une requête pour charger le 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);
}

  6. Pour gérer les cas où le processus du bac à sable du SDK se termine de manière inattendue, définissez une implémentation pour l'interface 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);
          }
      }

    Pour enregistrer ce rappel afin de recevoir des informations sur l'arrêt du bac à sable du SDK, ajoutez la ligne suivante à tout moment :

    Kotlin

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

    Java

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

    Comme l'état du bac à sable est perdu lors de l'arrêt de son processus, les vues affichées à distance par le SDK peuvent ne plus fonctionner correctement. Pour continuer à interagir avec les SDK, ces vues doivent être chargées à nouveau afin qu'un nouveau processus de bac à sable soit lancé.

  7. Ajoutez une dépendance au niveau du module SDK dans le fichier build.gradle de votre application cliente :

    dependencies {
    ...
    implementation project(':<your-sdk-module>')
    ...
}

Tester vos applications

Pour exécuter votre application cliente, installez l'application SDK et l'application cliente sur l'appareil de test à l'aide d'Android Studio ou de la ligne de commande.

Effectuer un déploiement via Android Studio

Lors du déploiement via Android Studio, procédez comme suit :

  1. Ouvrez le projet Android Studio pour votre application cliente.
  2. Accédez à Run > Edit Configurations (Exécuter > Modifier les configurations). La fenêtre Run/Debug Configuration (Configuration d'exécution/de débogage) s'affiche.
  3. Sous Launch Options (Options de lancement), définissez Launch (Lancer) sur Specified Activity (Activité spécifiée).
  4. Cliquez sur le menu à trois points à côté de l'option "Activity" (Activité), puis sélectionnez Main Activity (Activité principale) pour votre client.
  5. Cliquez sur Apply (Appliquer), puis sur OK.
  6. Cliquez sur Run (Exécuter) pour installer l'application cliente et le SDK sur l'appareil de test.

Effectuer un déploiement via la ligne de commande

Lors du déploiement à l'aide de la ligne de commande, procédez comme indiqué dans la liste suivante. Cette section suppose que le nom du module d'application SDK est sdk-app et que celui du module d'application cliente est client-app.

  1. À partir d'un terminal de ligne de commande, créez les fichiers APK du SDK Privacy Sandbox :

    ./gradlew :client-app:buildPrivacySandboxSdkApksForDebug

    Cette commande indique l'emplacement des fichiers APK générés. Ces fichiers APK sont signés avec votre clé de débogage locale. Vous aurez besoin de ce chemin dans la commande suivante.

  2. Installez le fichier APK sur votre appareil :

    adb install -t /path/to/your/standalone.apk

  3. Dans Android Studio, sélectionnez Run > Edit Configurations (Exécuter > Modifier les configurations). La fenêtre Run/Debug Configuration (Configuration d'exécution/de débogage) s'affiche.

  4. Sous Installation Options (Options d'installation), définissez Déploy (Déployer) sur Default APK (APK par défaut).

  5. Cliquez sur Apply (Appliquer), puis sur OK.

  6. Cliquez sur Run (Exécuter) pour installer le fichier APK sur votre appareil de test.

Déboguer vos applications

Pour déboguer l'application cliente, cliquez sur le bouton Debug (Déboguer) dans Android Studio.

Pour déboguer l'application SDK, accédez à Run > Attach to Process (Exécuter > Joindre au processus), qui affiche un écran pop-up (figure 1). Cochez l'option Show all processes (Afficher tous les processus). Dans la liste qui s'affiche, recherchez un processus appelé CLIENT_APP_PROCESS_sdk_sandbox. Sélectionnez cette option et ajoutez des points d'arrêt dans le code de l'application SDK pour commencer à déboguer le SDK.

Le processus de l'application SDK s'affiche sous forme de liste en bas de la boîte de dialogue
Figure 1. Écran de sélection, qui permet de sélectionner l'application SDK à déboguer

Démarrer et arrêter le SDK Runtime à partir de la ligne de commande

Pour lancer le processus du SDK Runtime pour votre application, utilisez la commande shell suivante :

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

De même, pour arrêter le SDK Runtime, exécutez la commande suivante :

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

Limites

Pour obtenir la liste des fonctionnalités en cours de développement pour le SDK Runtime, consultez les notes de version.

Exemples de code

Pour vous aider à faire vos premiers pas, le dépôt des API de protection de la confidentialité et du SDK Runtime sur GitHub contient un ensemble de projets Android Studio individuels, y compris des exemples qui montrent comment initialiser et appeler le SDK Runtime.

Signaler des bugs et des problèmes

Vos commentaires sont essentiels pour la Privacy Sandbox sur Android. Signalez-nous les problèmes que vous rencontrez et vos idées pour améliorer Privacy Sandbox sur Android.