Application multi-périphérique pour recevoir des notifications push

Remonter à Tutoriel mobile : Utilisation des notifications distantes (iOS et Android)

Vous allez créer une application élémentaire pour recevoir une notification push avec des éléments génériques à Android et iOS. Vous ajouterez ensuite le code qui permettra de définir les caractéristiques de chacune des plates-formes.

Remarque : Notre implémentation étant basée sur le framework BAAS REST, RAD Studio vous permet d'utiliser dans vos apps iOS ou Android l'un des fournisseurs de services suivants :

• Kinvey
• Parse
• EMS

Avant de créer votre application pour recevoir des notifications push, assurez-vous de terminer ces deux étapes nécessaires :

• Configuration du service de messagerie
• Choix du fournisseur :
  • Utilisation du service Cloud pour envoyer des notifications push
  • Utilisation de EMS pour envoyer des notifications push

Conception et configuration de l'interface utilisateur

1. Pour créer une application multi-périphérique, sélectionnez l'une des options suivantes :

   Fichier > Nouveau > Application multi-périphérique - Delphi > Application vide

   Fichier > Nouveau > Application multi-périphérique - C++Builder > Application vide

2. Déposez un composant TCheckBox sur la fiche.

   Dans l'inspecteur d'objets, définissez les propriétés suivantes pour la case à cocher :

   1. Définissez Align sur Top.
   2. Définissez la propriété IsChecked sur False.
   3. Définissez la propriété Text sur Active.
3. Ajoutez un composant TMemo à la fiche et définissez la propriété Align sur Client.
4. Déposez un objet TPushEvents.
5. Définissez la propriété AutoActivate sur False.
6. Dans le Concepteur LiveBindings, ajoutez un lien depuis Active de PushEvents vers IsChecked de CheckBox. La propriété Active de PushEvents est définie sur True lorsque le composant CheckBox est coché.

   

7. Selon le fournisseur de services que vous souhaitez utiliser, ajoutez :
   • Pour Parse : un TParseProvider.
   • Pour Kinvey : un TKinveyProvider.
   • Pour EMS : un TEMSProvider.
   1. Utilisation de TKinveyProvider (iOS ou Android)

      

      Dans l'inspecteur d'objets, définissez les propriétés suivantes pour le KinveyProvider :
      • Développez le noeud Android Push et copiez dans GCMAppID le numéro de projet indiqué dans la procédure S'enregistrer chez Google.
      • Définissez les paramètres AppKey, AppSecret et MasterSecret conformément aux valeurs des clés API indiquées dans la configuration de votre projet dans Kinvey.
      • Définissez les paramètres UserName et Password conformément aux valeurs définies dans Ajout d'un utilisateur dans Kinvey.

      

   2. Utilisation de TParseProvider (iOS ou Android)

      

      Dans l'inspecteur d'objets, définissez les propriétés suivantes pour ParseProvider :
      • Définissez les paramètres ApplicationID, MasterKey et RestApiKey conformément aux clés API indiquées dans Création d'un projet avec Parse.

      Remarque : Il n'est pas nécessaire d'ajouter GCM AppID lors du développement des apps Android et de l'utilisation de Parse.

      

   3. Utilisation de TEMSProvider (iOS ou Android)

      

      Dans l'inspecteur d'objets, définissez les propriétés suivantes du EMSProvider :
      • Développez le noeud Android Push et copiez dans GCMAppID le numéro de projet indiqué dans la procédure S'enregistrer chez Google.
      • Définissez les paramètres ApplicationId, AppSecret et MasterSecret conformément aux valeurs des clés API indiquées dans la configuration de votre serveur EMS.

      

Création des gestionnaires d'événement

1. Sur la fiche, sélectionnez PushEvents1 et accédez à l'inspecteur d'objets :
   • Vérifiez si la propriété Provider est définie sur KinveyProvider1, ParseProvider1 ou EMSProvider1, selon le fournisseur que vous avez choisi d'utiliser.
   • Accédez à l'onglet Evénements et créez un gestionnaire d'événement pour chaque événement en double-cliquant sur le champ Valeur.

   

