Si vous êtes un utilisateur de Parse à la recherche d'une solution alternative de backend en tant que service, Firebase pourrait être le choix idéal pour votre application iOS.
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 iOS+ .
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 aux 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 de l'appareil et l'âge.
Pour les événements personnalisés et les propriétés utilisateur, vous pouvez utiliser une stratégie de double écriture en utilisant à la fois Parse Analytics et Google Analytics pour enregistrer les événements et les propriétés, ce qui vous permet de déployer progressivement la nouvelle solution.
Comparaison des codes
Analyser l'analyse
// Start collecting data
[PFAnalytics trackAppOpenedWithLaunchOptions:launchOptions];
NSDictionary *dimensions = @{
// Define ranges to bucket data points into meaningful segments
@"priceRange": @"1000-1500",
// Did the user filter the query?
@"source": @"craigslist",
// Do searches happen more often on weekdays or weekends?
@"dayType": @"weekday"
};
// Send the dimensions to Parse along with the 'search' event
[PFAnalytics trackEvent:@"search" dimensions:dimensions];
Google Analytics
// Obtain the AppMeasurement instance and start collecting data
[FIRApp configure];
// Send the event with your params
[FIRAnalytics logEventWithName:@"search" parameters:@{
// Define ranges to bucket data points into meaningful segments
@"priceRange": @"1000-1500",
// Did the user filter the query?
@"source": @"craigslist",
// Do searches happen more often on weekdays or weekends?
@"dayType": @"weekday"
}];
Base de données en temps réel Firebase
La base de données Firebase Realtime est une base de données hébergée dans le cloud NoSQL. Les données sont stockées au format JSON et synchronisées en temps réel avec chaque client connecté.
Consultez la documentation de la base de données en temps réel Firebase pour en savoir plus.
Différences avec les données analysées
Objets
Dans Parse, vous stockez un PFObject , 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 PFObject .
Toutes les données de la base de données Firebase Realtime sont stockées sous forme d'objets JSON et il n'existe pas d'équivalent pour PFObject ; vous écrivez simplement dans l'arborescence JSON les valeurs des types qui correspondent aux types JSON disponibles.
Ce qui suit est un exemple de la façon dont vous pouvez enregistrer les meilleurs scores d'un jeu.
Analyser
PFObject *gameScore = [PFObject objectWithClassName:@"GameScore"];
gameScore[@"score"] = @1337;
gameScore[@"playerName"] = @"Sean Plott";
gameScore[@"cheatMode"] = @NO;
[gameScore saveInBackgroundWithBlock:^(BOOL succeeded, NSError *error) {
if (succeeded) {
// The object has been saved.
} else {
// There was a problem, check error.description
}
}];
Base de feu
// Create a reference to the database
FIRDatabaseReference *ref = [[FIRDatabase database] reference];
NSString *key = [[ref child:@"scores"] childByAutoId].key;
NSDictionary *score = @{@"score": @1337,
@"playerName": @"Sean Plott",
@"cheatMode": @NO};
[key setValue:score withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
if (error) {
// The object has been saved.
} else {
// There was a problem, check error.description
}
}];
Relations entre les données
Un PFObject peut avoir une relation avec un autre PFObject : n'importe quel objet peut utiliser d'autres objets comme valeurs.
Dans la base de données Firebase Realtime Database, les relations sont mieux exprimées à l'aide de structures de données plates qui divisent les données en chemins distincts, afin qu'elles puissent être téléchargées efficacement lors d'appels séparés.
Ce qui suit est un exemple de la façon dont vous pouvez structurer la relation entre les articles d'une application de blog et leurs auteurs.
Analyser
// Create the author
PFObject *myAuthor = [PFObject objectWithClassName:@"Author"];
myAuthor[@"name"] = @"Grace Hopper";
myAuthor[@"birthDate"] = @"December 9, 1906";
myAuthor[@"nickname"] = @"Amazing Grace";
// Create the post
PFObject *myPost = [PFObject objectWithClassName:@"Post"];
myPost[@"title"] = @"Announcing COBOL, a New Programming Language";
// Add a relation between the Post and the Author
myPost[@"parent"] = myAuthor;
// This will save both myAuthor and myPost
[myPost saveInBackground];
Base de feu
// Create a reference to the database
FIRDatabaseReference *ref = [[FIRDatabase database] reference];
// Create the author
NSString *myAuthorKey = @"ghopper";
NSDictionary *author = @{@"name": @"Grace Hopper",
@"birthDate": @"December 9, 1906",
@"nickname": @"Amazing Grace"};
// Save the author
[[ref child:myAuthorKey] setValue:author]
// Create and save the post
NSString *key = [[ref child:@"posts"] childByAutoId].key;
NSDictionary *post = @{@"author": myAuthorKey,
@"title": @"Announcing COBOL, a New Programming Language"};
[key 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 PFQuery .
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é.
Ce qui suit est 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
PFQuery *query = [PFQuery queryWithClassName:@"GameScore"];
[query whereKey:@"playerName" equalTo:@"Dan Stemkoski"];
[query findObjectsInBackgroundWithBlock:^(NSArray *objects, NSError *error) {
if (!error) {
for (PFObject *score in objects) {
NSString *gameScore = score[@"score"];
NSLog(@"Retrieved: %@", gameScore);
}
} else {
// Log details of the failure
NSLog(@"Error: %@ %@", error, [error userInfo]);
}
}];
Base de feu
// Create a reference to the database
FIRDatabaseReference *ref = [[FIRDatabase database] reference];
// This type of listener is not one time, and you need to cancel it to stop
// receiving updates.
[[[[ref child:@"scores"] queryOrderedByChild:@"playerName"] queryEqualToValue:@"Dan Stemkoski"]
observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
// This will fire for each matching child node.
NSDictionary *score = snapshot.value;
NSString gameScore = score[@"score"];
NSLog(@"Retrieved: %@", gameScore);
}];
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 quelques millisecondes sur tous les clients connectés, et la structure des données résultante est différente des données principales d'analyse. Cela signifie que la première étape de votre migration consiste à réfléchir aux modifications requises par vos données, notamment :
- Comment vos objets Parse doivent être mappés 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
Après avoir 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 commencer à utiliser la nouvelle version, vous devez :
- Convertissez vos données d'analyse existantes vers la nouvelle structure Firebase et écrivez-les dans la base de données en temps réel Firebase.
- Écrivez les fonctions Parse Cloud Code qui utilisent l'API REST Firebase pour écrire dans la base de données en temps réel Firebase les modifications apportées aux données d'analyse par les 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 de l'ancien et du nouveau code et simplifie la tâche des clients. Les défis de ce scénario consistent à gérer de grands ensembles de données lors de l'exportation initiale et à garantir que la synchronisation bidirectionnelle ne génère pas de récursion 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 depuis Parse Data vers la base de données en temps réel Firebase. Lorsqu'un nombre suffisant de personnes ont migré depuis la version Parse uniquement de l'application, vous pouvez supprimer le code Parse de la version à double écriture.
Ce scénario ne nécessite aucun code côté serveur. Ses inconvénients sont que les données auxquelles on n'accède pas 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 éviter l'investissement important requis pour mettre en œuvre et maintenir une expérience d'authentification complète pour votre application sur toutes les plateformes.
Consultez la documentation sur l'authentification Firebase pour en savoir plus.
Différences avec Parse Auth
Parse fournit une classe d'utilisateurs spécialisée appelée PFUser qui gère automatiquement les fonctionnalités requises pour la gestion des comptes utilisateur. PFUser est une sous-classe de PFObject , ce qui signifie que les données utilisateur sont disponibles dans Parse Data et peuvent être étendues avec des champs supplémentaires comme n'importe quel autre PFObject .
Un FIRUser 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ées dans la base de données d'utilisateurs d'un projet distinct ; ces propriétés peuvent être mises à jour par l'utilisateur. Vous ne pouvez pas ajouter d'autres propriétés directement à l'objet FIRUser ; à 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
PFUser *user = [PFUser user];
user.username = @"my name";
user.password = @"my pass";
user.email = @"email@example.com";
// other fields can be set just like with PFObject
user[@"phone"] = @"415-392-0202";
[user signUpInBackgroundWithBlock:^(BOOL succeeded, NSError *error) {
if (!error) {
// Hooray! Let them use the app now.
} else {
// Something went wrong
NSString *errorString = [error userInfo][@"error"];
}
}];
Base de feu
[[FIRAuth auth] createUserWithEmail:@"email@example.com"
password:@"my pass"
completion:^(FIRUser *_Nullable user, NSError *_Nullable error) {
if (!error) {
FIRDatabaseReference *ref = [[FIRDatabase database] reference];
[[[[ref child:@"users"] child:user.uid] child:@"phone"] setValue:@"415-392-0202"
} else {
// Something went wrong
NSString *errorString = [error userInfo][@"error"];
}
}];
Stratégie de migration suggérée
Migrer les comptes
Pour migrer les comptes d'utilisateurs de Parse vers Firebase, exportez votre base de données d'utilisateurs vers un fichier JSON ou CSV, puis importez le fichier dans votre projet Firebase à l'aide de la commande auth:import de 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 à ceci :
{ // 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 l' objectId de vos utilisateurs Parse comme localId de vos utilisateurs Firebase. De plus, en base64 encodez les valeurs bcryptPassword de Parse et utilisez-les 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 sur la migration des données . Si vous migrez des comptes à l'aide du flux décrit dans la section 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 toutes les relations saisies par l'identifiant utilisateur.
Messagerie cloud Firebase
Firebase Cloud Messaging (FCM) est une solution de messagerie multiplateforme qui vous permet de transmettre des messages et des notifications de manière fiable et gratuite. 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 Firebase Cloud Messaging pour en savoir plus.
Différences avec les notifications push d'analyse
Chaque application Parse installée sur un appareil enregistré pour les notifications est associée à un objet Installation , dans lequel vous stockez toutes les données nécessaires pour cibler les notifications. Installation est une sous-classe de PFUser , ce qui signifie que vous pouvez ajouter toutes les données supplémentaires souhaitées à vos instances Installation .
Le composeur de notifications fournit des segments d'utilisateurs prédéfinis basés sur des 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 les audiences 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 d'appareil
Alors que Parse utilise les jetons de périphérique APN pour cibler les installations pour les notifications, FCM utilise des jetons d'enregistrement FCM mappés aux jetons de périphérique APN. Ajoutez simplement le SDK FCM à votre application Apple et il récupérera automatiquement un jeton FCM .
Migration des chaînes vers les sujets FCM
Si vous utilisez les canaux Parse pour envoyer des notifications, vous pouvez migrer vers les sujets 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 SDK FCM pour vous abonner aux rubriques FCM correspondantes.
Par exemple, si votre utilisateur est abonné au sujet « Géants », vous feriez quelque chose comme :
PFInstallation *currentInstallation = [PFInstallation currentInstallation];
[currentInstallation removeObject:@"Giants" forKey:@"channels"];
[currentInstallation saveInBackgroundWithBlock:^(BOOL succeeded, NSError *error) {
if (succeeded) {
[[FIRMessaging messaging] subscribeToTopic:@"/topics/Giants"];
} else {
// Something went wrong unsubscribing
}
}];
Grâce à cette stratégie, vous pouvez envoyer des messages à la fois au canal Parse et à la rubrique FCM correspondante, prenant ainsi en charge les utilisateurs des anciennes et des nouvelles versions. Lorsqu'un nombre suffisant d'utilisateurs ont migré depuis la version Parse uniquement de l'application, vous pouvez mettre fin à cette version et commencer à envoyer en utilisant uniquement FCM.
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. Vous pourrez ensuite utiliser 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 plus 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 depuis Firebase et augmenter progressivement le pourcentage.
Pour en savoir plus sur Firebase Remote Config, consultez l' introduction de 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 le PFConfig sur le client. Chaque instance PFConfig que vous obtenez est toujours immuable. Lorsque vous récupérerez ultérieurement un nouveau PFConfig à partir du réseau, il ne modifiera aucune instance PFConfig existante, mais en créera une nouvelle et la rendra disponible via currentConfig .
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 de 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. Initialement, 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 qui convient à 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 sur 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 qu'un nombre suffisant d'utilisateurs aient migré depuis la version Parse uniquement.
Comparaison des codes
Analyser
[PFConfig getConfigInBackgroundWithBlock:^(PFConfig *config, NSError *error) {
if (!error) {
NSLog(@"Yay! Config was fetched from the server.");
} else {
NSLog(@"Failed to fetch. Using Cached Config.");
config = [PFConfig currentConfig];
}
NSString *welcomeMessage = config[@"welcomeMessage"];
if (!welcomeMessage) {
NSLog(@"Falling back to default message.");
welcomeMessage = @"Welcome!";
}
}];
Base de feu
FIRRemoteConfig remoteConfig = [FIRRemoteConfig remoteConfig];
// Set defaults from a plist file
[remoteConfig setDefaultsFromPlistFileName:@"RemoteConfigDefaults"];
[remoteConfig fetchWithCompletionHandler:^(FIRRemoteConfigFetchStatus status, NSError *error) {
if (status == FIRRemoteConfigFetchStatusSuccess) {
NSLog(@"Yay! Config was fetched from the server.");
// Once the config is successfully fetched it must be activated before newly fetched
// values are returned.
[self.remoteConfig activateFetched];
} else {
NSLog(@"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.
NSString welcomeMessage = remoteConfig[@"welcomeMessage"].stringValue;