Android
API Google Drive

Introduction

Remarques

Intégrer Google Drive dans Android

Créer un nouveau projet sur Google Developer Console

Pour intégrer une application Android à Google Drive, créez les informations d'identification du projet dans Google Developers Console. Nous devons donc créer un projet sur la console de développement Google.

Pour créer un projet sur Google Developer Console, procédez comme suit:

• Accédez à Google Developer Console pour Android. Remplissez votre nom du projet dans le champ de saisie et cliquez sur le bouton Créer pour créer un nouveau projet sur la console Google Developer.

• Nous devons créer des informations d'identification pour accéder à l'API. Alors, cliquez sur le bouton Créer des identifiants .

• Maintenant, une fenêtre pop s'ouvrira. Cliquez sur l'option Clé API dans la liste pour créer une clé API.

• Nous avons besoin d'une clé API pour appeler les API Google pour Android. Alors, cliquez sur la touche Android pour identifier votre projet Android.

• Ensuite, nous devons ajouter le nom du package du projet Android et l' empreinte SHA-1 dans les champs d'entrée pour créer une clé API.

• Nous devons générer une empreinte SHA-1 . Ouvrez donc votre terminal et lancez l' utilitaire Keytool pour obtenir l'empreinte SHA1. Lors de l'exécution de l'utilitaire Keytool, vous devez fournir un mot de passe pour le fichier de clés. Le mot de passe de développement par défaut est «Android» . keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v

• Maintenant, ajoutez le nom du package et l' empreinte SHA-1 dans les champs de saisie de la page d'informations d'identification. Enfin, cliquez sur le bouton Créer pour créer une clé API.

• Cela va créer une clé API pour Android. Nous utiliserons cette clé API pour intégrer l'application Android à Google Drive.

Activer l'API Google Drive

Nous devons activer Google Drive Api pour accéder aux fichiers stockés sur Google Drive depuis une application Android. Pour activer l'API Google Drive, suivez les étapes ci-dessous:

• Accédez à votre tableau de bord de la console de développeur Google et cliquez sur Activer les API pour obtenir des informations d'identification telles que des clés. Vous verrez alors les populaires API Google.

• Cliquez sur le lien API du lecteur pour ouvrir la page de présentation de l'API Google Drive.

• Cliquez sur le bouton Activer pour activer l'API Google Drive. Il permet un accès client à Google Drive.

Ajouter une autorisation Internet

App nécessite un accès Internet aux fichiers Google Drive. Utilisez le code suivant pour configurer les autorisations Internet dans le fichier AndroidManifest.xml:

<uses-permission android:name="android.permission.INTERNET" />

Ajouter des services Google Play

