Android
API di Google Drive

introduzione

Osservazioni

Integra Google Drive in Android

Crea un nuovo progetto su Google Developer Console

Per integrare l'applicazione Android con Google Drive, crea le credenziali del progetto nella Google Developers Console. Pertanto, dobbiamo creare un progetto sulla Console per gli sviluppatori di Google.

Per creare un progetto su Google Developer Console, procedi nel seguente modo:

• Vai a Google Developer Console per Android. Riempi il tuo nome del progetto nel campo di immissione e fare clic sul pulsante Crea per creare un nuovo progetto su console per sviluppatori Google.

• Dobbiamo creare credenziali per accedere all'API. Quindi, fare clic sul pulsante Crea credenziali .

• Ora, si aprirà una finestra pop. Fare clic sull'opzione Chiave API nell'elenco per creare la chiave API.

• Abbiamo bisogno di una chiave API per chiamare le API di Google per Android. Quindi, fai clic sulla chiave Android per identificare il tuo progetto Android.

• Successivamente, dobbiamo aggiungere il nome del pacchetto del progetto Android e l' impronta digitale SHA-1 nei campi di input per creare la chiave API.

• Abbiamo bisogno di generare un'impronta digitale SHA-1 . Quindi, apri il tuo terminale ed esegui l' utilità Keytool per ottenere l'impronta digitale SHA1. Durante l'esecuzione dell'utilità Keytool, è necessario fornire la password del keystore . La password keytool di sviluppo predefinita è "android" . keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v

• Ora aggiungi il nome del pacchetto e l' impronta digitale SHA-1 nei campi di inserimento nella pagina delle credenziali. Infine, fai clic sul pulsante Crea per creare la chiave API.

• Questo creerà la chiave API per Android. Utilizzeremo questa chiave API per integrare l'applicazione Android con Google Drive.

Abilita l'API di Google Drive

Dobbiamo abilitare Google Drive Api per accedere ai file memorizzati su Google Drive dall'applicazione Android. Per abilitare l'API di Google Drive, procedi nel seguente modo:

• Vai alla Dashboard della tua Console per gli sviluppatori di Google e fai clic su Abilita le API per ottenere credenziali come le chiavi, quindi vedrai le API di Google più diffuse.

• Fai clic sul link Drive API per aprire la pagina di panoramica dell'API di Google Drive.

• Fai clic sul pulsante Abilita per abilitare l'API di Google Drive. Consente l'accesso client a Google Drive.

Aggiungi autorizzazione Internet

L'app ha bisogno di accesso a Internet I file di Google Drive. Utilizzare il seguente codice per impostare le autorizzazioni Internet nel file AndroidManifest.xml:

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

Aggiungi Google Play Services

Useremo Google Play Services API che include l' API di Google Drive per Android . Pertanto, dobbiamo configurare l'SDK dei servizi di gioco di Google nell'applicazione Android. Apri il tuo file build.gradle (modulo app) e aggiungi l'SDK di Google Play Services come dipendenze.

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

Aggiungi la chiave API nel file manifest

Per utilizzare l'API di Google nell'applicazione Android, è necessario aggiungere la chiave API e la versione del servizio Google Play nel file AndroidManifest.xml. Aggiungi i tag di metadati corretti all'interno del tag del file AndroidManifest.xml.

Collega e autorizza l'API Android di Google Drive

Dobbiamo autenticare e connettere l' API Android di Google Drive con l'applicazione Android. L'autorizzazione dell'API Android di Google Drive è gestita da GoogleApiClient . Useremo GoogleApiClient all'interno del metodo 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();
    }

Disconnetti API Google Deive Android

Quando l'attività si interrompe, disconnetteremo la connessione dell'API Android di Google Drive con l'applicazione Android chiamando il metodo disconnect () all'interno del metodo onStop () dell'attività.

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

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

Implementare le chiamate di connessione e il listener non riuscito alla connessione

Implementeremo Connection Callbacks e Connection Failed Listener del client API di Google nel file MainActivity.java per conoscere lo stato della connessione del client API di Google. Questi listener forniscono il metodo onConnected (), onConnectionFailed (), onConnectionSuspended () per gestire i problemi di connessione tra app e Drive.

Se l'utente ha autorizzato l'applicazione, viene invocato il metodo onConnected () . Se l'utente non ha autorizzato l'applicazione, viene invocato il metodo onConnectionFailed () e all'utente viene visualizzata una finestra di dialogo in cui l'app non è autorizzata ad accedere a Google Drive. Nel caso in cui la connessione sia sospesa, viene chiamato il metodo onConnectionSuspended () .

È necessario implementare ConnectionCallbacks e OnConnectionFailedListener nella propria attività. Usa il seguente codice nel tuo file 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");
    }

Crea un file su Google Drive

Aggiungeremo un file su Google Drive. Useremo il metodo createFile() di un oggetto Drive per creare un file a livello di codice su Google Drive. In questo esempio stiamo aggiungendo un nuovo file di testo nella cartella principale dell'utente. Quando viene aggiunto un file, è necessario specificare il set iniziale di metadati, contenuto del file e cartella principale.

Dobbiamo creare un metodo di callback CreateMyFile() e all'interno di questo metodo, utilizzare l'oggetto Drive per recuperare una risorsa DriveContents . Quindi passiamo il client API all'oggetto Drive e richiamiamo il metodo callback driveContentsCallback per gestire il risultato di DriveContents .

Una risorsa DriveContents contiene una copia temporanea del flusso binario del file, disponibile solo per l'applicazione.

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

Gestore dei risultati di DriveContents

Per gestire la risposta è necessario verificare se la chiamata è andata a buon fine o meno. Se la chiamata ha avuto successo, possiamo recuperare la risorsa DriveContents .

Creeremo un gestore di risultati di DriveContents . All'interno di questo metodo, chiamiamo il metodo CreateFileOnGoogleDrive() e passiamo il risultato di 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);
                    }
                }
            }
        };

Crea file a livello di programmazione

Per creare file, è necessario utilizzare un oggetto MetadataChangeSet . Usando questo oggetto, impostiamo il titolo (nome del file) e il tipo di file. Inoltre, dobbiamo utilizzare il metodo createFile() della classe DriveFolder e passare l'API del client Google, l'oggetto MetaDataChangeSet e il driveContents per creare un file. Chiamiamo il callback del gestore di risultati per gestire il risultato del file creato.

Usiamo il seguente codice per creare un nuovo file di testo nella cartella principale dell'utente:

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

Gestire il risultato del file creato

Il codice seguente creerà un metodo di callback per gestire il risultato del file creato:

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