Aller au contenu principal

Initialiser le SDK Android

Les partenaires Rokt peuvent utiliser le SDK Android pour afficher des emplacements superposés ou intégrés, tandis que les marques Rokt peuvent l'utiliser pour enregistrer des conversions pour leurs campagnes. Le SDK Android de Rokt est déployé en utilisant Maven et Gradle.

remarque

Le SDK Android de Rokt contient des règles ProGuard et ne nécessite pas de configuration supplémentaire.

Tous les cas d'utilisation du SDK suivent les mêmes étapes initiales pour intégrer et initialiser le SDK. À un niveau élevé, ces étapes sont :

  1. Configurer un espace de travail et activer le référentiel Gradle de Rokt
  2. Ajouter le plugin Rokt Placement
  3. Ajouter le module SDK Android de Rokt
  4. Initialiser le SDK Android de Rokt

Après avoir suivi ces étapes, la méthode execute du SDK peut être utilisée de différentes manières pour s'adapter au cas d'utilisation requis.

Avant de commencer​

Ce guide suppose que vous êtes familier avec Gradle et savez comment installer un plugin pour le développement Android.

Configuration du SDK Android​

  1. Configurez un espace de travail et activez le dépôt Gradle de Rokt. Pour configurer un dépôt, suivez les instructions de Gradle.
  2. Ajoutez l'URL du dépôt du plugin Rokt Widget dans le fichier settings.gradle du projet.
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven("https://apps.rokt.com/msdk")
    }
}

Ou si vous utilisez une version de Gradle inférieure à 7.0.0 où les paramètres du dépôt sont au lieu de cela dans le fichier build.gradle de premier niveau, ajoutez ce qui suit dans le fichier build.gradle.

 // fichier => build.gradle.kts (Projet : ....)

allprojects {
    repositories {
        google()
        mavenCentral()
        maven("https://apps.rokt.com/msdk")
    }
}
  1. (Optionnel) Si vous utilisez un catalogage de versions, ajoutez le module Rokt Android SDK à votre libs.versions.toml (ou autre catalogue nommé).
[versions]
roktsdk = "4.6.1"

[libraries]
roktsdk = { group = "com.rokt", name = "roktsdk", version.ref = "roktsdk" }
  1. Ajoutez le module Rokt Android SDK à build.gradle pour le module.

Avec le Catalogue de Version​

 // fichier => build.gradle.kts (Module: ...)

dependencies {
    ...
    implementation(libs.roktsdk)
    ...
}

Sans le Catalogue de Version​

 // fichier => build.gradle.kts (Module: ...)

dependencies {
    ...
    implementation('com.rokt:roktsdk:4.6.1')
    ...
}
  1. Initialiser le SDK de Rokt avant de l'utiliser dans toute activité. Nous vous recommandons d'appeler la méthode init depuis la classe LauncherActivity.
attention

Contactez Rokt pour obtenir l'ID de compte Rokt associé à votre compte. Pour tester votre intégration, vous pouvez utiliser l'ID de compte Rokt ci-dessous, mais vous devez le remplacer par votre ID de compte Rokt unique avant de lancer en production.

ID de compte de test : 222

import com.rokt.roktsdk.Rokt;

public class LauncherActivity extends Activity {
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        // Ce qui suit révélera une intégration de démonstration. Pour voir votre intégration :
        // 1) Remplacez l'ID de balise de test d'intégration (222) par votre ID de balise Rokt unique
        // 2) Remplacez Y.Y.Y par la version de l'application
        Rokt.INSTANCE.init("222", "Y.Y.Y", LauncherActivity.this)
        ...
    }
}

Initialisation avec des polices​

remarque

Cette fonctionnalité est prise en charge à partir de la version 4.2.0 du SDK Android Rokt.

Au lieu de ou en plus de fournir vos polices souhaitées sur One Platform, vous pouvez choisir d'utiliser les polices déjà incluses avec votre application. Cela présente l'avantage d'éliminer le potentiel de téléchargement de polices au moment de l'initialisation, réduisant ainsi l'utilisation du réseau et les risques d'erreurs de téléchargement. Vous pouvez choisir soit d'utiliser des ressources de police situées dans le répertoire assets de votre application, soit de passer vos propres objets Typeface.

Utilisation des actifs de police​

Vous pouvez utiliser les polices stockées dans le répertoire assets de votre application. Pour cela, vous pouvez passer une cartographie à la méthode init qui associe les noms de polices postscript aux chemins de fichiers dans le répertoire des actifs (où le répertoire des actifs est le répertoire racine). Les noms de postscript doivent correspondre à ceux utilisés dans votre mise en page, veuillez vérifier avec votre responsable de compte si vous avez des doutes.

import com.rokt.roktsdk.Rokt;

public class LauncherActivity extends Activity {
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        Map<String,String> fontFilePathMap = new HashMap<String, String>();
        fontFilePathMap.put("Arial-Bold", "fonts/arialbold.otf");
        Rokt.INSTANCE.init(
            "222",
            "Y.Y.Y",
            LauncherActivity.this,
            new HashSet<>(), // fontPostScriptNames peut être vide 
            fontFilePathMap
        );
        ...
    }
}

Utilisation des typographies​

Vous pouvez également utiliser des objets Typeface que vous avez créés dans votre application. Pour cela, vous devez passer un ensemble des noms postscript des polices à la fonction init, puis passer les Typefaces à la fonction execute (détaillé dans Ajout d'un placement). 

import com.rokt.roktsdk.Rokt;

public class LauncherActivity extends Activity {
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        Set<String> fontPostScriptNames = new HashSet<String>();
        fontFilePathMap.add("Arial-Bold");
        Rokt.INSTANCE.init(
            "222",
            "Y.Y.Y",
            LauncherActivity.this,
            fontPostScriptNames
        );
        ...
    }
}

Réception du statut d'initialisation​

Depuis la version 4.6.1, le SDK Rokt fournit 2 façons de recevoir le statut de l'initialisation :

Callback optionnel à l'initialisation​

Il y a un callback dans la méthode Rokt.init pour notifier lorsque l'initialisation est terminée et retourner le statut.

import com.rokt.roktsdk.Rokt

public class LauncherActivity: Activity {
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        Rokt.init("222",
                  "Y.Y.Y",
                  this@LauncherActivity,
                  callback = object : Rokt.RoktInitCallback {
                      override fun onInitComplete(success: Boolean) {
                          Log.d("Rokt", "received init completed $success")
                      }
                  },
        )
        ...
    }
}

API des événements globaux​

Le SDK fournit également le statut sous forme de flux via l'API Rokt.globalEvents. Les utilisateurs du SDK peuvent tirer parti du mécanisme Kotlin Flow pour consommer le statut.

// owner: LifecycleOwner
owner.lifecycleScope.launch {
    Rokt.globalEvents().collect { event ->
        if (event is RoktEvent.InitComplete)
            Log.d("Rokt", "received init completed $event")
    }
}

Débogage​

Utilisez l'API Rokt.setLoggingEnabled(enable = true) pour activer les journaux de débogage du SDK Rokt.

Prochaines étapes​

Les étapes suivantes dépendent de votre cas d'utilisation pour l'intégration. Consultez ces sujets pour en savoir plus :

Cet article vous a-t-il été utile ?