Android
Interfejs API Dysku Google

Wprowadzenie

Uwagi

Zintegruj Dysk Google z Androidem

Utwórz nowy projekt w Google Developer Console

Aby zintegrować aplikację Android z Dyskiem Google, utwórz poświadczenia projektu w Google Developers Console. Musimy więc stworzyć projekt na konsoli programisty Google.

Aby utworzyć projekt w Google Developer Console, wykonaj następujące kroki:

• Przejdź do Google Developer Console na Androida. Wpisz nazwę projektu w polu wejściowym i kliknij przycisk Utwórz , aby utworzyć nowy projekt w konsoli programisty Google.

• Musimy utworzyć poświadczenia, aby uzyskać dostęp do interfejsu API. Kliknij przycisk Utwórz poświadczenia .

• Teraz otworzy się okno pop. Kliknij opcję Klucz API na liście, aby utworzyć klucz API.

• Potrzebujemy klucza API, aby wywoływać interfejsy API Google dla Androida. Kliknij przycisk Android, aby zidentyfikować swój projekt Android.

• Następnie musimy dodać nazwę pakietu projektu Android i odcisk palca SHA-1 w polach wejściowych, aby utworzyć klucz API.

• Musimy wygenerować odcisk palca SHA-1 . Otwórz terminal i uruchom narzędzie Keytool, aby uzyskać odcisk palca SHA1. Podczas działania narzędzia Keytool musisz podać hasło do magazynu kluczy . Domyślne hasło do narzędzi programistycznych to „android” . keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v

• Teraz dodaj nazwę pakietu i odcisk palca SHA-1 w polach wejściowych na stronie poświadczeń. Na koniec kliknij przycisk Utwórz, aby utworzyć klucz API.

• Spowoduje to utworzenie klucza API dla Androida. Użyjemy tego klucza API do zintegrowania aplikacji na Androida z Dyskiem Google.

Włącz interfejs API Dysku Google

Musimy włączyć Google Drive Api, aby uzyskać dostęp do plików przechowywanych na Dysku Google z aplikacji na Androida. Aby włączyć interfejs API Dysku Google, wykonaj następujące kroki:

• Przejdź do pulpitu nawigacyjnego konsoli programisty Google i kliknij opcję Włącz interfejsy API, aby uzyskać poświadczenia, takie jak klucze, a następnie zobaczysz popularne interfejsy API Google.

• Kliknij link Drive API, aby otworzyć stronę przeglądu interfejsu API Google Drive.

• Kliknij przycisk Włącz, aby włączyć interfejs API dysku Google. Umożliwia dostęp klienta do Dysku Google.

Dodaj uprawnienie do Internetu

Aplikacja wymaga dostępu do Internetu na Dysku Google. Użyj poniższego kodu, aby skonfigurować uprawnienia internetowe w pliku AndroidManifest.xml:

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

Dodaj usługi Google Play

Będziemy używać interfejsu API usług Google Play, który obejmuje interfejs API Dysku Google na Androida . Musimy więc skonfigurować zestaw SDK usług Google Play w aplikacji na Androida. Otwórz plik build.gradle (moduł aplikacji) i dodaj zestaw SDK usług Google Play jako zależności.

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

Dodaj klucz API w pliku manifestu

Aby korzystać z Google API w aplikacji na Androida, musimy dodać klucz API i wersję usługi Google Play w pliku AndroidManifest.xml. Dodaj prawidłowe znaczniki metadanych do znacznika pliku AndroidManifest.xml.

Połącz i autoryzuj interfejs API Google Drive Android

Musimy uwierzytelnić interfejs Google Drive Android API i połączyć go z aplikacją na Androida. Autoryzacją interfejsu API Dysku Google na Androida zajmuje się GoogleApiClient . Będziemy używać GoogleApiClient w ramach metody 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();
    }

Odłącz Google Deive Android API

Gdy aktywność się zatrzyma, rozłączymy połączenie interfejsu API systemu Android z Dyskiem Google z aplikacją na Androida, wywołując metodę rozłączania () w metodzie onStop () działania .

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

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

Wdrożenie wywołań zwrotnych połączeń i nasłuchu połączenia nieudanego

Zaimplementujemy wywołania zwrotne połączeń i nasłuchiwanie połączenia klienta Google API w pliku MainActivity.java, aby poznać stan połączenia klienta Google API. Te detektory dostarczają metody onConnected (), onConnectionFailed (), onConnectionSuspended () do obsługi problemów z połączeniem między aplikacją a Dyskiem.

Jeśli użytkownik autoryzował aplikację, wywoływana jest metoda onConnected () . Jeśli użytkownik nie autoryzował aplikacji, wywoływana jest metoda onConnectionFailed () i wyświetla się okno dialogowe informujące, że aplikacja nie ma uprawnień dostępu do Dysku Google. W przypadku zawieszenia połączenia wywoływana jest metoda onConnectionSuspended () .

Musisz zaimplementować ConnectionCallbacks i OnConnectionFailedListener w swojej działalności. Użyj następującego kodu w pliku 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");
    }

Utwórz plik na Dysku Google

Dodamy plik na Dysk Google. Użyjemy metody createFile() obiektu Drive aby programowo utworzyć plik na Dysku Google. W tym przykładzie dodajemy nowy plik tekstowy w folderze głównym użytkownika. Po dodaniu pliku musimy określić początkowy zestaw metadanych, zawartość pliku i folder nadrzędny.

Musimy utworzyć metodę wywołania zwrotnego CreateMyFile() iw tej metodzie użyj obiektu Drive aby pobrać zasób DriveContents . Następnie przekazujemy klienta API do obiektu Drive i wywołujemy driveContentsCallback callback driveContentsCallback , aby obsłużyć wynik DriveContents .

Zasób DriveContents zawiera tymczasową kopię strumienia binarnego pliku, który jest dostępny tylko dla aplikacji.

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

Moduł obsługi wyników DriveContents

Obsługa odpowiedzi wymaga sprawdzenia, czy połączenie zakończyło się powodzeniem, czy nie. Jeśli połączenie się powiedzie, możemy odzyskać zasób DriveContents .

Stworzymy DriveContents obsługi wyników DriveContents . W ramach tej metody wywołujemy metodę CreateFileOnGoogleDrive() i przekazujemy wynik 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);
                    }
                }
            }
        };

Utwórz plik programowo

Aby utworzyć pliki, musimy użyć obiektu MetadataChangeSet . Za pomocą tego obiektu ustawiamy tytuł (nazwę pliku) i typ pliku. Ponadto musimy użyć metody createFile() klasy DriveFolder i przekazać interfejs API klienta Google, obiekt MetaDataChangeSet i driveContents aby utworzyć plik. Wywołujemy wywołanie zwrotne modułu obsługi wyników w celu obsługi wyniku utworzonego pliku.

Używamy następującego kodu, aby utworzyć nowy plik tekstowy w folderze głównym użytkownika:

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

Obsługa wyniku utworzonego pliku

Poniższy kod utworzy metodę wywołania zwrotnego do obsługi wyniku utworzonego pliku:

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