Nous utiliserons l' API de services Google Play qui comprend l' API Google Drive Android . Nous devons donc configurer les services de jeu Google SDK dans une application Android. Ouvrez votre build.gradle (module d'application) et ajoutez le SDK de services Google play en tant que dépendances.

dependencies {
  ....
    compile 'com.google.android.gms:play-services:<latest_version>'
  ....
}

Ajouter une clé API dans le fichier manifeste

Pour utiliser l'API Google dans une application Android, nous devons ajouter la clé API et la version du service Google Play dans le fichier AndroidManifest.xml. Ajoutez les balises de métadonnées correctes à l'intérieur de la balise du fichier AndroidManifest.xml.

Connectez-vous et autorisez l'API Google Drive Android

Nous devons nous authentifier et connecter l' API Google Drive Android à une application Android. L'autorisation de Google Drive Android API est gérée par GoogleApiClient . Nous utiliserons GoogleApiClient dans la méthode onResume () .

/**
 * Called when the activity will start interacting with the user.
 * At this point your activity is at the top of the activity stack,
 * with user input going to it.
 */
@Override
protected void onResume() {
   super.onResume();
   if (mGoogleApiClient == null) {

       /**
        * Create the API client and bind it to an instance variable.
        * We use this instance as the callback for connection and connection failures.
        * Since no account name is passed, the user is prompted to choose.
        */
         mGoogleApiClient = new GoogleApiClient.Builder(this)
                 .addApi(Drive.API)
                 .addScope(Drive.SCOPE_FILE)
                 .addConnectionCallbacks(this)
                 .addOnConnectionFailedListener(this)
                 .build();
        }

        mGoogleApiClient.connect();
    }

Déconnecter l'API Android de Google Deive

Lorsque l'activité s'arrête, nous allons déconnecter la connexion API Google Drive Android avec l'application Android en appelant la méthode disconnect () dans la méthode onStop () de l'activité .

@Override
protected void onStop() {
    super.onStop();
    if (mGoogleApiClient != null) {

         // disconnect Google Android Drive API connection.
         mGoogleApiClient.disconnect();
    }
    super.onPause();
}

Implémenter des rappels de connexion et un écouteur avec échec de connexion

Nous implémenterons les callbacks de connexion et le listener d'échec de connexion du client API Google dans le fichier MainActivity.java pour connaître l'état de la connexion du client API Google. Ces écouteurs fournissent la méthode onConnected (), onConnectionFailed (), onConnectionSuspended () pour gérer les problèmes de connexion entre l'application et le lecteur.

Si l'utilisateur a autorisé l'application, la méthode onConnected () est appelée. Si l'utilisateur n'a pas autorisé l'application, la méthode onConnectionFailed () est appelée et une boîte de dialogue s'affiche pour indiquer que votre application n'est pas autorisée à accéder à Google Drive. Si la connexion est suspendue, la méthode onConnectionSuspended () est appelée.

Vous devez implémenter ConnectionCallbacks et OnConnectionFailedListener dans votre activité. Utilisez le code suivant dans votre fichier Java.

@Override
    public void onConnectionFailed(ConnectionResult result) {

        // Called whenever the API client fails to connect.
        Log.i(TAG, "GoogleApiClient connection failed:" + result.toString());

        if (!result.hasResolution()) {

            // show the localized error dialog.
            GoogleApiAvailability.getInstance().getErrorDialog(this, result.getErrorCode(), 0).show();
            return;
        }

        /**
         *  The failure has a resolution. Resolve it.
         *  Called typically when the app is not yet authorized, and an  authorization
         *  dialog is displayed to the user.
         */

        try {

            result.startResolutionForResult(this, REQUEST_CODE_RESOLUTION);

        } catch (SendIntentException e) {

            Log.e(TAG, "Exception while starting resolution activity", e);
        }
    }

   /**
    * It invoked when Google API client connected
    * @param connectionHint
    */
    @Override
    public void onConnected(Bundle connectionHint) {

        Toast.makeText(getApplicationContext(), "Connected", Toast.LENGTH_LONG).show();
    }

   /**
    * It invoked when connection suspended
    * @param cause
    */
    @Override
    public void onConnectionSuspended(int cause) {

        Log.i(TAG, "GoogleApiClient connection suspended");
    }

Créer un fichier sur Google Drive

Nous allons ajouter un fichier sur Google Drive. Nous allons utiliser la createFile() d'un objet Drive pour créer un fichier par programme sur Google Drive. Dans cet exemple nous ajoutons un nouveau fichier texte dans le dossier racine de l'utilisateur. Lorsqu'un fichier est ajouté, nous devons spécifier le jeu initial de métadonnées, le contenu du fichier et le dossier parent.

Nous devons créer une méthode de rappel CreateMyFile() et, au sein de cette méthode, utiliser l'objet Drive pour extraire une ressource DriveContents . Ensuite, nous passons le client API à l'objet Drive et appelons la méthode de rappel driveContentsCallback pour gérer le résultat de DriveContents .

Une ressource DriveContents contient une copie temporaire du flux binaire du fichier, uniquement disponible pour l'application.

public void CreateMyFile(){
    fileOperation = true;
    // Create new contents resource.
    Drive.DriveApi.newDriveContents(mGoogleApiClient)
                  .setResultCallback(driveContentsCallback);
}

Gestionnaire de résultat de DriveContents

La gestion de la réponse nécessite de vérifier si l'appel a réussi ou non. Si l'appel a réussi, nous pouvons récupérer la ressource DriveContents .

Nous allons créer un gestionnaire de résultats de DriveContents . Dans cette méthode, nous appelons la méthode CreateFileOnGoogleDrive() et transmettons le résultat de DriveContentsResult :

/**
 * This is the Result result handler of Drive contents.
 * This callback method calls the CreateFileOnGoogleDrive() method.
 */
final ResultCallback<DriveContentsResult> driveContentsCallback =
         new ResultCallback<DriveContentsResult>() {
            @Override
            public void onResult(DriveContentsResult result) {
                if (result.getStatus().isSuccess()) {
                    if (fileOperation == true){
                        CreateFileOnGoogleDrive(result);
                    }
                }
            }
        };

Créer un fichier par programme

Pour créer des fichiers, nous devons utiliser un objet MetadataChangeSet . En utilisant cet objet, nous définissons le titre (nom du fichier) et le type de fichier. En outre, nous devons utiliser la createFile() de la classe DriveFolder et transmettre l'API cliente Google, l'objet MetaDataChangeSet et driveContents pour créer un fichier. Nous appelons le rappel du gestionnaire de résultats pour gérer le résultat du fichier créé.

Nous utilisons le code suivant pour créer un nouveau fichier texte dans le dossier racine de l'utilisateur:

/**
 * Create a file in the root folder using a MetadataChangeSet object.
 * @param result
 */
public void CreateFileOnGoogleDrive(DriveContentsResult result){

    final DriveContents driveContents = result.getDriveContents();

    // Perform I/O off the UI thread.
    new Thread() {
        @Override
        public void run() {
            // Write content to DriveContents.
            OutputStream outputStream = driveContents.getOutputStream();
            Writer writer = new OutputStreamWriter(outputStream);
            try {
                writer.write("Hello Christlin!");
                writer.close();
            } catch (IOException e) {
                Log.e(TAG, e.getMessage());
            }

            MetadataChangeSet changeSet = new MetadataChangeSet.Builder()
                    .setTitle("My First Drive File")
                    .setMimeType("text/plain")
                    .setStarred(true).build();

            // Create a file in the root folder.
            Drive.DriveApi.getRootFolder(mGoogleApiClient)
                    .createFile(mGoogleApiClient, changeSet, driveContents)
                    setResultCallback(fileCallback);
        }
   }.start();
}

Gérer le résultat du fichier créé

Le code suivant créera une méthode de rappel pour gérer le résultat du fichier créé:

/**
 * Handle result of Created file
 */
final private ResultCallback<DriveFolder.DriveFileResult> fileCallback = new
        ResultCallback<DriveFolder.DriveFileResult>() {
            @Override
            public void onResult(DriveFolder.DriveFileResult result) {
                if (result.getStatus().isSuccess()) {
                    Toast.makeText(getApplicationContext(), "file created: "+
                                result.getDriveFile().getDriveId(), Toast.LENGTH_LONG).show();
                }
                return;
            }
        };