Android
API de Google Drive

Introducción

Observaciones

Integrar Google Drive en Android

Crear un nuevo proyecto en la consola de desarrolladores de Google

Para integrar la aplicación de Android con Google Drive, cree las credenciales del proyecto en la Consola de desarrolladores de Google. Por lo tanto, necesitamos crear un proyecto en la consola de desarrolladores de Google.

Para crear un proyecto en la Consola de desarrollador de Google, siga estos pasos:

• Ir a la consola de desarrolladores de Google para Android. Rellene el nombre del proyecto en el campo de entrada y haga clic en el botón Crear para crear un nuevo proyecto en Google consola de desarrollador.

• Necesitamos crear credenciales para acceder a la API. Por lo tanto, haga clic en el botón Crear credenciales .

• Ahora, se abrirá una ventana emergente. Haga clic en la opción Clave de API en la lista para crear la clave de API.

• Necesitamos una clave API para llamar a las API de Google para Android. Por lo tanto, haga clic en la tecla Android para identificar su proyecto Android.

• A continuación, debemos agregar el Nombre del paquete del proyecto de Android y la huella dactilar SHA-1 en los campos de entrada para crear la clave API.

• Necesitamos generar la huella dactilar SHA-1 . Por lo tanto, abra su terminal y ejecute la utilidad Keytool para obtener la huella digital SHA1. Mientras ejecuta la utilidad Keytool, debe proporcionar la contraseña del almacén de claves . La clave de desarrollo predeterminada de la herramienta keytool es "android" . keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v

• Ahora, agregue el nombre del paquete y la huella digital SHA-1 en los campos de entrada en la página de credenciales. Finalmente, haga clic en el botón crear para crear la clave API.

• Esto creará la clave API para Android. Utilizaremos esta clave API para integrar la aplicación de Android con Google Drive.

Habilitar API de Google Drive

Necesitamos habilitar Google Drive Api para acceder a los archivos almacenados en Google Drive desde la aplicación de Android. Para habilitar la API de Google Drive, siga los siguientes pasos:

• Vaya al panel de la consola de Google Developer y haga clic en Habilitar APIs para obtener credenciales como claves, luego verá las populares API de Google.

• Haga clic en el enlace de Drive API para abrir la página de información general de Google Drive API.

• Haga clic en el botón Habilitar para habilitar la API de Google drive. Permite el acceso del cliente a Google Drive.

Añadir permiso de Internet

La aplicación necesita acceso a Internet archivos de Google Drive. Use el siguiente código para configurar los permisos de Internet en el archivo AndroidManifest.xml:

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

Añadir servicios de Google Play

Utilizaremos la API de servicios de Google Play, que incluye la API de Android de Google Drive . Por lo tanto, necesitamos configurar los servicios de Google Play SDK en la aplicación de Android. Abra su build.gradle (módulo de aplicación) y agregue el SDK de servicios de Google Play como dependencias.

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

Añadir clave de API en el archivo de manifiesto

Para utilizar la API de Google en la aplicación de Android, debemos agregar la clave de la API y la versión del servicio Google Play en el archivo AndroidManifest.xml. Agregue las etiquetas de metadatos correctas dentro de la etiqueta del archivo AndroidManifest.xml.

Conectar y Autorizar la API de Android de Google Drive

Necesitamos autenticar y conectar la API de Android de Google Drive con la aplicación de Android. La autorización de Google Drive Android API es manejada por GoogleApiClient . Usaremos GoogleApiClient dentro del método 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();
    }

Desconecta Google Deive Android API

Cuando la actividad se detenga, desconectaremos la conexión de la API de Android de Google Drive con la aplicación de Android llamando al método disconnect () dentro del método onStop () de la actividad .

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

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

Implementar devoluciones de llamada de conexión y escucha de conexión fallida

Implementaremos las devoluciones de llamada de conexión y la escucha de conexión fallida del cliente API de Google en el archivo MainActivity.java para conocer el estado de la conexión del cliente API de Google. Estos escuchas proporcionan el método onConnected (), onConnectionFailed (), onConnectionSuspended () para manejar los problemas de conexión entre la aplicación y la unidad.

Si el usuario ha autorizado la aplicación, se invoca el método onConnected () . Si el usuario no ha autorizado la aplicación, se invoca el método onConnectionFailed () y se muestra un cuadro de diálogo que indica que su aplicación no está autorizada para acceder a Google Drive. En caso de que se suspenda la conexión, se llama al método onConnectionSuspended () .

Debe implementar ConnectionCallbacks y OnConnectionFailedListener en su actividad. Usa el siguiente código en tu archivo 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");
    }

Crear un archivo en Google Drive

Añadiremos un archivo en Google Drive. Usaremos el método createFile() de un objeto Drive para crear un archivo mediante programación en Google Drive. En este ejemplo, estamos agregando un nuevo archivo de texto en la carpeta raíz del usuario. Cuando se agrega un archivo, debemos especificar el conjunto inicial de metadatos, el contenido del archivo y la carpeta principal.

Necesitamos crear un método de devolución de llamada CreateMyFile() y, dentro de este método, usar el objeto Drive para recuperar un recurso DriveContents . Luego pasamos el cliente API al objeto Drive y llamamos al método de devolución de llamada driveContentsCallback para manejar el resultado de DriveContents .

Un recurso DriveContents contiene una copia temporal del flujo binario del archivo que solo está disponible para la aplicación.

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

Controlador de resultados de DriveContents

El manejo de la respuesta requiere verificar si la llamada fue exitosa o no. Si la llamada fue exitosa, podemos recuperar el recurso DriveContents .

Crearemos un manejador de resultados de DriveContents . Dentro de este método, llamamos al método CreateFileOnGoogleDrive() y pasamos el resultado 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);
                    }
                }
            }
        };

Crear archivo programáticamente

Para crear archivos, necesitamos usar un objeto MetadataChangeSet . Al usar este objeto, establecemos el título (nombre del archivo) y el tipo de archivo. Además, debemos usar el método createFile() de la clase DriveFolder y pasar la API del cliente de Google, el objeto MetaDataChangeSet y driveContents para crear un archivo. Llamamos a la devolución de llamada del manejador de resultados para manejar el resultado del archivo creado.

Usamos el siguiente código para crear un nuevo archivo de texto en la carpeta raíz del usuario:

/**
 * 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();
}

Manejar el resultado del archivo creado

El siguiente código creará un método de devolución de llamada para manejar el resultado del archivo creado:

/**
 * 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;
            }
        };