Mobile-Tutorial: Verwenden der Wählhilfe auf mobilen Geräten (iOS und Android)

Nach oben zu Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)

In diesem Tutorial werden die grundlegenden Schritte zur Verwendung der Wählhilfe-Dienste auf mobilen Geräten beschrieben.

Allgemeine Informationen zu den Wählhilfe-Dienste auf mobilen Geräten

FireMonkey stellt auf mobilen Plattformen das Interface IFMXPhoneDialerService bereit, das die Struktur der Klassen für Wählhilfe-Dienste, wie TPhoneDialerService, definiert.

Mit den Wählhilfe-Diensten können Sie die folgenden Operationen ausführen:

• Abrufen von Informationen über den Netzbetreiber
• Durchführen eines Anrufs
• Ermitteln der Statusänderungen eines Anrufs

Zugreifen auf die Wählhilfe-Dienste

Führen Sie die folgenden grundlegenden Schritte aus, um eine Anwendung zu erstellen, die die Wählhilfe-Dienste verwendet:

1. Wählen Sie einen der folgenden Befehle aus:
   • Für Delphi: Datei > Neu > Geräteübergreifende Anwendung - Delphi
   • Für C++: Datei > Neu > Geräteübergreifende Anwendung - C++Builder
2. Öffnen Sie den Quelltext-Editor, und führen Sie Folgendes aus:

• Fügen Sie die beiden folgenden Zeilen hinzu, falls sie nicht vorhanden sind:
  

Delphi:

uses
  FMX.Platform, FMX.PhoneDialer;

C++:

#include <FMX.Platform.hpp>
#include <FMX.PhoneDialer.hpp>

• Nur für Delphi-Apps: Fügen Sie in den public-Abschnitt der Formulardefinition die folgende Zeile ein:

 constructor Create(AOwner: TComponent); override;

• Fügen Sie dem private-Abschnitt der Formulardefinition die folgenden Eigenschaften hinzu:
  

Delphi:

 private: // User declarations
 PhoneDialerService: IFMXPhoneDialerService;

C++:

private: //User declarations
_di_IFMXPhoneDialerService phoneDialerService;
bool serviceSupported;

• Nur für Delphi-Apps: Überschreiben Sie im implementation-Abschnitt den Formularkonstruktor wie folgt:

 constructor TForm1.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  TPlatformServices.Current.SupportsPlatformService(IFMXPhoneDialerService, IInterface(PhoneDialerService));
end;

• Nur für C++Builder-Apps: Klicken Sie in der Strukturansicht auf das Formular, öffnen Sie im Objektinspektor die Registerkarte Ereignisse, und doppelklicken Sie dann auf onCreate. Implementieren Sie die folgende onCreate-Ereignisbehandlungsroutine für das Anwendungsformular:
  

void __fastcall TForm1::FormCreate(TObject *Sender)
{
        serviceSupported = (TPlatformServices::Current->SupportsPlatformService(__uuidof(IFMXPhoneDialerService)) &&
	                   (phoneDialerService = TPlatformServices::Current->GetPlatformService(__uuidof(IFMXPhoneDialerService))));
		
}

Jetzt kann Ihre Anwendung auf die Wählhilfe-Dienste zugreifen.

Entwerfen der Benutzeroberfläche

In diesem Tutorial werden die Komponenten TLabel, TButton und TEdit als Elemente der Benutzeroberfläche verwendet.

Führen Sie die folgenden Schritte aus, um die UI-Elemente zu konfigurieren:

1. Ziehen Sie zwei TLabel-Komponenten in den Formular-Designer, und setzen Sie dann deren Name-Eigenschaften auf lblCarrierName bzw. lblISOCountryCode.
2. Setzen Sie die Eigenschaft Text für die Beschriftungen auf Carrier Name bzw. ISO Country Code.
3. Ziehen Sie eine TButton-Komponente in den Formular-Designer, und setzen Sie im Objektinspektor die folgenden Eigenschaften für diese Schaltfläche:
   • Name auf btnGetCarrierInfo
   • Text auf Get Carrier Info

Abrufen der Netzbetreiber-Eigenschaften

Führen Sie die folgenden Änderungen durch, um Informationen über den Netzbetreiber abzurufen:

1. Wählen Sie im Formular-Designer die Schaltfläche Get Carrier Info aus.
2. Doppelklicken Sie im Objektinspektor auf das Ereignis onClick, und implementieren Sie die onClick-Ereignisbehandlungsroutine wie folgt:

Delphi:

procedure TForm1.btnGetCarrierInfoClick(Sender: TObject);
begin
  { test whether the PhoneDialer services are supported on your device }
  if Assigned(PhoneDialerService) then
  begin
    { if yes, then update the labels with the retrieved information }
    lblCarrierName.Text := 'Carrier Name:  '  + PhoneDialerService.GetCarrier.GetCarrierName;
    lblISOCountryCode.Text := 'ISO Country Code: ' + PhoneDialerService.GetCarrier.GetIsoCountryCode;
  end;
end;

C++:

void __fastcall TForm1::btnGetCarrierInfoClick(TObject *Sender)
{
        if (serviceSupported) {
	    lblCarrierName->Text = "Carrier Name:  "  + phoneDialerService->GetCarrier()->GetCarrierName();
	    lblISOCountryCode->Text = "ISO Country Code: " + phoneDialerService->GetCarrier()->GetIsoCountryCode();
        }   else ShowMessage("This device does not support the Phone Dialer services.");

}

Ausführen der Anwendung

Wichtig: Überprüfen Sie vor dem Ausführen der Delphi-Anwendung auf einem Android-Gerät, ob die folgenden Berechtigungen in Projekt > Optionen > Verwendet Berechtigungen für das Ziel Alle Konfigurationen - Android-Plattform festgelegt sind:

• Anrufe tätigen
• Telefonstatus lesen

Weitere Informationen finden Sie unter Verwendet Berechtigungen.

Führen Sie die Anwendung mit dem Menübefehl Start > Start oder mit F9 aus.

Nach dem Klicken auf die Schaltfläche Get Carrier Info, zeigt die Anwendung die grundlegenden Informationen über den Netzbetreiber an, ähnlich wie in der folgenden Abbildung:

iOS	Android

Durchführen eines Anrufs

FireMonkey stellt die Methode IFMXPhoneDialerService.Call bereit, die einen Anruf bei einer bestimmten Telefonnummer durchführt.

Fügen Sie dem Formular-Designer die folgenden Elemente hinzu, um in der Anwendung Anrufe durchzuführen:

1. Fügen Sie eine TLabel-Komponente hinzu, und setzen Sie deren Eigenschaft Text auf Telephone Number.
2. Fügen Sie eine TEdit-Komponente hinzu, und setzen Sie im Objektinspektor die folgenden Eigenschaften:
   • Name auf edtTelephoneNumber.
   • KillFocusByReturn auf True.
   • KeyboardType auf PhonePad.
   • ReturnKeyType auf Go.
3. Fügen Sie eine TButton-Komponente hinzu, und führen Sie im Objektinspektor Folgendes aus:

• Setzen Sie die Eigenschaft Name auf btnMakeCall.
• Setzen Sie die Eigenschaft Text auf Make Call.
• Doppelklicken Sie auf der Registerkarte Ereignisse auf onClick, und implementieren Sie die onClick-Ereignisbehandlungsroutine wie folgt:
  

Delphi:

procedure TForm1.btnMakeCallClick(Sender: TObject);
begin
  { test whether the PhoneDialer services are supported on your device }
  if Assigned(PhoneDialerService) then
  begin
    { if the Telephone Number is entered in the edit box then make the call, else
      display an error message }
    if edtTelephoneNumber.Text <> '' then
      PhoneDialerService.Call(edtTelephoneNumber.Text)
    else
    begin
      ShowMessage('Please type-in a telephone number.');
      edtTelephoneNumber.SetFocus;
    end;
  end;
end;

C++:

void __fastcall TForm1::btnMakeCallClick(TObject *Sender)
{
       if (serviceSupported) {
	      if (edtTelephoneNumber->Text != "" )   {
		  phoneDialerService->Call(edtTelephoneNumber->Text);
              }
	           else {
		   ShowMessage("Please type-in a telephone number.");
		   edtTelephoneNumber->SetFocus();
	           }
       }   else ShowMessage("This device does not support the Phone Dialer services.");
}

So führen Sie einen Anruf durch:

1. Führen Sie die Anwendung aus.
2. Geben Sie in das TEdit-Feld unter Telephone Number die Telefonnummer ein.
3. Klicken Sie auf die Schaltfläche Make Call.

iOS	Android

Ermitteln der Statusänderungen eines Anrufs

Das Interface IFMXPhoneDialerService stellt das Ereignis OnCallStateChanged bereit, mit dem Sie Statusänderungen von Anrufen verarbeiten können. Die Aufzählung TCallState beschreibt die möglichen Status von Anrufen.

In der folgenden Tabelle sind die Einträge der TCallState-Aufzählung beschrieben (die für die jeweilige Plattform unterstützten Status sind mit einem "+" gekennzeichnet).

Element	Beschreibung	iOS	Android
None	Status "Kein Anruf".	+	-
Connected	Der Anrufer ist mit dem angerufenen Teilnehmer verbunden.	+	+
Incoming	Ein eingehender Telefonanruf.	+	+
Dialing	Das Telefon wählt gerade.	+	-
Disconnected	Die Verbindung ist getrennt.	+	+

Implementieren der OnCallStateChanged-Ereignisbehandlungsroutine

Führen Sie die folgenden Schritte aus, um die Ereignisbehandlungsroutine OnCallStateChanged zu implementieren:

1. Fügen Sie dem private-Abschnitt der Formulardefinition den folgenden Prozeduren-Header hinzu:
   
   Delphi:
   

    procedure MyOnCallStateChanged(const ACallID: String; const ACallState: TCallState);
   

   C++:
   

   void __fastcall MyOnCallStateChanged(const UnicodeString aCallID, const TCallState aCallState);
   

2. Schreiben Sie den Formularkonstruktor (Delphi-Anwendungen) oder die onFormCreate-Ereignisbehandlungsroutine (C++-Anwendungen), die Sie im Abschnitt Zugreifen auf die Wählhilfe-Dienste definiert haben, wie folgt um:
   
   Delphi:
   

    constructor TForm1.Create(AOwner: TComponent);
   begin
     inherited Create(AOwner);
     TPlatformServices.Current.SupportsPlatformService(IFMXPhoneDialerService, IInterface(PhoneDialerService));
     if Assigned(PhoneDialerService) then
       PhoneDialerService.OnCallStateChanged := MyOnCallStateChanged;
   end;
   

   C++:
   

   void __fastcall TForm1::FormCreate(TObject *Sender)
   {
          serviceSupported = (TPlatformServices::Current->SupportsPlatformService(__uuidof(IFMXPhoneDialerService)) &&
   		(phoneDialerService = TPlatformServices::Current->GetPlatformService(__uuidof(IFMXPhoneDialerService))));
          if (serviceSupported) {
              phoneDialerService->OnCallStateChanged = MyOnCallStateChanged;
          }
   }
   

3. Fügen Sie dem Formular-Designer eine TLabel-Komponente hinzu, und setzen Sie im Objektinspektor deren Eigenschaft Name auf lblCallState.
4. Fügen Sie im Quelltext-Editor den folgenden Code für die Ereignisbehandlungsroutine hinzu:
   
   Delphi:
   

   procedure TForm1.MyOnCallStateChanged(const ACallID: String; const ACallState: TCallState);
   var outText: String;
    Begin
     case ACallState of
            TCallState.None:         outText := 'No calls';
            TCallState.Connected:    outText := 'Connected';
            TCallState.Incoming:     outText := 'Incoming call';
            TCallState.Dialing:      outText := 'Dialing';
            TCallState.Disconnected: outText := 'Disconnected';
        end;
      lblCallState.Text := outText;
    End;
   

   C++:
   

   void __fastcall TForm1::MyOnCallStateChanged(const UnicodeString aCallID, const TCallState aCallState) {
   	switch (aCallState) {
   	    case TCallState::None:
                   lblCallState->Text = "No calls";
                   break;
   	    case TCallState::Connected:
                   lblCallState->Text = "Connected";
                   break;
   	    case TCallState::Incoming:
                   lblCallState->Text = "Incoming call";
                   break;
               case TCallState::Dialing:
                   lblCallState->Text = "Dialing";
                   break;
   	    case TCallState::Disconnected:
                   lblCallState->Text = "Disconnected";
                   break;
   	}
    }
   

Nach der Implementierung dieser Ereignisbehandlungsroutine zeigt die Anwendung den Status des Telefonanrufs an.

Beispielsweise wird auf dem folgenden iOS-Bildschirm angezeigt, dass das Telefon gerade wählt:

Hinweis: In diesem Beispielprojekt befindet sich die Komponente TLabel neben dem TEdit-Feld und die Schaltfläche Make Call unterhalb von Telephone Number.

Siehe auch

• Mobile-Tutorial: Aufnehmen und Teilen von Bildern und Teilen von Texten (iOS und Android)
• Mobile-Tutorial: Verwenden von Positionssensoren (iOS und Android)
• Mobile Android-Anwendungsentwicklung
• Mobile iOS-Anwendungsentwicklung
• Codefragmente für die mobile Entwicklung: Wählhilfe
• FMX.PhoneDialer.IFMXPhoneDialerService

Beispiele

• FireMonkey Phone Dialer (Beispiel)