Android
Google Drive API

Einführung

Bemerkungen

Integrieren Sie Google Drive in Android

Erstellen Sie ein neues Projekt in der Google Developer Console

Um die Android-Anwendung in Google Drive zu integrieren, erstellen Sie die Anmeldeinformationen des Projekts in der Google Developers Console. Daher müssen wir ein Projekt in der Google Developer Console erstellen.

Führen Sie die folgenden Schritte aus, um ein Projekt in der Google Developer Console zu erstellen:

• Rufen Sie die Google Developer Console für Android auf. Füllen Sie Ihren Projektnamen in das Eingabefeld ein und klicken Sie auf die Schaltfläche Erstellen Sie ein neues Projekt auf Google Developer - Konsole zu erstellen.

• Wir müssen Anmeldeinformationen erstellen, um auf die API zuzugreifen. Klicken Sie also auf die Schaltfläche Anmeldeinformationen erstellen .

• Nun öffnet sich ein Popup-Fenster. Klicken Sie auf API Key - Option in der Liste API - Schlüssel zu erstellen.

• Wir benötigen einen API-Schlüssel, um Google-APIs für Android aufzurufen. Klicken Sie also auf den Android-Schlüssel , um Ihr Android-Projekt zu identifizieren.

• Als Nächstes müssen wir den Paketnamen des Android-Projekts und den SHA-1-Fingerabdruck in den Eingabefeldern hinzufügen, um den API-Schlüssel zu erstellen.

• Wir müssen SHA-1-Fingerabdruck erstellen . Öffnen Sie also Ihr Terminal und führen Sie das Dienstprogramm Keytool aus , um den SHA1-Fingerabdruck zu erhalten. Während Keytool - Dienstprogramm ausgeführt wird , müssen Sie Kennwort für Schlüsselspeicher zur Verfügung zu stellen. Das Standardkennwort für das Entwicklungs-Keytool lautet „Android“ . keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v

• Fügen Sie nun in den Eingabefeldern auf der Seite mit den Anmeldeinformationen den Paketnamen und den SHA-1-Fingerabdruck hinzu . Klicken Sie abschließend auf die Schaltfläche Erstellen, um den API-Schlüssel zu erstellen.

• Dadurch wird ein API-Schlüssel für Android erstellt. Wir verwenden diesen API-Schlüssel, um die Android-Anwendung in Google Drive zu integrieren.

Aktivieren Sie die Google Drive-API

Wir müssen Google Drive Api für den Zugriff auf auf Google Drive gespeicherte Dateien über eine Android-Anwendung aktivieren. Führen Sie die folgenden Schritte aus, um die Google Drive-API zu aktivieren:

• Gehen Sie zu Ihrem Google Developer Console-Dashboard und klicken Sie auf " APIs aktivieren", um Anmeldeinformationen wie Schlüssel zu erhalten. Anschließend werden beliebte Google-APIs angezeigt.

• Klicken Sie auf den Link Drive API , um die Übersichtsseite der Google Drive API zu öffnen.

• Klicken Sie auf die Schaltfläche Aktivieren, um die Google Drive API zu aktivieren. Es ermöglicht dem Client den Zugriff auf Google Drive.

Internet-Berechtigung hinzufügen

App benötigt Internet- Zugriff auf Google Drive-Dateien. Verwenden Sie den folgenden Code, um Internetberechtigungen in der Datei AndroidManifest.xml einzurichten:

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

Google Play-Services hinzufügen

Wir verwenden die Google Play-Services-API, zu der die Google Drive-Android-API gehört . Daher müssen wir das Google Play-Services-SDK in der Android-Anwendung einrichten. Öffnen Sie Ihre build.gradle Datei (App-Modul) und fügen Sie das SDK des Google play-Services als Abhängigkeiten hinzu.

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

Fügen Sie den API-Schlüssel in der Manifest-Datei hinzu

Um die Google-API in einer Android-Anwendung verwenden zu können, müssen Sie der Datei AndroidManifest.xml den API-Schlüssel und die Version des Google Play-Diensts hinzufügen. Fügen Sie die richtigen Metadaten-Tags in das Tag der Datei AndroidManifest.xml ein.

