Connecter un compte Google
Bonjour,
Je programme un logiciel en Java et une des particularités principales de ce logiciel est qu'il demandera à l'utilisateur son compte Google afin de pouvoir synchroniser les données du compte (agenda, contacts, docs, etc...). Par synchroniser, j'entends le fait de pouvoir lire et modifier les données du compte.
Donc, mon problème est que je peine à connecter un compte. Alors ce que je vais faire, c'est que je vais vous expliquer en détails où j'en suis et pourquoi je bloque. Alors c'est parti :P:
Donc, pour commencer, Google propose un tas de documentation sur laquelle je me suis basé. Je suis donc tombé sur ce site qui traite de l'autorisation pour des applications third-party. Et plus précisément, la partie qui me concerne est celle-ci:
http://code.google.com/intl/fr/apis/...alledApps.html
Sur cette page est expliqué le fonctionnement du système OAuth que je vais essayer de réexpliquer en français ici:
Le processus se déroule en différentes étapes:
- Effectuer une requête HTTP aux serveurs Google, en précisant quelles données on aimerait accéder et encore d'autres choses.
- Google nous répond en envoyant un "unauthorized token"
- On ouvre ensuite un navigateur internet pour l'utilisateur et on le dirige sur une page de confirmation grâce à notre "unauthorized token"
- L'utilisateur confirme qu'il fait confiance au logiciel en question et qu'il le laisse accéder aux données en question
- Google renvoi cette fois-ci un "authorized token"
- On pourra ensuite échanger à Google cet "authorized token" contre un "access token"
- On utilise l'"access token" pour accéder aux données
Donc voilà grossièrement le théorie (en espérant que ce soit la bonne et que je ne fasse pas fausse route), jusque là c'est bon, c'est au niveau de la pratique que je bloque.
Alors tout d'abord, il faut savoir lancer des requêtes HTTP, notamment les GET et POST. Malheureusement, ce n'est de loin pas ma tasse de thé, j'ai donc rechercher des bouts de codes sur le net, mais comme je n'y connais pas grand chose, je ne peux pas certifier qu'ils marchent. En voici deux exemples:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| /** Envoi de données par GET */
public static void GET(String URLAdresse) throws MalformedURLException, IOException{
URL url = new URL(URLAdresse);
URLConnection conn = url.openConnection();
try{
RetrievingResponse(conn);
} catch(IOException e){
e.printStackTrace();
}
}
/** Envoi de données par POST */
public static void POST(String URLAdresse, String URLData) throws MalformedURLException, IOException{
URL url = new URL(URLAdresse);
String data = new String(URLData);
URLConnection conn = url.openConnection();
conn.setDoOutput(true);
OutputStreamWriter osw = new OutputStreamWriter(conn.getOutputStream());
osw.write(data);
osw.flush();
osw.close();
try{
RetrievingResponse(conn);
} catch(IOException e){
e.printStackTrace();
}
}
/** Récupération de la réponse de la servlet */
private static void RetrievingResponse(URLConnection conn) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
} br.close();
} |
Voilà, ensuite, il faut savoir faire les bonnes requêtes et c'est là que j'en suis (et oui, à peine au début...) et pour ce, je me réfère à l'aide Google. Donc voici en détail, comme je l'ai compris, la première requête à envoyer:
Il faut envoyer la requête à l'URL suivante:
https://www.google.com/accounts/OAuthGetRequestToken
Avec comme paramètres:
- oauth_consumer_key: Etant donné que mon application n'est pas enregistrée chez eux, il faut mettre "anonymous"
- oauth_nonce: Un String long de 32 caractères et qui comporte des valeurs au hasard (des lettres et chiffres) qu'il faut ensuite garder en mémoire pour les prochaines requêtes.
- oauth_signature_method: Ca sera "HMAC-SHA1" pour moi car mon application n'est pas enregistrée
- oauth_signature: Alors ici, je galère:aie:!
- oauth_timestamp: Nombre de secondes après le 01.01.1970 à 00h00
- scope: Les données qu'on aimerait accéder. Par exemple: https://www.google.com/calendar/feeds/
- oauth_callback: URL où sera redirigé l'utilisateur après sa confirmation. Il est possible de mettre "oob" si le stade de développement est peu avancé, ainsi l'utilisateur sera redirigé sur une autre page Google avec le code qu'il devra copier/coller
- oauth_version: 1.0
- xoauth_displayname: Le nom de mon application qui sera affiché à l'utilisateur dans la confirmation
Alors je tiens à préciser que ce sont les éléments comme je les ai compris et que par conséquent, il est tout à fait possible que des fautes existent.
Et donc voilà un bout de code qui vous montrera la manière dont j'ai appliqué toute cette histoire:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
| public void ConnectTEST() throws MalformedURLException, IOException{
System.out.println("Connexion try...");
String oauth_consumer_key,
oauth_token,
oauth_signature_method,
oauth_signature,
oauth_timestamp,
oauth_version,
oauth_nonce,
oauth_callback,
xoauth_displayname,
scope,
URL;
oauth_nonce=new String();
for(int i=0;i<32;i++){
int next=(int) (Math.floor(Math.random() * 62) + 1);
if(next<=10){
next=next+47;
}else if(next<=36){
next=next+54;
}else{
next=next+60;
}
oauth_nonce=oauth_nonce+(char)next;
}
System.out.println("nonce:\n"+oauth_nonce);
oauth_consumer_key="anonymous";
oauth_signature=""; //?
oauth_signature_method="HMAC-SHA1";
oauth_version="1.0";
oauth_token=""; //?
oauth_callback="oob";
scope="https://www.google.com/calendar/feeds/";
xoauth_displayname="TESTApplication";
URL="https://www.google.com/accounts/OAuthGetRequestToken";
oauth_timestamp=String.valueOf(getTimeStamp());
String TESTrequest=new String("" +
"POST /accounts/OAuthGetRequestToken HTTP/1.1" + "\n" +
"Host: www.google.com" + "\n" +
"Accept: */*" + "\n" +
"Authorization: OAuth " +
"oauth_version=\""+oauth_version+"\", " +
"oauth_nonce=\""+oauth_nonce+"\", " +
"oauth_timestamp=\""+oauth_timestamp+"\", " +
"oauth_consumer_key=\""+oauth_consumer_key+"\", " +
"oauth_callback=\""+oauth_callback+"\", " +
"oauth_signature_method=\""+oauth_signature_method+"\", " +
"oauth_signature=\""+oauth_signature+"\"" +
"\n\n"+
"scope=\""+scope+"\""+"\n"+
"xoauth_displayname=\""+xoauth_displayname+"\""
);
try{
URLRequest.POST(URL, TESTrequest); //Classe qui contient la méthode que j'ai posté ci-dessus
}catch(MalformedURLException mue){
System.err.print("Malformed URL\n"+mue.getMessage());
}catch(IOException ioe){
System.err.print("IOException\n"+ioe.getMessage());
}
} |
Sachant que la méthode getTimeStamp se résume à:
Code:
1
2
3
4
| private long getTimeStamp(){
Date ref=new Date();
return ref.getTime()/1000;
} |
Et donc voilà, en admettant que jusque là tout soit juste (ce qui m'étonnerais énormément 8O), il reste deux problèmes, celui du callback dont je n'ai pas compris le fonctionnement et, plus urgent, celui de la signature qui me passe tout outre! Alors Google propose de la doc ici, mais je n'y arrive toujours pas. Si j'ai bien compris, je devrais faire une requête du type GET en premier lieu pour récupérer ma signature. Et pour faire cette requête, je devrais concaténer les paramètres en les séparant par des &. Ok, mais seulement, j'ai essayé différentes façon et à tout les coups je reçois une belle erreur 400 (requête mal formulée, ce qui ne m'étonne pas vu mon manque de connaissances dans la matière). Alors voici par exemple mon dernier essai en date:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| String signatureRequest=new String("GET "+URL+"?"+
"oauth_callback="+oauth_callback+
"&oauth_consumer_key="+oauth_consumer_key+
"&oauth_nonce="+oauth_nonce+
"&oauth_signature_method="+oauth_signature_method+
"&oauth_timestamp="+oauth_timestamp+
"&oauth_version="+oauth_version+
"&scope="+scope+
"&xoauth_displayname="+xoauth_displayname+
" HTTP/1.1"
);
System.out.println(signatureRequest);
try{
URLRequest.GET(signatureRequest); //Classe qui contient la méthode que j'ai posté ci-dessus
}catch(MalformedURLException mue){
System.err.print("Malformed URL\n"+mue.getMessage());
}catch(IOException ioe){
System.err.print("IOException\n"+ioe.getMessage());
} |
Ce code me rapporte donc toujours une erreur 400. Et donc voilà où j'en suis, alors le problème dans l'histoire, c'est que je ne sais même pas où chercher mon problème. Après tout, mon problème se situe peut-être dans mes requêtes qui sont mal formulées et n'aboutissent donc à rien, peut-être est-ce alors mes méthodes de requêtes HTTP que j'ai copié sur le net mais qui ne fonctionnent peut-être pas ou pas comme je le voudrais. Ou le problème peut également venir de la méthode elle-même, peut-être que je fais fausse route depuis le début et que ceci ne correspond pas à ce que je veux faire (accéder aux données Google agenda, contact, docs,... d'un utilisateur). Ou alors ça vient des 3 éléments en même temps... D'ailleurs, je pense à ça car cette méthode ne précise pas une seule fois le nom du compte auquel je veux accéder et je trouve ça bizarre :?
Alors si quelqu'un aurait des idées, j'en serais très reconnaissant parce que moi ça fait depuis un bout de temps que je nage là :cry:
