Geräteübergreifende Anwendung zum Empfangen von Push-Benachrichtigungen

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Mobile-Tutorial: Verwenden von Remote-Mitteilungen (iOS und Android)

In diesem Tutorial wird eine Basisanwendung zum Empfangen von Push-Benachrichtigungen mit generischen Android- bzw. iOS-Elementen erstellt und der für die jeweilige Plattform charakteristische Code hinzugefügt.

Da unsere Implementierung auf dem REST BAAS-Framework basiert, können Sie in RAD Studio in Ihren iOS- oder Android-Apps einen der folgenden Dienst-Provider verwenden:

Bevor Sie die Anwendung zum Empfangen von Push-Benachrichtigungen erstellen, müssen Sie diese beiden erforderlichen Schritte ausführen:

Entwerfen und Einrichten der Benutzeroberfläche

  1. Wählen Sie zum Erstellen einer geräteübergreifenden Anwendung einen der beiden folgenden Befehle aus:
    Datei > Neu > Geräteübergreifende Anwendung - Delphi > Leere Anwendung
    Datei > Neu > Geräteübergreifende Anwendung - C++Builder > Leere Anwendung
  2. Legen Sie eine TCheckBox-Komponente auf dem Formular ab.
    Legen Sie im Objektinspektor die folgenden Eigenschaften für die CheckBox-Komponente fest:
    1. Setzen Sie Align auf Top.
    2. Setzen Sie die Eigenschaft IsChecked auf False.
    3. Setzen Sie Text auf Active.
  3. Fügen Sie dem Formular eine TMemo-Komponente hinzu, und setzen Sie die Eigenschaft Align auf Client.
  4. Legen Sie ein TPushEvents-Objekt auf dem Formular ab.
  5. Setzen Sie AutoActivate auf False.
  6. Fügen Sie im LiveBindings-Designer eine Verknüpfung von Active in PushEvents zu IsChecked in CheckBox ein. Die Eigenschaft Active von PushEvents wird auf True gesetzt, wenn die CheckBox-Komponente aktiviert wird.
    Link.png
  7. Fügen Sie je nach gewünschtem Dienst-Provider Folgendes hinzu:
    1. Verwenden von TKinveyProvider (iOS oder Android)
      KinveyProvider.png
      Legen Sie im Objektinspektor die folgenden Eigenschaften für den KinveyProvider fest:
      KnvProv.png
    2. Verwenden von TParseProvider (iOS oder Android)
      ParseProvider.png
      Legen Sie im Objektinspektor die folgenden Eigenschaften für den ParseProvider fest:
      Hinweis: Beim Entwickeln von Android-Apps und der Verwendung von Parse müssen Sie die GCM AppID nicht hinzufügen.
      ParsePorviderSett.png
    3. Verwenden von TEMSProvider (iOS oder Android)
      EMSProvider.png
      Legen Sie im Objektinspektor die folgenden Eigenschaften für den EMSProvider fest:
      EMSProv.png

Erstellen der Ereignisbehandlungsroutinen

  1. Wählen Sie auf dem Formular PushEvents1 aus, und wechseln Sie zum Objektinspektor:
    • Überprüfen Sie, ob die Eigenschaft Provider je nach verwendetem Provider auf KinveyProvider1, auf ParseProvider1 oder auf EMSProvider1 gesetzt ist.
    • Erstellen Sie auf der Registerkarte Ereignisse eine Ereignisbehandlungsroutine für jedes Ereignis, indem Sie auf das Wertefeld doppelklicken.
    PushEvents.png
  2. Wechseln Sie zur Registerkarte Code, indem Sie F12 drücken.
  3. Definieren Sie die Ereignisbehandlungsroutinen wie folgt:
    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("");
}
//--------------------------------------------------------------------------

Android-Einstellungen

Hinweis: Unter GCM Overview (EN) können Sie feststellen, ob Ihr Android-Gerät GCM unterstützt.

Projekteinstellungen

So aktivieren Sie Ihre Anwendung für den Empfang von Remote-Benachrichtigungen:

  1. Klicken Sie in der Projektverwaltung mit der rechten Maustaste auf Ihr Projekt.
  2. Wählen Sie Projekt > Optionen > Berechtigungsliste.
  3. Setzen Sie den Wert von Push-Benachrichtigungen empfangen auf True.
Hinweis: Falls eine Benachrichtigung auch empfangen werden soll, wenn die Anwendung beim Eingang der Remote-Benachrichtigung nicht ausgeführt wird, müssen Sie eine Dienstklasse registrieren. Die Java-Dienstklasse erstellt einen Eintrag in der Mitteilungszentrale des Android-Geräts. Wenn Sie keine Einträge in der Mitteilungszentrale benötigen oder möchten, können Sie diesen Schritt überspringen.

