Google is committed to advancing racial equity for Black communities. See how.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

Migrez votre application Parse Android vers Firebase

Si vous êtes un utilisateur Parse à la recherche d'une autre solution Backend as a Service, Firebase peut être le choix idéal pour votre application Android.

Ce guide décrit comment intégrer des services spécifiques dans votre application. Pour obtenir les instructions de configuration de base de Firebase, consultez le guide de configuration Android .

Google Analytics

Google Analytics est une solution gratuite de mesure des applications qui fournit des informations sur l'utilisation des applications et l'engagement des utilisateurs. Analytics s'intègre à toutes les fonctionnalités de Firebase et vous fournit des rapports illimités pour jusqu'à 500 événements distincts que vous pouvez définir à l'aide du SDK Firebase.

Consultez la documentation Google Analytics pour en savoir plus.

Stratégie de migration suggérée

L'utilisation de différents fournisseurs d'analyse est un scénario courant qui s'applique facilement à Google Analytics. Ajoutez-le simplement à votre application pour bénéficier des événements et des propriétés utilisateur qu'Analytics collecte automatiquement, comme la première ouverture, la mise à jour de l'application, le modèle d'appareil, l'âge.

Pour les événements personnalisés et les propriétés utilisateur, vous pouvez utiliser une stratégie de double écriture utilisant à la fois Parse Analytics et Google Analytics pour consigner les événements et les propriétés, ce qui vous permet de déployer progressivement la nouvelle solution.

Comparaison de code

Analyser les analyses

 // Start collecting data
ParseAnalytics.trackAppOpenedInBackground(getIntent());

Map<String, String> dimensions = new HashMap<String, String>();
// Define ranges to bucket data points into meaningful segments
dimensions.put("priceRange", "1000-1500");
// Did the user filter the query?
dimensions.put("source", "craigslist");
// Do searches happen more often on weekdays or weekends?
dimensions.put("dayType", "weekday");

// Send the dimensions to Parse along with the 'search' event
ParseAnalytics.trackEvent("search", dimensions);
 

Google Analytics

 // Obtain the FirebaseAnalytics instance and start collecting data
mFirebaseAnalytics = FirebaseAnalytics.getInstance(this);

Bundle params = new Bundle();
// Define ranges to bucket data points into meaningful segments
params.putString("priceRange", "1000-1500");
// Did the user filter the query?
params.putString("source", "craigslist");
// Do searches happen more often on weekdays or weekends?
params.putString("dayType", "weekday");

// Send the event
mFirebaseAnalytics.logEvent("search", params);
 

Base de données en temps réel Firebase

La base de données Firebase Realtime est une base de données NoSQL hébergée dans le cloud. Les données sont stockées au format JSON et synchronisées en temps réel sur chaque client connecté.

Consultez la documentation relative à Firebase Realtime Database pour en savoir plus.

Différences avec l'analyse des données

Objets

Dans Parse, vous stockez un ParseObject , ou une sous-classe de celui-ci, qui contient des paires clé-valeur de données compatibles JSON. Les données sont sans schéma, ce qui signifie que vous n'avez pas besoin de spécifier quelles clés existent sur chaque ParseObject .

Toutes les données de la base de données Firebase Realtime sont stockées en tant qu'objets JSON et il n'y a pas d'équivalent pour ParseObject ; vous écrivez simplement dans l'arborescence JSON des valeurs de types qui correspondent aux types JSON disponibles. Vous pouvez utiliser des objets Java pour simplifier la lecture et l'écriture à partir de la base de données.

Voici un exemple de la façon dont vous pouvez enregistrer les meilleurs scores d'un jeu.

Analyser
 @ParseClassName("GameScore")
public class GameScore {
        public GameScore() {}
        public GameScore(Long score, String playerName, Boolean cheatMode) {
            setScore(score);
            setPlayerName(playerName);
            setCheatMode(cheatMode);
        }

        public void setScore(Long score) {
            set("score", score);
        }

        public Long getScore() {
            return getLong("score");
        }

        public void setPlayerName(String playerName) {
            set("playerName", playerName);
        }

        public String getPlayerName() {
            return getString("playerName");
        }

        public void setCheatMode(Boolean cheatMode) {
            return set("cheatMode", cheatMode);
        }

        public Boolean getCheatMode() {
            return getBoolean("cheatMode");
        }
}

// Must call Parse.registerSubclass(GameScore.class) in Application.onCreate
GameScore gameScore = new GameScore(1337, "Sean Plott", false);
gameScore.saveInBackground();
 
Firebase
 // Assuming we defined the GameScore class as:
public class GameScore {
        private Long score;
        private String playerName;
        private Boolean cheatMode;

        public GameScore() {}
        public GameScore(Long score, String playerName, Boolean cheatMode) {
            this.score = score;
            this.playerName = playerName;
            this.cheatMode = cheatMode;
        }

        public Long getScore() {
            return score;
        }

        public String getPlayerName() {
            return playerName;
        }

        public Boolean getCheatMode() {
            return cheatMode;
        }
}

// We would save it to our list of high scores as follows:
DatabaseReference mFirebaseRef = FirebaseDatabase.getInstance().getReference();
GameScore score = new GameScore(1337, "Sean Plott", false);
mFirebaseRef.child("scores").push().setValue(score);
 
Pour plus de détails, consultez le guide Lire et écrire des données sur Android .

Relations entre les données

Un ParseObject peut avoir une relation avec un autre ParseObject : tout objet peut utiliser d'autres objets comme valeurs.

Dans la base de données Firebase Realtime, les relations sont mieux exprimées en utilisant des structures de données plates qui divisent les données en chemins séparés, afin qu'elles puissent être téléchargées efficacement dans des appels séparés.

Voici un exemple de la manière dont vous pouvez structurer la relation entre les articles d'une application de blog et leurs auteurs.

Analyser
 // Create the author
ParseObject myAuthor = new ParseObject("Author");
myAuthor.put("name", "Grace Hopper");
myAuthor.put("birthDate", "December 9, 1906");
myAuthor.put("nickname", "Amazing Grace");

// Create the post
ParseObject myPost = new ParseObject("Post");
myPost.put("title", "Announcing COBOL, a New Programming Language");

// Add a relation between the Post and the Author
myPost.put("parent", myAuthor);

// This will save both myAuthor and myPost
myPost.saveInBackground();
 
Firebase
 DatabaseReference firebaseRef = FirebaseDatabase.getInstance().getReference();
// Create the author
Map<String, String> myAuthor = new HashMap<String, String>();
myAuthor.put("name", "Grace Hopper");
myAuthor.put("birthDate", "December 9, 1906");
myAuthor.put("nickname", "Amazing Grace");

// Save the author
String myAuthorKey = "ghopper";
firebaseRef.child('authors').child(myAuthorKey).setValue(myAuthor);

// Create the post
Map<String, String> post = new HashMap<String, String>();
post.put("author", myAuthorKey);
post.put("title", "Announcing COBOL, a New Programming Language");
firebaseRef.child('posts').push().setValue(post);
 

La disposition des données suivante est le résultat.

{
  // Info about the authors
  "authors": {
    "ghopper": {
      "name": "Grace Hopper",
      "date_of_birth": "December 9, 1906",
      "nickname": "Amazing Grace"
    },
    ...
  },
  // Info about the posts: the "author" fields contains the key for the author
  "posts": {
    "-JRHTHaIs-jNPLXOQivY": {
      "author": "ghopper",
      "title": "Announcing COBOL, a New Programming Language"
    }
    ...
  }
}
Pour plus de détails, consultez le guide Structurer votre base de données .

Lecture des données

Dans Parse, vous lisez des données en utilisant soit l'ID d'un objet Parse spécifique, soit en exécutant des requêtes à l'aide de ParseQuery .

Dans Firebase, vous récupérez des données en attachant un écouteur asynchrone à une référence de base de données. L'écouteur est déclenché une fois pour l'état initial des données et à nouveau lorsque les données changent, vous n'aurez donc pas besoin d'ajouter de code pour déterminer si les données ont changé.

Voici un exemple de la façon dont vous pouvez récupérer les scores d'un joueur particulier, basé sur l'exemple présenté dans la section "Objets" .

Analyser
 ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.whereEqualTo("playerName", "Dan Stemkoski");
query.findInBackground(new FindCallback<ParseObject>() {
    public void done(List<ParseObject> scoreList, ParseException e) {
        if (e == null) {
            for (ParseObject score: scoreList) {
                Log.d("score", "Retrieved: " + Long.toString(score.getLong("score")));
            }
        } else {
            Log.d("score", "Error: " + e.getMessage());
        }
    }
});
 
Firebase
 DatabaseReference mFirebaseRef = FirebaseDatabase.getInstance().getReference();
Query mQueryRef = mFirebaseRef.child("scores").orderByChild("playerName").equalTo("Dan Stemkoski");

// This type of listener is not one time, and you need to cancel it to stop
// receiving updates.
mQueryRef.addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot snapshot, String previousChild) {
        // This will fire for each matching child node.
        GameScore score = snapshot.getValue(GameScore.class);
        Log.d("score", "Retrieved: " + Long.toString(score.getScore());
    }
});
 
Pour plus de détails sur les types d'écouteurs d'événements disponibles et sur la façon de classer et de filtrer les données, consultez le guide Lire et écrire des données sur Android .

Stratégie de migration suggérée

Repensez vos données

La base de données Firebase Realtime est optimisée pour synchroniser les données en millisecondes sur tous les clients connectés, et la structure de données qui en résulte est différente des données de base d'analyse. Cela signifie que la première étape de votre migration consiste à prendre en compte les modifications requises par vos données, notamment:

  • Comment vos objets Parse doivent correspondre aux données Firebase
  • Si vous avez des relations parent-enfant, comment diviser vos données sur différents chemins afin qu'elles puissent être téléchargées efficacement lors d'appels séparés.

Migrez vos données

Une fois que vous avez décidé comment structurer vos données dans Firebase, vous devez planifier comment gérer la période pendant laquelle votre application doit écrire dans les deux bases de données. Vos choix sont:

Synchronisation en arrière-plan

Dans ce scénario, vous disposez de deux versions de l'application: l'ancienne version qui utilise Parse et une nouvelle version qui utilise Firebase. Les synchronisations entre les deux bases de données sont gérées par Parse Cloud Code (Parse to Firebase), votre code écoutant les modifications sur Firebase et synchronisant ces modifications avec Parse. Avant de pouvoir utiliser la nouvelle version, vous devez:

  • Convertissez vos données d'analyse existantes dans la nouvelle structure Firebase et écrivez-les dans la base de données Firebase Realtime.
  • Ecrivez des fonctions d'analyse de code cloud qui utilisent l'API Firebase REST pour écrire dans la base de données Firebase Realtime les modifications apportées dans l'analyse des données par d'anciens clients.
  • Écrivez et déployez du code qui écoute les modifications sur Firebase et les synchronise avec la base de données Parse.

Ce scénario garantit une séparation nette entre l'ancien et le nouveau code et simplifie les clients. Les défis de ce scénario sont la gestion de grands ensembles de données lors de l'exportation initiale et la garantie que la synchronisation bidirectionnelle ne génère pas de récursivité infinie.

Double écriture

Dans ce scénario, vous écrivez une nouvelle version de l'application qui utilise à la fois Firebase et Parse, en utilisant Parse Cloud Code pour synchroniser les modifications apportées par les anciens clients à partir des données d'analyse vers la base de données Firebase Realtime. Lorsque suffisamment de personnes ont migré de la version d'analyse uniquement de l'application, vous pouvez supprimer le code d'analyse de la version en double écriture.

Ce scénario ne nécessite aucun code côté serveur. Ses inconvénients sont que les données non accessibles ne sont pas migrées et que la taille de votre application est augmentée par l'utilisation des deux SDK.

Authentification Firebase

L'authentification Firebase peut authentifier les utilisateurs à l'aide de mots de passe et de fournisseurs d'identité fédérés populaires tels que Google, Facebook et Twitter. Il fournit également des bibliothèques d'interface utilisateur pour vous faire économiser l'investissement significatif requis pour mettre en œuvre et maintenir une expérience d'authentification complète pour votre application sur toutes les plates-formes.

Consultez la documentation relative à l' authentification Firebase pour en savoir plus.

Différences avec Parse Auth

Parse fournit une classe d'utilisateurs spécialisée appelée ParseUser qui gère automatiquement les fonctionnalités requises pour la gestion des comptes d'utilisateurs. ParseUser est une sous-classe de ParseObject , ce qui signifie que les données utilisateur sont disponibles dans Parse Data et peuvent être étendues avec des champs supplémentaires comme tout autre ParseObject .

Un FirebaseUser possède un ensemble fixe de propriétés de base (un identifiant unique, une adresse e-mail principale, un nom et une URL de photo) stockés dans la base de données des utilisateurs d'un projet distinct; ces propriétés peuvent être mises à jour par l'utilisateur. Vous ne pouvez pas ajouter directement d'autres propriétés à l'objet FirebaseUser ; à la place, vous pouvez stocker les propriétés supplémentaires dans votre base de données Firebase Realtime.

