La boîte à Tutoriels de Christopher PECAUD

Top

Accéder à ses contacts Google en utilisant Delphi

Laisser un commentaire

SOMMAIRE

I Introduction
II Ouverture d’un compte Développeur via la console développeur Google
III Les préliminaires
IV Codage de l’aplication
V Conclusion

I Introduction

Je vous propose aujourd’hui un tutoriel permettant d’utiliser les Google API avec Delphi afin de vous permettre de récupérer des informations sur vos contacts Google. Pour ce faire il y a quelques prérequis à assurer avant de pouvoir réaliser cette opération. Nous verrons donc dans un premier temps les étapes nécessaires pour pouvoir ensuite accéder aux différentes API de Google, dans une application installée sur un ordinateur ou sur un appareil mobile via l’API oAuth 2.0.

Nous verrons ensuite comment récupérer des informations concernant les contacts importés de Google en utilisant JSON.

Nous utiliserons les composants Indy pour se connecter aux API Google. Nous aurons besoin d même d’un composant WebBrowser, et d’un composant permettant de parser du contenu JSON.

II Ouverture d’un compte Développeur via la console développeur Google

Pour accéder aux API de Google vous êtes maintenant obligés de passer par cette étape. Pour ce faire il faut aller vers ce lien et créer un nouveau compte si vous n’en aviez pas avant il suffit ensuite de créer un projet. Une fois le projet créé, il suffit ensuite de spécifier les APIs dont vous aurez besoin pour votre projet. Dans notre cas il s’agit de la Google Contacts API. Donc il suffit de mettre l’état de cette API sur la valeur « ON ». Concernant l’utilisation de cette API on a le droit à un quota de 20000000 de requêtes par jour. Ce qui est largement suffisant pour un usage personnel ou même une petite application à usage restreint. Au cas où ce quota viendrait à être dépassé vous devriez remplir des informations commerciales accessibles dans l’onglet « Settings » et dans la section « Billing ».

Maintenant il vous faut ensuite créer des informations qui vous permettront d’utiliser les APIs oAuth 2.0. Il faut créer un Id de Client. Cet élément est créé via l’onglet « Credentials ». Les informations que nous trouvons après la génération sont très importantes car elles vont être utilisées dans le code pour effectuer l’opération d’authentification.

Une dernière chose à réaliser est de créer un écran de consentement qui sera affiché lorsqu’un utilisateur voudra accéder à cette API depuis votre application, celui-ci est créé en cliquant sur la commande « Consent Screen ».

Une fois ces opérations réalisées, nous pouvons enfin passer à la partie codage de l’application.

III Les préliminaires

Une fois ces opérations réalisées, on va pouvoir passer à la partie codage de l’application. Mais avant nous devons nous assurer que l’on a bien tous les composants nécessaires pour arriver à nos fins. Et ce surtout si vous utilisez la version Starter à la maison comme moi. Pas de panique des outils libres sont à notre disposition pour réaliser les principales fonctions de notre tutoriel.

Dans un premier temps il nous faut un composant qui va nous permettre de nous connecter aux APIs de Google et de « dialoguer » avec. Ce composant est installé par défaut dans les la bibliothèque de composants de Delphi, nous utiliserons le composant TIndyHTTP.

Pour demander à l’utilisateur de votre programme le consentement d’utiliser ce service afin d’accéder à vos contacts Google, il vous faudra créer une nouvelle fenêtre avec un composant navigateur inséré dedans. Ce procédé est indispensable afin de récupérer le token qui vous permettra de passer à l’étape suivante qui permet la récupération des données de contacts. A noter que ce procédé est le même pour l’accès aux autres services de Google (Analytics, Calendar, Search, etc…).

Par défaut dans la version Starter ce composant n’est pas installé. Il vous passer par l’installation d’un nouveau composant ActiveX Microsoft Internet, vous pouvez l’installer dans un nouveau groupe de composant ActiveX. Comme cela vous pourrez le réutiliser ensuite dans d’autres programme.

Voici la fenêtre d’authentification :

Stacks Image 1037