Sie müssen für das Projekt einen zusätzlichen Eintrag in die Datei AndroidManifest.xml aufnehmen, indem Sie die Datei "AndroidManifest.template.xml" anpassen. Suchen Sie in der Datei AndroidManifest.template.xml für Ihr Projekt nach dem folgenden Tag: 

<%receivers%>

Fügen Sie darunter den folgenden Code ein:

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

Bitte berücksichtigen Sie die folgenden Updates in Ihrem Code:

  • Bevor Sie die Projekteinstellungen für Ihr Projekt anwenden, müssen Sie das GCM in einem Hintergrund-Thread registrieren.
    • Sie können die Eigenschaft "TPushEvents.Active" im Haupt-Thread zuweisen, ohne dass eine Instanz der Java-Exception "IOException" ausgelöst wird.
    • Sie können die Eigenschaft "TPushServiceConnection.Active" im Haupt-Thread zuweisen, ohne dass eine Instanz der Java-Exception "IOException" ausgelöst wird.
  • Der Statuswechsel zu "Starting" wird jetzt unterstützt.
    • Die Plattformen "Android" und "iOS" verhalten sich in Bezug auf den Lebenszyklus des Push-Dienstes ähnlich.
    • Jetzt können Sie testen, ob der "Push-Dienst" in den Status "Starting" übergegangen ist, wenn ein Verbindungswechsel stattfindet, ähnlich wie mit dem folgenden Code-Ansatz:
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;
  • Ereignisbehandlungsroutinen werden jetzt im Haupt-Thread aufgerufen.
    • Die Ereignisbehandlungsroutinen "TPushEvents.OnDeviceRegistered", "TPushEvents.OnDeviceTokenReceived", "TPushEvents.OnDeviceTokenRequestFailed" und "TPushEvents.OnPushReceived" müssen bei der Interaktion mit den visuellen Steuerelementen "TThread.Synchronize" nicht mehr verwenden.
    • Die Ereignisbehandlungsroutinen "TPushServiceConnection.OnChange" und "TPushServiceConnection.OnReceiveNotification" müssen bei der Interaktion mit den visuellen Steuerelementen "TThread.Synchronize" nicht mehr verwenden.

iOS-Einstellungen

Projekteinstellungen

  1. Klicken Sie in der Projektverwaltung mit der rechten Maustaste auf Ihr Projekt.
  2. Wählen Sie Projekt > Optionen > Versionsinformationen, und legen Sie den CFBundleIdentifier-Schlüssel fest. Dieser Schlüssel muss identisch mit dem Bezeichner Ihrer App-ID sein. Dabei handelt es sich um die Bundle ID aus Erstellen einer iOS-App-ID auf Apple Developer Program.
VersionInfo.png

Ausführen der Anwendung auf einem mobilen Gerät

Ihre Anwendung kann jetzt auf einem Simulator oder einem angeschlossenen mobilen Gerät ausgeführt werden.
So führen Sie die Anwendung aus:

  1. Wählen Sie im Projekte-Fenster die Zielplattform aus.
  2. Wählen Sie einen der folgenden Befehle aus:
    • Start > Start
    • Start > Ohne Debugger ausführen
  3. Klicken Sie auf das Kontrollkästchen Aktiv.
  4. Wechseln Sie zu Parse, Kinvey oder zu Senden von RAD Server-Push-Meldungen und senden Sie eine neue Push-Benachrichtigung:
    Hinweis: Sie können mit Ihrer eigenen RAD Server-Anwendung Meldungen zu RAD Server-Push-Benachrichtigungen senden.
    Parse

    ParseHello.png

    Kinvey

    HelloKinvey.png

    RAD Server (EMS)

    HelloEMS.png

  5. Wechseln Sie zu Ihrem mobilen Gerät:
    iOS

    IosDevice.png

    Android

    AndroidHello.png

    iOS RAD Server (EMS)

    IOSEMSHello.png


  6. Verlagern Sie Ihre App in den Hintergrund, und senden Sie eine weitere Push-Benachrichtigung von Parse oder Kinvey. Wechseln Sie zu Mitteilungen:
    iOS

    Pushios.png

    Android

    AndNotificationCenter.png

Siehe auch

Codebeispiele

Abgerufen von „https://docwiki.embarcadero.com/RADStudio/Athens/d/index.php?title=Geräteübergreifende_Anwendung_zum_Empfangen_von_Push-Benachrichtigungen&oldid=220337“