Tutoriel mobile : Utilisation du numéroteur téléphonique sur les périphériques mobiles (iOS et Android)

De RAD Studio
Aller à : navigation, rechercher

Remonter à Tutoriels mobiles : Développement d'applications mobiles (iOS et Android)


Ce tutoriel décrit les étapes élémentaires relatives à l'utilisation des services de numérotation téléphonique sur votre périphérique mobile.

A propos des services de numérotation téléphonique sur les périphériques mobiles

Sur les plates-formes mobiles, FireMonkey fournit l'interface IFMXPhoneDialerService qui définit la structure des classes de services de numérotation téléphonique, comme TPhoneDialerService.

Les services de numérotation téléphonique vous permettent d'effectuer les opérations suivantes :

  • obtenir les informations relatives à la porteuse ;
  • effectuer un appel ;
  • détecter les modifications d'état des appels.

Accès aux services de numérotation téléphonique

Pour créer une application qui utilise les services de numérotation téléphonique, effectuez les étapes élémentaires suivantes :

  1. Sélectionnez :
  2. Ouvrez l'éditeur de code et procédez comme suit :
  • Ajoutez les lignes suivantes à votre code si elles ne sont pas présentes :
Delphi :
uses
  FMX.Platform, FMX.PhoneDialer;
C++ :
#include <FMX.Platform.hpp>
#include <FMX.PhoneDialer.hpp>
  • Uniquement pour les apps Delphi : ajoutez la ligne suivante à la section public de la définition de fiche :
 constructor Create(AOwner: TComponent); override;
  • Ajoutez les propriétés suivantes à la section private de la définition de fiche :
Delphi :
 private: // User declarations
 PhoneDialerService: IFMXPhoneDialerService;
C++ :
private: //User declarations
_di_IFMXPhoneDialerService phoneDialerService;
bool serviceSupported;
  • Uniquement pour les apps Delphi : dans la section implementation, redéfinissez le constructeur de fiche comme suit :
 constructor TForm1.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  TPlatformServices.Current.SupportsPlatformService(IFMXPhoneDialerService, IInterface(PhoneDialerService));
end;
  • Uniquement pour les apps C++Builder : dans la vue Structure, cliquez sur la fiche, puis dans l'inspecteur d'objets, ouvrez l'onglet Evénements puis double-cliquez sur onCreate. Implémentez le gestionnaire d'événement onCreate pour la fiche de l'application :
void __fastcall TForm1::FormCreate(TObject *Sender)
{
        serviceSupported = (TPlatformServices::Current->SupportsPlatformService(__uuidof(IFMXPhoneDialerService)) &&
	                   (phoneDialerService = TPlatformServices::Current->GetPlatformService(__uuidof(IFMXPhoneDialerService))));
		
}

A présent votre application peut accéder aux services de numérotation téléphonique.

Conception de l'interface utilisateur

Dans ce tutoriel, les composants TLabel, TButton et TEdit sont utilisés comme éléments de l'interface utilisateur.

Pour configurer les éléments de l'interface utilisateur, effectuez les étapes suivantes :

  1. Déposez deux composants TLabel sur le Concepteur de fiches, puis définissez leurs propriétés Name sur lblCarrierName et lblISOCountryCode, respectivement.
  2. Définissez la propriété Text des libellés sur Carrier Name et ISO Country Code, respectivement.
  3. Déposez un composant TButton sur le Concepteur de fiches, puis dans l'inspecteur d'objets, définissez les propriétés suivantes de ce bouton :
    • Name sur btnGetCarrierInfo
    • Text sur Get Carrier Info

Obtenir les propriétés de la porteuse

Pour obtenir les informations relatives à la porteuse, apportez les modifications suivantes :

  1. Dans le Concepteur de fiches, sélectionnez le bouton Get Carrier Info.
  2. Dans l'inspecteur d'objets, double-cliquez sur l'événement onClick et implémentez le gestionnaire d'événement onClick comme suit :
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.");

}

