Tutoriel mobile : Utilisation du numéroteur téléphonique sur les périphériques mobiles (iOS et Android)
Sommaire
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 :
- Sélectionnez :
- Pour Delphi : Fichier > Nouveau > Application multi-périphérique - Delphi
- Pour C++ : Fichier > Nouveau > Application multi-périphérique - C++Builder
- Ouvrez l'éditeur de code et procédez comme suit :
- Ajoutez les lignes suivantes à votre code si elles ne sont pas présentes :
uses
FMX.Platform, FMX.PhoneDialer;
#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 :
private: // User declarations
PhoneDialerService: IFMXPhoneDialerService;
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 :
- Déposez deux composants TLabel sur le Concepteur de fiches, puis définissez leurs propriétés Name sur lblCarrierName et lblISOCountryCode, respectivement.
- Définissez la propriété Text des libellés sur Carrier Name et ISO Country Code, respectivement.
- 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 :
Obtenir les propriétés de la porteuse
Pour obtenir les informations relatives à la porteuse, apportez les modifications suivantes :
- Dans le Concepteur de fiches, sélectionnez le bouton Get Carrier Info.
- Dans l'inspecteur d'objets, double-cliquez sur l'événement onClick et implémentez le gestionnaire d'événement onClick comme suit :
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;
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 |
---|---|
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 :
- Ajoutez un composant TLabel, puis définissez sa propriété Text sur Telephone Number.
- Ajoutez un composant TEdit puis, dans l'inspecteur d'objets, définissez les propriétés suivantes :
- Name sur edtTelephoneNumber.
- KillFocusByReturn sur True.
- KeyboardType sur PhonePad.
- ReturnKeyType sur Go.
- Ajoutez un composant TButton puis, dans l'inspecteur d'objets, définissez les éléments suivants :
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;
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 :
- Exécutez l'application.
- Dans le champ TEdit sous Telephone Number, tapez le numéro de téléphone.
- Cliquez sur le bouton Make Call.
iOS | Android |
---|---|
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 :
-
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);
-
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; } }
- Ajoutez un composant TLabel au Concepteur de fiches, puis dans l'inspecteur d'objets, définissez sa propriété Name sur lblCallState.
-
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) :
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
- Tutoriel mobile : Prendre une photo et la partager, et partager du texte (iOS et Android)
- Tutoriel mobile : Utilisation de détecteurs d'emplacement (iOS et Android)
- FMX.PhoneDialer.IFMXPhoneDialerService
- Développement d'applications mobiles Android
- Développement d'applications mobiles iOS
- Extraits de code mobile : Numéroteur téléphonique