Voici un exemple de la façon dont vous pouvez inscrire un utilisateur et ajouter un champ de numéro de téléphone supplémentaire.

Analyser
 ParseUser user = new ParseUser();
user.setUsername("my name");
user.setPassword("my pass");
user.setEmail("email@example.com");

// other fields can be set just like with ParseObject
user.put("phone", "650-253-0000");

user.signUpInBackground(new SignUpCallback() {
    public void done(ParseException e) {
        if (e == null) {
            // Hooray! Let them use the app now.
        } else {
            // Sign up didn't succeed. Look at the ParseException
            // to figure out what went wrong
        }
    }
});
 
Firebase
 FirebaseAuth mAuth = FirebaseAuth.getInstance();

mAuth.createUserWithEmailAndPassword("email@example.com", "my pass")
    .continueWithTask(new Continuation<AuthResult, Task<Void>> {
        @Override
        public Task<Void> then(Task<AuthResult> task) {
            if (task.isSuccessful()) {
                FirebaseUser user = task.getResult().getUser();
                DatabaseReference firebaseRef = FirebaseDatabase.getInstance().getReference();
                return firebaseRef.child("users").child(user.getUid()).child("phone").setValue("650-253-0000");
            } else {
                // User creation didn't succeed. Look at the task exception
                // to figure out what went wrong
                Log.w(TAG, "signInWithEmail", task.getException());
            }
        }
    });
 

Stratégie de migration suggérée

Migrer les comptes

Pour migrer les comptes utilisateur de Parse vers Firebase, exportez votre base de données utilisateur vers un fichier JSON ou CSV, puis importez le fichier dans votre projet Firebase à l'aide de la commande auth:import la CLI Firebase.

Tout d'abord, exportez votre base de données utilisateur depuis la console Parse ou votre base de données auto-hébergée. Par exemple, un fichier JSON exporté depuis la console Parse peut ressembler à ce qui suit:

{ // Username/password user
  "bcryptPassword": "$2a$10$OBp2hxB7TaYZgKyTiY48luawlTuYAU6BqzxJfpHoJMdZmjaF4HFh6",
  "email": "user@example.com",
  "username": "testuser",
  "objectId": "abcde1234",
  ...
},
{ // Facebook user
  "authData": {
    "facebook": {
      "access_token": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
      "expiration_date": "2017-01-02T03:04:05.006Z",
      "id": "1000000000"
    }
  },
  "username": "wXyZ987654321StUv",
  "objectId": "fghij5678",
  ...
}

Ensuite, transformez le fichier exporté au format requis par la CLI Firebase. Utilisez le objectId de vos utilisateurs Parse comme localId de vos utilisateurs Firebase. En outre, base64 codent les valeurs bcryptPassword de Parse et les utilise dans le champ passwordHash . Par exemple:

{
  "users": [
    {
      "localId": "abcde1234",  // Parse objectId
      "email": "user@example.com",
      "displayName": "testuser",
      "passwordHash": "JDJhJDEwJE9CcDJoeEI3VGFZWmdLeVRpWTQ4bHVhd2xUdVlBVTZCcXp4SmZwSG9KTWRabWphRjRIRmg2",
    },
    {
      "localId": "fghij5678",  // Parse objectId
      "displayName": "wXyZ987654321StUv",
      "providerUserInfo": [
        {
          "providerId": "facebook.com",
          "rawId": "1000000000",  // Facebook ID
        }
      ]
    }
  ]
}

Enfin, importez le fichier transformé avec la CLI Firebase, en spécifiant bcrypt comme algorithme de hachage:

firebase auth:import account_file.json --hash-algo=BCRYPT

Migrer les données utilisateur

Si vous stockez des données supplémentaires pour vos utilisateurs, vous pouvez les migrer vers Firebase Realtime Database à l'aide des stratégies décrites dans la section de migration des données . Si vous migrez des comptes en utilisant le flux décrit dans la section de migration des comptes , vos comptes Firebase ont les mêmes identifiants que vos comptes Parse, ce qui vous permet de migrer et de reproduire facilement les relations définies par l'ID utilisateur.

Messagerie Firebase Cloud

