GoogleApiClient mGoogleApiClient=new GoogleApiClient.Builder(this)
    .addApi(Drive.API)
    .addScope(Drive.SCOPE_FILE)
    .build();

import gms.common.api.*;
import gms.drive.*;
import android.support.v4.app.FragmentActivity;

public classMyActivityextendsFragmentActivity
        implements ConnectionCallbacks, OnConnectionFailedListener {
    private GoogleApiClient mGoogleApiClient;

@Override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);

// Create a GoogleApiClient instance
        mGoogleApiClient = new GoogleApiClient.Builder(this)
                .addApi(Drive.API)
                .addScope(Drive.SCOPE_FILE)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .build();
        ...
    }

@Override
    public void onConnected(Bundle connectionHint){
        // Connected to Google Play services!
        // The good stuff goes here.
    }

@Override
    public void onConnectionSuspended(int cause){
        // The connection has been interrupted.
        // Disable any UI components that depend on Google APIs
        // until onConnected() is called.
    }

@Override
    public void onConnectionFailed(ConnectionResult result){
        // This callback is important for handling errors that
        // may occur while attempting to connect with Google.
        //
        // More about this in the next section.
        ...
    }
}

@Override
    protected void onStart(){
        super.onStart();
        if (!mResolvingError){  // more about this later
            mGoogleApiClient.connect();
        }
    }

@Override
    protected void onStop(){
        mGoogleApiClient.disconnect();
        super.onStop();
    }

public class MyActivity extends FragmentActivity
        implements ConnectionCallbacks, OnConnectionFailedListener {

// Requestcode to use when launching the resolution activity
    private staticfinalint REQUEST_RESOLVE_ERROR=1001;
    // Uniquetag for the error dialog fragment
    private staticfinalString DIALOG_ERROR="dialog_error";
    // Bool totrack whether the app is already resolving an error
    private boolean mResolvingError=false;

...

@Override
    public void onConnectionFailed(ConnectionResult result){
        if (mResolvingError){
            // Already attempting to resolve an error.

//如果正在解决这个错误，什么也不做
            return;
        } elseif(result.hasResolution()){
            try {
                mResolvingError = true;
                result.startResolutionForResult(this, REQUEST_RESOLVE_ERROR);
            } catch(SendIntentException e){
                // There was an error with theresolution intent. Try again.
                mGoogleApiClient.connect();
            }
        } else{
            // Show dialog usingGooglePlayServicesUtil.getErrorDialog()
            showErrorDialog(result.getErrorCode());
            mResolvingError = true;
        }
    }

// The restof this code is all about building the error dialog

/* Creates adialog for an error message */
    private void showErrorDialog(int errorCode){
        // Create a fragment for the error dialog
        ErrorDialogFragment dialogFragment = new ErrorDialogFragment();
        // Pass the error that should be displayed
        Bundle args = new Bundle();
        args.putInt(DIALOG_ERROR, errorCode);
        dialogFragment.setArguments(args);
        dialogFragment.show(getSupportFragmentManager(),"errordialog");
    }

/* Calledfrom ErrorDialogFragment when the dialog is dismissed. */
    public void onDialogDismissed(){
        mResolvingError = false;
    }

/* Afragment to display an error dialog */
    public staticclassErrorDialogFragmentextendsDialogFragment{
        public ErrorDialogFragment(){}

@Override
        public Dialog onCreateDialog(Bundle savedInstanceState){
            // Get the error code and retrieve theappropriate dialog
            int errorCode = this.getArguments().getInt(DIALOG_ERROR);
            return GooglePlayServicesUtil.getErrorDialog(errorCode,
                    this.getActivity(), REQUEST_RESOLVE_ERROR);
        }

@Override
        public void onDismiss(DialogInterface dialog){
            ((MainActivity)getActivity()).onDialogDismissed();
        }
    }
}

@Override
protected void onActivityResult(int requestCode,int resultCode,Intent data){
    if (requestCode== REQUEST_RESOLVE_ERROR){
        mResolvingError = false;
        if (resultCode== RESULT_OK){
            // Make sure the app is not alreadyconnected or attempting to connect
            if (!mGoogleApiClient.isConnecting()&&
                    !mGoogleApiClient.isConnected()){
                mGoogleApiClient.connect();
            }
        }
    }
}

private static final String STATE_RESOLVING_ERROR = "resolving_error";

@Override
protected void onSaveInstanceState(Bundle outState){
    super.onSaveInstanceState(outState);
    outState.putBoolean(STATE_RESOLVING_ERROR, mResolvingError);
}

@Override
protected void onCreate(Bundle savedInstanceState){
    super.onCreate(savedInstanceState);

...
    mResolvingError = savedInstanceState != null
            && savedInstanceState.getBoolean(STATE_RESOLVING_ERROR,false);
}

// Connection failed listener method for a client thatonly
// requestsaccess to the Wearable API
@Override
public void onConnectionFailed(ConnectionResult result){
    if (result.getErrorCode()==ConnectionResult.API_UNAVAILABLE){
        // The Android Wear app is not installed
    }
    ...
}

Query query = new Query.Builder()
        .addFilter(Filters.eq(SearchableField.TITLE, filename));
PendingResult result = Drive.DriveApi.query(mGoogleApiClient, query);

private void loadFile(String filename){
    // Create aquery for a specific filename in Drive.
    Query query =newQuery.Builder()
            .addFilter(Filters.eq(SearchableField.TITLE, filename))
            .build();
    // Invokethe query asynchronously with a callback method
    Drive.DriveApi.query(mGoogleApiClient, query)
            .setResultCallback(newResultCallback<DriveApi.MetadataBufferResult>(){
        @Override
        public void onResult(DriveApi.MetadataBufferResult result) {
            // Success! Handle the query result.
            ...
        }
    });
}

private void loadFile(String filename){
    new GetFileTask().execute(filename);
}

private classGetFileTaskextendsAsyncTask<String,Void,Void> {
    protected void doInBackground(String filename){
        Query query = new Query.Builder()
                .addFilter(Filters.eq(SearchableField.TITLE, filename))
                .build();
        // Invoke the query synchronously
        DriveApi.MetadataBufferResult result=
                Drive.DriveApi.query(mGoogleApiClient, query).await();

// Continue doing other stuff synchronously
        ...
    }
}