Exécution de l'application

Important : Avant d'exécuter votre application Delphi sur un périphérique Android, vérifiez que les permissions suivantes sont définies dans

Projet > Options > Permissions d'utilisation pour la cible Toutes les configurations - Plate-forme Android :

  • Appel téléphonique
  • Lire l'état du téléphone


Pour plus d'informations, voir Permissions d'utilisation.

Pour exécuter l'application, choisissez Exécuter > Exécuter ou appuyez sur F9.

Lorsque vous cliquez sur le bouton Get Carrier Info, l'application affiche les informations élémentaires relatives à la porteuse, comme dans les écrans suivants :

iOS Android

IOS CarrierInfo.png

Android CarrierInfo.png

Effectuer un appel

FireMonkey fournit la méthode IFMXPhoneDialerService.Call qui effectue un appel téléphonique vers le numéro de téléphone spécifié.

Pour que votre application effectue des appels, ajoutez les éléments suivants au Concepteur de fiches :

  1. Ajoutez un composant TLabel, puis définissez sa propriété Text sur Telephone Number.
  2. Ajoutez un composant TEdit puis, dans l'inspecteur d'objets, définissez les propriétés suivantes :
  3. Ajoutez un composant TButton puis, dans l'inspecteur d'objets, définissez les éléments suivants :
  • Définissez la propriété Name sur btnMakeCall.
  • Définissez la propriété Text sur Make Call.
  • Dans l'onglet Evénements, double-cliquez sur onClick, puis implémentez le gestionnaire d'événement onClick comme suit :
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.");
}

Pour effectuer un appel :

  1. Exécutez l'application.
  2. Dans le champ TEdit sous Telephone Number, tapez le numéro de téléphone.
  3. Cliquez sur le bouton Make Call.
iOS Android

IOS PhoneDialer.png

Android PhoneDialer.png

Détection des modifications d'état des appels

L'interface IFMXPhoneDialerService fournit l'événement OnCallStateChanged qui vous permet de gérer les modifications d'état des appels. L'énumération TCallState décrit les états possibles d'un appel téléphonique.

Le tableau suivant décrit les éléments de l'énumération TCallState (les états supportés pour chaque plate-forme sont signalés par un "+").

Elément Description  iOS  Android
None Etat Pas d'appel. + -
Connected L'appelant est connecté au destinataire. + +
Incoming Un appel téléphonique entrant. + +
Dialing Le téléphone est à l'état numérotation. + -
Disconnected L'appel est déconnecté. + +

Implémentation du gestionnaire d'événement OnCallStateChanged

Pour implémenter le gestionnaire d'événement OnCallStateChanged, effectuez les étapes suivantes :

  1. Ajoutez l'en-tête de procédure suivant à la section private de la définition de fiche :
    Delphi :
     procedure MyOnCallStateChanged(const ACallID: String; const ACallState: TCallState);
    
    C++ :
    void __fastcall MyOnCallStateChanged(const UnicodeString aCallID, const TCallState aCallState);
    
  2. Réécrivez le constructeur de fiche (applications Delphi) ou le gestionnaire d'événement onFormCreate (applications C++) que vous avez défini dans la section #Accès aux services de numérotation téléphonique comme suit :
    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. Ajoutez un composant TLabel au Concepteur de fiches, puis dans l'inspecteur d'objets, définissez sa propriété Name sur lblCallState.
  4. Dans l'éditeur de code, ajoutez le code de gestionnaire d'événement suivant :
    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;
    	}
     }
    


Une fois ce gestionnaire d'événement implémenté, l'application affiche l'état des appels téléphoniques.

Par exemple, cet écran iOS indique que le téléphone est dans l'état Dialing (numérotation en cours) :

Ios PhoneCall State.png

Remarque : Dans ce projet exemple, le composant TLabel est situé en regard de la zone TEdit et du bouton Make Call, sous Telephone Number.

Voir aussi