Firebase Cloud Messaging (FCM) est une solution de messagerie multiplateforme qui vous permet de transmettre de manière fiable des messages et des notifications sans frais. Le compositeur de notifications est un service gratuit basé sur Firebase Cloud Messaging qui permet des notifications utilisateur ciblées pour les développeurs d'applications mobiles.

Consultez la documentation de Firebase Cloud Messaging pour en savoir plus.

Différences avec l'analyse des notifications push

Chaque application Parse installée sur un appareil enregistré pour les notifications possède un objet Installation associé, dans lequel vous stockez toutes les données nécessaires pour cibler les notifications. Installation est une sous-classe de ParseUser , ce qui signifie que vous pouvez ajouter toutes les données supplémentaires que vous souhaitez à vos instances d' Installation .

Le composeur de notifications fournit des segments d'utilisateurs prédéfinis en fonction d'informations telles que l'application, la version de l'application et la langue de l'appareil. Vous pouvez créer des segments d'utilisateurs plus complexes à l'aide d'événements et de propriétés Google Analytics pour créer des audiences. Consultez le guide d'aide sur le public pour en savoir plus. Ces informations de ciblage ne sont pas visibles dans la base de données Firebase Realtime.

Stratégie de migration suggérée

Migration des jetons de périphérique

Au moment de la rédaction de cet article, le SDK Parse Android utilise une ancienne version des jetons d'enregistrement FCM, non compatible avec les fonctionnalités offertes par l'éditeur de notifications.

Vous pouvez obtenir un nouveau jeton en ajoutant le SDK FCM à votre application; cependant, cela peut invalider le jeton utilisé par le SDK Parse pour recevoir des notifications. Si vous souhaitez éviter cela, vous pouvez configurer le SDK Parse pour utiliser à la fois l'ID d'expéditeur de Parse et votre ID d'expéditeur. De cette façon, vous n'invalidez pas le jeton utilisé par le SDK Parse, mais sachez que cette solution de contournement cessera de fonctionner lorsque Parse arrête son projet.

Migration des canaux vers les rubriques FCM

Si vous utilisez Parse channels pour envoyer des notifications, vous pouvez migrer vers les rubriques FCM, qui fournissent le même modèle éditeur-abonné. Pour gérer la transition de Parse vers FCM, vous pouvez écrire une nouvelle version de l'application qui utilise le SDK Parse pour vous désabonner des canaux Parse et le FCM SDK pour vous abonner aux rubriques FCM correspondantes. Dans cette version de l'application, vous devez désactiver la réception de notifications sur le SDK Parse, en supprimant les éléments suivants du manifeste de votre application:

 <service android:name="com.parse.PushService" />
<receiver android:name="com.parse.ParsePushBroadcastReceiver"
  android:exported="false">
<intent-filter>
<action android:name="com.parse.push.intent.RECEIVE" />
<action android:name="com.parse.push.intent.DELETE" />
<action android:name="com.parse.push.intent.OPEN" />
</intent-filter>
</receiver>
<receiver android:name="com.parse.GcmBroadcastReceiver"
  android:permission="com.google.android.c2dm.permission.SEND">
<intent-filter>
<action android:name="com.google.android.c2dm.intent.RECEIVE" />
<action android:name="com.google.android.c2dm.intent.REGISTRATION" />

<!--
IMPORTANT: Change "com.parse.starter" to match your app's package name.
-->
<category android:name="com.parse.starter" />
</intent-filter>
</receiver>

<!--
IMPORTANT: Change "YOUR_SENDER_ID" to your GCM Sender Id.
-->
<meta-data android:name="com.parse.push.gcm_sender_id"
  android:value="id:YOUR_SENDER_ID" />;
 

Par exemple, si votre utilisateur est abonné à la rubrique "Géants", vous feriez quelque chose comme:

 ParsePush.unsubscribeInBackground("Giants", new SaveCallback() {
    @Override
    public void done(ParseException e) {
        if (e == null) {
            FirebaseMessaging.getInstance().subscribeToTopic("Giants");
        } else {
            // Something went wrong unsubscribing
        }
    }
});
 

En utilisant cette stratégie, vous pouvez envoyer des messages à la fois au canal Parse et à la rubrique FCM correspondante, prenant en charge les utilisateurs des anciennes et des nouvelles versions. Lorsque suffisamment d'utilisateurs ont migré de la version d'analyse uniquement de l'application, vous pouvez suspendre cette version et commencer à envoyer à l'aide de FCM uniquement.