Nous aurons besoin d’un autre composant permettant de parser le contenu JSON envoyé en retour de notre requête. Le composant que j’ai utilisé pour effectuer cette opération est la bibliothèque SuperObject que vous pourrez télécharger à cette adresse : https://code.google.com/p/superobject/downloads/list

Nous pouvons maintenant passer à la partie codage de notre application.

IV Codage de l’application

Maintenant que les prérequis ont été réalisés, il va falloir maintenant coder l’application pour pouvoir dans un premier temps s ‘authentifier à votre compte Google via l’API OAut 2.0. Et dans un second temps nous allons récupérer le token d’accès retourné par la précédente requête. Ensuite nous pourront demander des informations sur nos contacts.

Donc dans un premier temps il faut envoyer une requête à l’adresse : https://accounts.google.com/o/oauth2/auth

Avec les paramètres suivant le client_id, et l’uri de redirection que vous avez obtenus lors de la création de votre id ainsi que le scope. Je vous conseille, dans un premier temps, de créer des constantes client_id, client_secret, et redirect_uri quiseront utilisées plus tard dans le code.

const client_secret =  'votre code';
const client_id = ‘votre code';
const redirect_uri = 'urn donnée par Google';

Cette première requête doit être effectuée par l’intermédiaire de la fiche que nous avons précédemment créée.