2. Passez à l'onglet Code en appuyant sur F12.
3. Définissez les gestionnaires d'événement comme suit :

   Delphi :

   implementation
   
   {$R *.fmx}
   
   procedure TForm1.PushEvents1DeviceRegistered(Sender: TObject);
   begin
     Memo1.Lines.Add('Device Registered');
     Memo1.Lines.Add('');
   end;
   
   procedure TForm1.PushEvents1DeviceTokenReceived(Sender: TObject);
   begin
     Memo1.Lines.Add('Device Token Received');
     Memo1.Lines.Add('');
   end;
   
   procedure TForm1.PushEvents1DeviceTokenRequestFailed(Sender: TObject;
     const AErrorMessage: string);
   begin
     Memo1.Lines.Add('Device Token Request Failed');
     Memo1.Lines.Add(AErrorMessage);
     Memo1.Lines.Add('');
   end;
   
   procedure TForm1.PushEvents1PushReceived(Sender: TObject;
     const AData: TPushData);
   begin
     Memo1.Lines.Add('Device push received');
     Memo1.Lines.Add(AData.Message);
     Memo1.Lines.Add('');
   end;
   
   end.
   

   C++ :

   //--------------------------------------------------------------------------
   void __fastcall TForm1::PushEvents1DeviceRegistered(TObject *Sender)
   {
      Memo1->Lines->Add("Device Registered");
      Memo1->Lines->Add("");
   }
   //--------------------------------------------------------------------------
   void __fastcall TForm1::PushEvents1DeviceTokenReceived(TObject *Sender)
   {
      Memo1->Lines->Add("Device Token Received");
      Memo1->Lines->Add("");
   }
   //--------------------------------------------------------------------------
   void __fastcall TForm1::PushEvents1DeviceTokenRequestFailed(TObject *Sender, const UnicodeString AErrorMessage)
   
   {
     Memo1->Lines->Add("Device Token Request Failed");
     Memo1->Lines->Add(AErrorMessage);
     Memo1->Lines->Add("");
   }
   //--------------------------------------------------------------------------
   void __fastcall TForm1::PushEvents1PushReceived(TObject *Sender, TPushData * const AData)
   
   {
     Memo1->Lines->Add("Push Received");
     Memo1->Lines->Add(AData->Message);
     Memo1->Lines->Add("");
   }
   //--------------------------------------------------------------------------
   

Paramètres Android

Remarque : Pour savoir si votre périphérique Android prend en charge GCM, consultez GCM Overview (EN).

Paramètres du projet

Pour permettre à votre application de recevoir des notifications distantes :

1. Cliquez avec le bouton droit sur votre projet dans le Gestionnaire de projets.
2. Choisissez Projet > Options > Liste des droits.
3. Définissez la valeur Recevoir les notifications push sur True.

Remarque : Si vous souhaitez activer la réception d'une notification même si l'application n'est pas en cours d'exécution lorsque la notification distante est reçue, vous devrez recenser une classe de service. Cette classe de service Java créera une entrée dans le Centre de notifications du périphérique Android. Vous pouvez ignorer cette étape si vous ne souhaitez pas recevoir d'éléments du Centre de notifications.

Vous devez inclure une entrée supplémentaire pour le projet dans le fichier AndroidManifest.xml en personnalisant votre fichier AndroidManifest.template.xml. Dans le fichier AndroidManifest.template.xml de votre projet, recherchez la balise suivante :

<%receivers%>

Ajoutez le code suivant sous la balise :

<service android:name="com.embarcadero.gcm.notifications.GCMIntentService" />

Paramètres iOS

Paramètres du projet

1. Cliquez avec le bouton droit sur votre projet dans le Gestionnaire de projets.
2. Choisissez Projet > Options > Informations de version, et définissez la clé CFBundleIdentifier. La valeur doit être identique à celle de l'identificateur de votre app. C'est la valeur Bundle ID de la section Création d'un ID d'app iOS sur le site Apple Developer Program.

Exécution de votre application sur un périphérique mobile

Votre application est maintenant prête pour s'exécuter sur un simulateur ou votre périphérique mobile connecté.
Pour exécuter votre application

1. Dans le Gestionnaire de projets, sélectionnez votre plate-forme cible.
2. Choisissez l'une des commandes suivantes :
   • Exécuter > Exécuter
   • Exécuter > Exécuter sans déboguer
3. Cliquez sur la case à cocher Active.
4. Accédez à Parse, Kinvey ou à Envoi de messages push EMS et envoyez un nouveau push :
   

   Remarque : Vous pouvez utiliser votre propre application EMS pour envoyer des messages de notifications push EMS.

   Parse

   Kinvey

   EMS

5. Passez à votre périphérique mobile :

   iOS

   Android

   iOS EMS

   
   

6. Mettez votre app en arrière-plan et envoyez une autre notification Push depuis Parse ou Kinvey. Accédez maintenant à Notifications :

   iOS

   Android

Voir aussi

• Tutoriel mobile : Utilisation des notifications (iOS et Android)
• Tutoriel mobile : Utilisation de BaaS pour le stockage backend (iOS et Android)
• Services de mobilité d'entreprise
• Notifications push EMS
• Liste des droits

Exemples de code

• Exemple BaaS ToDo