Verbinden und autorisieren Sie die Google Drive Android API

Wir müssen die Google Drive Android API mit der Android-Anwendung authentifizieren und verbinden. Die Autorisierung der Google Drive Android API wird vom GoogleApiClient übernommen . Wir verwenden GoogleApiClient innerhalb der onResume () -Methode.

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

Trennen Sie die Google Deive Android API

Wenn die Aktivität endet, trennen wir die Verbindung zwischen der Google Drive Android API-Verbindung und der Android-Anwendung, indem wir die Methode disconnect () in der Methode onStop () der Aktivität aufrufen .

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

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

Implementieren Sie Verbindungsrückrufe und einen Listener für fehlgeschlagene Verbindung

Wir implementieren Connection Callbacks und Connection Failed Listener des Google API-Clients in der Datei MainActivity.java, um den Status der Verbindung des Google API-Clients zu erfahren. Diese Listener bieten die Methoden onConnected (), onConnectionFailed (), onConnectionSuspended () , um Verbindungsprobleme zwischen App und Laufwerk zu behandeln.

Wenn der Benutzer die Anwendung autorisiert hat, wird die onConnected () - Methode aufgerufen. Wenn der Benutzer keine Anwendung autorisiert hat, wird die Methode onConnectionFailed () aufgerufen, und dem Benutzer wird ein Dialogfeld angezeigt, dass Ihre App nicht zum Zugriff auf Google Drive berechtigt ist. Wenn die Verbindung unterbrochen wird, wird die Methode onConnectionSuspended () aufgerufen.

Sie müssen ConnectionCallbacks und OnConnectionFailedListener in Ihrer Aktivität implementieren. Verwenden Sie den folgenden Code in Ihrer Java-Datei.

@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");
    }

Erstellen Sie eine Datei in Google Drive

Wir werden eine Datei in Google Drive hinzufügen. Wir verwenden die createFile() -Methode eines Drive Objekts, um Dateien programmgesteuert in Google Drive zu erstellen. In diesem Beispiel fügen wir eine neue Textdatei im Stammordner des Benutzers hinzu. Wenn eine Datei hinzugefügt wird, müssen der erste Satz Metadaten, der Inhalt der Datei und der übergeordnete Ordner angegeben werden.

Wir müssen eine CreateMyFile() Callback-Methode erstellen und innerhalb dieser Methode das Drive Objekt verwenden, um eine DriveContents Ressource DriveContents . Dann übergeben wir den API-Client an das Drive Objekt und rufen die driveContentsCallback Callback-Methode auf, um das Ergebnis von DriveContents .

Eine DriveContents Ressource enthält eine temporäre Kopie des binären Datenstroms der Datei, die nur für die Anwendung verfügbar ist.

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

Result Handler von DriveContents

Für die Bearbeitung der Antwort muss geprüft werden, ob der Anruf erfolgreich war oder nicht. Wenn der Aufruf erfolgreich war, können wir die DriveContents Ressource DriveContents .

Wir erstellen einen Ergebnis-Handler für DriveContents . In dieser Methode rufen wir die CreateFileOnGoogleDrive() Methode auf und übergeben das Ergebnis von 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);
                    }
                }
            }
        };

Erstellen Sie eine Datei programmgesteuert

Um Dateien zu erstellen, müssen wir ein MetadataChangeSet Objekt verwenden. Mit diesem Objekt legen wir den Titel (Dateinamen) und den Dateityp fest. Außerdem müssen wir die createFile() Methode der DriveFolder Klasse verwenden und die Google-Client-API, das MetaDataChangeSet Objekt und das driveContents , um eine Datei zu erstellen. Wir rufen den Callback des Ergebnishandlers auf, um das Ergebnis der erstellten Datei zu behandeln.

Wir verwenden den folgenden Code, um eine neue Textdatei im Stammverzeichnis des Benutzers zu erstellen:

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

Ergebnis der erstellten Datei behandeln

Der folgende Code erstellt eine Callback-Methode, um das Ergebnis der erstellten Datei zu verarbeiten:

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