authFrm := TAuthenticationFrm.Create(self);
authFrm.WebBrowser1.Navigate('https://accounts.google.com/o/oauth2/auth?
                                response_type=code&client_id=' + client_id + '&
                                redirect_uri=' +redirect_uri + '&
                                scope=https://www.google.com/m8/feeds');
authFrm.ShowModal;

Une fois que l’utilisateur s’est connecté à son compte Google et a accepté d’utiliser le service pour récupérer ses données de contacts. Nous récupérons cette information dans le titre de la page qui a changé.

if (AnsiContainsStr(authFrm.Caption, 'Success code=')) then
    begin
      code := authFrm.Caption;

Dans le fichier .pas associé à la fenêtre d’authentification, il faut donc rajouter ce code lié au gestionnaire d’événement changement du titre du navigateur :

procedure TAuthenticationFrm.WebBrowser1TitleChange(ASender: TObject;  const Text: WideString);
begin
  Caption := Text;
end;

Voici le code qui permet de récupérer le code de succès.

code := authFrm.Caption;
successCode := Copy(authFrm.Caption, 14, code.Length);

Une fois ce code récupéré nous pouvons préparer la requête de demande du token. C’est là que nous allons initialiser un objet de type TIdHTTP. Nous allons devoir créer aussi des entêtes contenant les données à envoyer aux API Google. Nous avons besoin d’instancier aussi un composant qui permette d’ouvrir et de vérifier les certificats SSL, ce composant est de type TIdSSLIOHandlerSocketOpenSSL. Il nous faut ensuite l’assigner à notre composant http, par l’intermédiaire de sa propriété IOHandler. Concernant les entêtes de la requête, nous avons besoin de renseigner les informations d’hôte, de type de contenu, de longueur de contenu. Cette dernière est obtenue à partir de la chaîne que l’on va envoyer à Google avec la requête.

code := authFrm.Caption;
successCode := Copy(authFrm.Caption, 14, code.Length);
chaine := 'code=' + successCode + '&client_id=' + client_id + '&
       client_secret=' + client_secret + '&
       redirect_url=' + redirect_uri + '&
       grant_type=authorization_code';
longueur_chaine := chaine.Length;
httpSocket := TIdHTTP.Create(Self);
SSLIOHandler := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
httpSocket.IOHandler := SSLIOHandler;
httpSocket.Request.Host := 'acounts.google.fr';
httpSocket.Request.ContentType := 'application/x-www-form-urlencoded';
httpSocket.Request.ContentLength := longueur_chaine;

Maintenant il nous reste encore quelques opérations à réaliser avant de poster notre requête à Google. En effet il nous faut définir encore le contenu de notre requête.

Cette opération consiste à envoyer de nouveau les différents codes retournés par Google ainsi que celui que l’on vient de récupérer lors de la dernière requête.

PostContent := TStringList.Create;
PostContent.Add('code='+successcode);
PostContent.Add('client_id='+client_id);
PostContent.Add('client_secret=' + client_secret);
PostContent.Add('redirect_uri=' + redirect_uri);
PostContent.Add('grant_type=authorization_code');

Cette fois-ci on peut envoyer notre requête et récupérer une chaine de caractères qui est au format JSON :

chaine := httpSocket.Post('https://accounts.google.com/o/oauth2/token', PostContent);

Maintenant il nous faut parser le contenu renvoyé par Google. Nous voulons accéder à la valeur access_token. Pour ce faire nous allons instancier un objet de type ISuperObject et nous allons lui assigner la chaine de caractères.

JSONparser := TSuperObject.ParseString(PWideChar(chaine), true);
accessToken := JSONParser.AsObject.S['access_token'];

Maintenant que l’on a récupérer le token, il ne nous reste plus qu’à récupérer les données de contacts. Nous allons donc instancier un nouvel objet de type TIdHTTP. On fait de même avec un objet de type TIdSSLIOHandlerSocketOpenSSL. Ensuite on appelle la méthode Get de l’objet httpSocket2 pour récupérer le contenu JSON correspondant à la liste des contacts Google.

chaine2 := 'https://www.google.com/m8/feeds/contacts/default/base?access_token=' + 
                   accessToken + '&alt=json';
httpSocket2 := TIdHTTP.Create(Self);
SSLIOHandler2 := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
httpSocket2.IOHandler := SSLIOHandler; 
retourJSON := httpSocket2.Get(chaine2);

La structure de contenu JSON est un peu complexe il va falloir descendre dans l’arborescence de ce contenu.

Nous allons donc devoir accéder aux différents nœuds. Pour ce faire on initialise un nouvel objet de type ISuperObject. Une fois ceci effectué il suffit de descendre dans l’arborescence de ce contenu vers les nœuds « entry » et « feed ».

JSONparser2 := TSuperObject.ParseString(PWideChar(retourJSON), true);
node := JSONParser2['feed'];

entrynode := node['entry'].AsArray;

A noter que entrynode est un objet de type TSuperArray car il contient tous les enregistrements correspondants à nos contacts. Il va falloir itérer chaque élément de ce tableau donc pour ce faire nous utilisons une boucle de la façon suivante :

for i := 0 to entrynode.Length -1 do
          begin
          contactlistnode := entrynode[i];
          contacttitlenode := contactlistnode['title'];
          contactName := contacttitlenode.AsObject.S['$t'];
          Application.MessageBox(PWideChar(contactName), 'Name :');
          if (contactlistnode['gd$email'] <> nil) then
            contactmailnode := contactlistnode['gd$email'].AsArray;
          for j := 0 to contactmailnode.Length - 1 do
            begin
            if (contactmailnode[j] <> nil) then
              begin
              contactmailtable := contactmailnode[j];
              contactAddress := contactMailTable.AsObject.S['address'];
              end;
            end;
          end;

Comme vous pouvez le constater on obtient le nom complet du contact par l’intermédiaire de la clé « $t », et les adresses mails associées sont contenues elles aussi dans un objet de type TSuperArray, car le contact peut avoir plusieurs mails associés. Nous nous assurons dans un premier lieu qu’une adresse mail a bien été renseignée dans la fiche du contact.

Voilà, maintenant vous savez comment accéder aux API Google pour accéder à des informations et les récupérer.

V Conclusion

A travers ce tutoriel nous avons vu qu’il était possible de récupérer ses contacts issus des applications Google (Google Contacts en l’occurrence). Nous avons vu qu’il y avait toute une étape assez longue nous imposant de nous authentifier sur la plateforme Google. Ce tutoriel vous a décrit les différentes étapes utiles pour réaliser l’import de vos contacts dans une application . Ces informations sont bien sûr utiles si vous voulez utiliser d’autres applications Google nécessitant une authentification à l’aide de la technologie Oauth 2.0.