Initialiser le SDK Android (ancien)

Les partenaires de Rokt peuvent utiliser le SDK Android pour afficher des placements en superposition 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. Rokt Widget est maintenant disponible sur Maven Central à partir des versions 4.9.0 et supérieures.

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. Ajouter le module SDK Android de Rokt
2. Initialiser le SDK Android de Rokt

Après avoir suivi ces étapes, la méthode execute du SDK peut ensuite ê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 que vous savez comment installer un plugin pour le développement Android.

Configuration du SDK Android

1. Ajoutez la bibliothèque du SDK Android Rokt à votre fichier de construction Gradle pour le module.

Kotlin

build.gradle.kts

dependencies {
    ...
    implementation("com.rokt:roktsdk:4.x.x")
    ...
}

Groovy

build.gradle

 // file => build.gradle (Module: ...)

dependencies {
    ...
    implementation 'com.rokt:roktsdk:4.x.x'
    ...
}

2. Initialisez le SDK Rokt avant de l'utiliser dans n'importe quelle activité. Nous recommandons d'appeler la méthode init depuis votre classe d'application.

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

Java

import com.rokt.roktsdk.Rokt

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

Kotlin

import com.rokt.roktsdk.Rokt;

public class YourApplication extends Application {
    @Override
    public void onCreate() {
        ...
        // Ce qui suit révélera une intégration de démonstration. Pour voir votre intégration :
        // 1) Remplacez l'ID de tag de test d'intégration (222) par votre ID de tag Rokt unique
        // 2) Remplacez Y.Y.Y par la version de l'application
        Rokt.INSTANCE.init("222", "Y.Y.Y", this)
        ...
    }
}

Initialisation avec des polices

remarque

Cette fonctionnalité est prise en charge à partir de la version 4.2.0 du SDK Android de 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à intégrées à votre application. Cela présente l'avantage d'éliminer la possibilité que les polices soient téléchargées lors de l'initialisation, réduisant ainsi l'utilisation du réseau et les risques d'erreurs de téléchargement. Vous pouvez choisir d'utiliser soit les ressources de polices situées dans le répertoire assets de votre application, soit de passer vos propres objets Typeface.

Utilisation des polices dans les assets

Vous pouvez utiliser les polices stockées dans le répertoire assets de votre application. Pour cela, vous pouvez passer une map à la méthode init qui associe les noms postscript des polices au chemin d'accès dans le répertoire assets (où le répertoire assets est le répertoire racine). Les noms postscript doivent correspondre à ceux utilisés dans votre mise en page, veuillez vérifier avec votre gestionnaire de compte si vous n'êtes pas sûr.

Java

import com.rokt.roktsdk.Rokt

public class YourApplication: Application() {
    override fun onCreate() {
        ...
        Rokt.init(
            "222",
            "Y.Y.Y",
            this,
            fontFilePathMap = mapOf("Arial-Bold" to "fonts/arialbold.otf")
        )
        ...
    }
}

Kotlin

import com.rokt.roktsdk.Rokt;

public class YourApplication extends Application {
    @Override
    public void onCreate() {
        ...
        Map<String,String> fontFilePathMap = new HashMap<>();
        fontFilePathMap.put("Arial-Bold", "fonts/arialbold.otf");
        Rokt.INSTANCE.init(
            "222",
            "Y.Y.Y",
            this,
            new HashSet<>(), // fontPostScriptNames peut être vide
            fontFilePathMap
        );
        ...
    }
}

Utilisation des polices de caractères

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

Java

import com.rokt.roktsdk.Rokt

public class YourApplication: Application() {
    override fun onCreate() {
        ...
        Rokt.init(
            "222",
            "Y.Y.Y",
            this,
            fontPostScriptNames = setOf("Arial-Bold")
        )
        ...
    }
}

Kotlin

import com.rokt.roktsdk.Rokt;

public class YourApplication extends Application {
    @Override
    public void onCreate() {
        ...
        Set<String> fontPostScriptNames = new HashSet<String>();
        fontPostScriptNames.add("Arial-Bold");
        Rokt.INSTANCE.init(
            "222",
            "Y.Y.Y",
            this,
            fontPostScriptNames
        );
        ...
    }
}

Recevoir le statut d'initialisation

À partir de la version 4.6.0, le SDK Rokt fournit 2 façons de recevoir le statut de l'initialisation :

Callback optionnel lors de 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 YourApplication: Application {
    override fun onCreate() {
        ...
        Rokt.init("222",
                  "Y.Y.Y",
                  this,
                  callback = object : Rokt.RoktInitCallback {
                      override fun onInitComplete(success: Boolean) {
                          Log.d("Rokt", "initialisation terminée reçue $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", "initialisation terminée reçue $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 :

• Ajout d'un emplacement
• Enregistrer les conversions