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.

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
RAD Server (EMS)

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

Conception et configuration de l'interface utilisateur

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
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.
Ajoutez un composant TMemo à la fiche et définissez la propriété Align sur Client.
Déposez un objet TPushEvents.
Définissez la propriété AutoActivate sur False.
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é.
Selon le fournisseur de services que vous souhaitez utiliser, ajoutez :
- Pour Parse : un TParseProvider.
- Pour Kinvey : un TKinveyProvider.
- Pour RAD Server (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 AppKey, AppSecret et MasterSecret avec les valeurs des clés API fournies lors de la configuration de votre projet dans Kinvey.
  - Définissez UserName et Password avec les 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 ApplicationId, AppSecret et MasterSecret avec les valeurs des clés API fournies lors de la configuration de RAD Server Engine.

Création des gestionnaires d'événement

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.
Passez à l'onglet Code en appuyant sur F12.

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

.

Paramètres du projet

Pour permettre à votre application de recevoir des notifications distantes :

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

Remarque:  Si vous voulez activer une notification même lorsque l'application n'est pas en cours d'exécution au moment où la notification distante est reçue, vous devez recenser une classe de service. Cette classe de service Java va créer une entrée dans le centre de notification du périphérique Android. Si vous ne voulez pas avoir d'éléments dans le centre de notifications, vous pouvez ignorer cette étape.

Vous devez inclure une entrée supplémentaire dans le fichier AndroidManifest.xml du projet, en personnalisant le fichier AndroidManifest.template.xml. Recherchez l'indicateur suivant dans le fichier AndroidManifest.template.xml de votre projet :

<%receivers%>

Ajoutez le code suivant sous la balise :

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

Pensez à apporter les modifications suivantes à votre code :

Avant d'appliquer vos paramètres de projet, vous devez recenser le GCM sur un thread d'arrière-plan.
- Vous pouvez assigner la propriété 'TPushEvents.Active' sur le thread principal sans déclencher d'instance de l'exception Java 'IOException'.
- Vous pouvez assigner la propriété 'TPushServiceConnection.Active' sur le thread principal sans déclencher d'instance de l'exception Java 'IOException'.

Le changement d'état en 'Starting' est maintenant supporté.
- Les plates-formes 'Android' et 'iOS' commencent à avoir un comportement identique par rapport au cycle de vie du push service.
- Vous pouvez maintenant tester si le 'push service' saisi est passé à l'état 'Starting' lors d'un changement de connexion, en utilisant le code suivant :

procedure TForm1.OnServiceConnectionChange(Sender: TObject; PushChanges: TPushService.TChanges);
begin
  if TPushService.TChange.Status in PushChanges then
  begin
    if FPushService.Status = TPushService.TStatus.Starting then
    begin
      Memo1.Lines.Add('GCM registration is going to start.'); 
    end;
  end;
end;

Les gestionnaires d'événement sont maintenant appelés sur le thread principal.
- Les gestionnaires d'événement 'TPushEvents.OnDeviceRegistered', 'TPushEvents.OnDeviceTokenReceived', 'TPushEvents.OnDeviceTokenRequestFailed' et 'TPushEvents.OnPushReceived' n'ont plus besoin d'utiliser 'TThread.Synchronize' lorsqu'ils interagissent avec des contrôles visuels.
- Les gestionnaires d'événement 'TPushServiceConnection.OnChange' et 'TPushServiceConnection.OnReceiveNotification' n'ont plus besoin d'utiliser 'TThread.Synchronize' lorsqu'ils interagissent avec des contrôles visuels.

Paramètres iOS

Paramètres du projet

Cliquez avec le bouton droit sur votre projet dans le Gestionnaire de projets.
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

Dans la fenêtre Projets, sélectionnez votre plate-forme cible.
Choisissez l'une des commandes suivantes :
- Exécuter > Exécuter
- Exécuter > Exécuter sans déboguer
Cliquez sur la case à cocher Active.
Accédez à Parse, Kinvey ou Envoi de messages Push de RAD Server et envoyez un nouveau message Push :

Remarque: Vous pouvez utiliser votre propre application RAD Server pour envoyer des messages de notification Push RAD Server.

Parse

Kinvey

RAD Server (EMS)
Passez à votre périphérique mobile :

iOS

Android

iOS RAD Server (EMS)
Mettez votre app en arrière-plan et envoyez une autre notification Push depuis Parse ou Kinvey. Accédez maintenant à Notifications :

iOS

Android