Consultez la documentation sur les sujets FCM pour en savoir plus.

Configuration à distance Firebase

Firebase Remote Config est un service cloud qui vous permet de modifier le comportement et l'apparence de votre application sans obliger les utilisateurs à télécharger une mise à jour de l'application. Lorsque vous utilisez Remote Config, vous créez des valeurs par défaut dans l'application qui contrôlent le comportement et l'apparence de votre application. Ensuite, vous pouvez utiliser ultérieurement la console Firebase pour remplacer les valeurs par défaut de l'application pour tous les utilisateurs de l'application ou pour des segments de votre base d'utilisateurs.

Firebase Remote Config peut être très utile lors de vos migrations dans les cas où vous souhaitez tester différentes solutions et pouvoir déplacer dynamiquement davantage de clients vers un autre fournisseur. Par exemple, si vous disposez d'une version de votre application qui utilise à la fois Firebase et Parse pour les données, vous pouvez utiliser une règle de centile aléatoire pour déterminer quels clients lisent à partir de Firebase et augmenter progressivement le pourcentage.

Pour en savoir plus sur Firebase Remote Config, consultez l' introduction à Remote Config .

Différences avec Parse Config

Avec Parse config, vous pouvez ajouter des paires clé / valeur à votre application sur le tableau de bord Parse Config, puis récupérer ParseConfig sur le client. Chaque instance de ParseConfig que vous obtenez est toujours immuable. Lorsque vous récupérez un nouveau ParseConfig à l'avenir sur le réseau, il ne modifiera aucune instance de ParseConfig existante, mais en créera une nouvelle et la rendra disponible via getCurrentConfig() .

Avec Firebase Remote Config, vous créez des valeurs par défaut dans l'application pour les paires clé / valeur que vous pouvez remplacer à partir de la console Firebase, et vous pouvez utiliser des règles et des conditions pour fournir des variations sur l'expérience utilisateur de votre application à différents segments de votre base d'utilisateurs. Firebase Remote Config implémente une classe singleton qui rend les paires clé / valeur disponibles pour votre application. Au départ, le singleton renvoie les valeurs par défaut que vous définissez dans l'application. Vous pouvez récupérer un nouvel ensemble de valeurs sur le serveur à tout moment convenant à votre application; une fois le nouvel ensemble récupéré avec succès, vous pouvez choisir quand l'activer pour rendre les nouvelles valeurs disponibles pour l'application.

Stratégie de migration suggérée

Vous pouvez passer à Firebase Remote Config en copiant les paires clé / valeur de votre configuration Parse dans la console Firebase, puis en déployant une nouvelle version de l'application qui utilise Firebase Remote Config.

Si vous souhaitez expérimenter à la fois Parse Config et Firebase Remote Config, vous pouvez déployer une nouvelle version de l'application qui utilise les deux SDK jusqu'à ce que suffisamment d'utilisateurs aient migré de la version Parse uniquement.

Comparaison de code

Analyser

 ParseConfig.getInBackground(new ConfigCallback() {
    @Override
    public void done(ParseConfig config, ParseException e) {
        if (e == null) {
            Log.d("TAG", "Yay! Config was fetched from the server.");
        } else {
            Log.e("TAG", "Failed to fetch. Using Cached Config.");
            config = ParseConfig.getCurrentConfig();
        }

        // Get the message from config or fallback to default value
        String welcomeMessage = config.getString("welcomeMessage", "Welcome!");
    }
});
 

Firebase

 mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
// Set defaults from an XML resource file stored in res/xml
mFirebaseRemoteConfig.setDefaults(R.xml.remote_config_defaults);

mFirebaseRemoteConfig.fetch()
    .addOnSuccessListener(new OnSuccessListener<Void>() {
        @Override
        public void onSuccess(Void aVoid) {
            Log.d("TAG", "Yay! Config was fetched from the server.");
            // Once the config is successfully fetched it must be activated before newly fetched
            // values are returned.
            mFirebaseRemoteConfig.activateFetched();
        }
    })
    .addOnFailureListener(new OnFailureListener() {
        @Override
        public void onFailure(@NonNull Exception exception) {
            Log.e("TAG", "Failed to fetch. Using last fetched or default.");
        }
    })

// ...

// When this is called, the value of the latest fetched and activated config is returned;
// if there's none, the default value is returned.
String welcomeMessage = mFirebaseRemoteConfig.getString("welcomeMessage");