Android
Google Drive API

Introduktion

Anmärkningar

Integrera Google Drive i Android

Skapa ett nytt projekt på Google Developer Console

För att integrera Android-applikationen med Google Drive skapar du projektets referenser i Google Developers Console. Så vi måste skapa ett projekt på Google Developer Console.

Så här skapar du ett projekt på Google Developer Console:

• Gå till Google Developer Console för Android. Fyll ditt projektnamnet i inmatningsfältet och klicka på knappen Skapa för att skapa ett nytt projekt på Google utvecklarkonsolen.

• Vi måste skapa referenser för att komma åt API. Så, klicka på knappen Skapa referenser .

• Nu öppnas ett pop-fönster. Klicka på alternativet API-nyckel i listan för att skapa API-nyckel.

• Vi behöver en API-nyckel för att kalla Google API: er för Android. Så, klicka på Android-nyckeln för att identifiera ditt Android-projekt.

• Därefter måste vi lägga till paketnamn för Android-projektet och SHA-1-fingeravtryck i inmatningsfältet för att skapa API-nyckel.

• Vi måste skapa SHA-1-fingeravtryck . Så öppna din terminal och kör Keytool-verktyget för att få SHA1-fingeravtrycket. När du kör Keytool-verktyget måste du ange lösenord för keystore . Standardutveckling keytool lösenord är "Android" . keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v

• Lägg nu till paketnamn och SHA-1-fingeravtryck i inmatningsfält på referenssidan. Slutligen, klicka på skapa-knappen för att skapa API-nyckel.

• Detta skapar API-nyckel för Android. Vi kommer att använda denna API-nyckel för att integrera Android-applikationen med Google Drive.

Aktivera Google Drive API

Vi måste aktivera Google Drive Api för att få åtkomst till filer lagrade på Google Drive från Android-applikationen. Så här aktiverar du Google Drive API:

• Gå till din Google Developer Console Dashboard och klicka på Aktivera API: er få referenser som nycklar så ser du populära Google API: er.

• Klicka på Drive API- länken för att öppna översiktssidan för Google Drive API.

• Klicka på Aktivera för att aktivera Google Drive API. Det ger klientåtkomst till Google Drive.

Lägg till Internet-tillstånd

App behöver Internet- åtkomst till Google Drive-filer. Använd följande kod för att ställa in Internetbehörigheter i filen AndroidManifest.xml:

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

Lägg till Google Play-tjänster

Vi kommer att använda Google Play Services API som inkluderar Google Drive Android API . Så vi måste konfigurera Google Play-tjänster SDK i Android-applikationen. Öppna build.gradle ( build.gradle ) och lägg till Google Play Services SDK som beroenden.

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

Lägg till API-nyckel i Manifest-filen

För att kunna använda Google API i Android-applikationen måste vi lägga till API-nyckel och version av Google Play-tjänsten i filen AndroidManifest.xml. Lägg till rätt metadatataggar i taggen i filen AndroidManifest.xml.

Anslut och auktorisera Google Drive Android API

Vi måste verifiera och ansluta Google Drive Android API till Android-applikationen. Godkännande av Google Drive Android API hanteras av GoogleApiClient . Vi kommer att använda GoogleApiClient i metoden 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();
    }

Koppla från Google Deive Android API

När aktiviteten upphör kommer vi att koppla från Google Drive Android API-anslutningen med Android-applikationen genom att ringa frånkopplingsmetoden () i aktivitetens onStop () -metod.

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

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

Implementera anslutningssuppringningar och anslutning misslyckades lyssnare

Vi kommer att implementera Connection Callbacks och Connection Failed Listener för Google API-klient i MainActivity.java-fil för att veta status om anslutning av Google API-klient. Dessa lyssnare tillhandahåller metoden OnConnected (), onConnectionFailed (), onConnectionSuspended () för att hantera anslutningsfrågorna mellan app och Drive.

Om användaren har godkänt applikationen åberopas metoden onConnected () . Om användaren inte har godkänt ansökan startas onConnectionFailed () -metoden och en dialogruta visas för användaren att din app inte är behörig att få åtkomst till Google Drive. Om anslutningen avbryts kallas metoden onConnectionSuspended () .

Du måste implementera ConnectionCallbacks och OnConnectionFailedListener i din aktivitet. Använd följande kod i din Java-fil.

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

Skapa en fil på Google Drive

Vi lägger till en fil på Google Drive. Vi kommer att använda createFile() för ett Drive objekt för att skapa fil programmatiskt på Google Drive. I det här exemplet lägger vi till en ny textfil i användarens rotmapp. När en fil läggs till måste vi ange den ursprungliga uppsättningen metadata, filinnehåll och överordnad mapp.

Vi måste skapa en CreateMyFile() återuppringningsmetod och inom den här metoden använder du Drive objektet för att hämta en DriveContents resurs. Sedan skickar vi API-klienten till Drive objektet och kallar driveContentsCallback återuppringningsmetoden för att hantera resultatet av DriveContents .

En DriveContents resurs innehåller en tillfällig kopia av filens binära ström som endast är tillgänglig för applikationen.

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

Resultathandlare av DriveContents

För att hantera svaret måste du kontrollera om samtalet lyckades eller inte. Om samtalet lyckades kan vi hämta DriveContents resursen.

Vi kommer att skapa en resultathanterare av DriveContents . Inom den här metoden kallar vi metoden CreateFileOnGoogleDrive() och DriveContentsResult resultatet av 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);
                    }
                }
            }
        };

Skapa fil programmatiskt

För att skapa filer måste vi använda ett MetadataChangeSet objekt. Genom att använda detta objekt ställer vi in titeln (filnamn) och filtyp. Vi måste också använda createFile() i klassen DriveFolder och passera Google-klient-API: et, MetaDataChangeSet objektet och driveContents att skapa en fil. Vi kallar återhämtning av resultathanteraren för att hantera resultatet av den skapade filen.

Vi använder följande kod för att skapa en ny textfil i användarens rotmapp:

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

Hantera resultatet av Skapad fil

Följande kod skapar en återuppringningsmetod för att hantera resultatet av den skapade filen:

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