Google Drive Android API wie zum hochladen einer audio-Datei auf meinem Laufwerk ? , Wie sync-drive-Dateien?

Versuchen Sie dies:

**
 * An AsyncTask that maintains a connected client.
 */
public abstract class ApiClientAsyncTask<Params, Progress, Result>
        extends AsyncTask<Params, Progress, Result> {

    private GoogleApiClient mClient;

    public ApiClientAsyncTask(Context context) {
        GoogleApiClient.Builder builder = new GoogleApiClient.Builder(context)
                .addApi(Drive.API)
                .addScope(Drive.SCOPE_FILE);
        mClient = builder.build();
    }

    @Override
    protected final Result doInBackground(Params... params) {
        Log.d("TAG", "in background");
        final CountDownLatch latch = new CountDownLatch(1);
        mClient.registerConnectionCallbacks(new ConnectionCallbacks() {
            @Override
            public void onConnectionSuspended(int cause) {
            }

            @Override
            public void onConnected(Bundle arg0) {
                latch.countDown();
            }
        });
        mClient.registerConnectionFailedListener(new OnConnectionFailedListener() {
            @Override
            public void onConnectionFailed(ConnectionResult arg0) {
                latch.countDown();
            }
        });
        mClient.connect();
        try {
            latch.await();
        } catch (InterruptedException e) {
            return null;
        }
        if (!mClient.isConnected()) {
            return null;
        }
        try {
            return doInBackgroundConnected(params);
        } finally {
            mClient.disconnect();
        }
    }

    /**
     * Override this method to perform a computation on a background thread, while the client is
     * connected.
     */
    protected abstract Result doInBackgroundConnected(Params... params);

    /**
     * Gets the GoogleApliClient owned by this async task.
     */
    protected GoogleApiClient getGoogleApiClient() {
        return mClient;
    }
    }

Klasse zum speichern der Datei:

 /**
     * An async task that creates a new text file by creating new contents and
     * metadata entities on user's root folder. A number of blocking tasks are
     * performed serially in a thread. Each time, await() is called on the
     * result which blocks until the request has been completed.
     */
public class CreateFileAsyncTask extends ApiClientAsyncTask<String, Void, Metadata>
{

    public CreateFileAsyncTask(Context context)
    {
        super(context);
    }

    @Override
    protected Metadata doInBackgroundConnected(String... arg0)
    {
        //First we start by creating a new contents, and blocking on the
        //result by calling await().
        DriveApi.ContentsResult contentsResult = Drive.DriveApi.newContents(getGoogleApiClient()).await();

        if (!contentsResult.getStatus().isSuccess()) {
            //We failed, stop the task and return.
            return null;
        }

        //file to save in drive
        String pathFile = arg0[0];
        File file = new File(pathFile);

        //Read the contents and open its output stream for writing, then
        //write a short message.
        Contents originalContents = contentsResult.getContents();
        OutputStream os = originalContents.getOutputStream();

        try
        {
            InputStream dbInputStream = new FileInputStream(file);

            byte[] buffer = new byte[1024];
            int length;
            int counter = 0;
            while((length = dbInputStream.read(buffer)) > 0)
            {
                ++counter;
                os.write(buffer, 0, length);
            }

            dbInputStream.close();
            os.flush();
            os.close();

        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }

        //Create the metadata for the new file including title and MIME
        //type.
        MetadataChangeSet originalMetadata = new MetadataChangeSet.Builder()
        .setTitle(file.getName())
        .setMimeType("application/x-sqlite3").build();

        //Create the file in the root folder, again calling await() to
        //block until the request finishes.
        DriveFolder rootFolder = Drive.DriveApi.getRootFolder(getGoogleApiClient());
        DriveFolder.DriveFileResult fileResult = rootFolder.createFile(
        getGoogleApiClient(), originalMetadata, originalContents).await();

        if (!fileResult.getStatus().isSuccess()) {
            //We failed, stop the task and return.
            return null;
        }

        //Finally, fetch the metadata for the newly created file, again
        //calling await to block until the request finishes.
        DriveResource.MetadataResult metadataResult = fileResult.getDriveFile()
        .getMetadata(getGoogleApiClient())
        .await();

        if (!metadataResult.getStatus().isSuccess()) {
            //We failed, stop the task and return.
            return null;
        }
        //We succeeded, return the newly created metadata.
        return metadataResult.getMetadata();
    }

    @Override
    protected void onPostExecute(Metadata result)
    {
        super.onPostExecute(result);

        if (result == null)
        {
            //The creation failed somehow, so show a message.
            App.showAppMsg(getActivity(),"Error while creating the file.",Style.ALERT);
            return;
        }
        //The creation succeeded, show a message.
        App.showAppMsg(getActivity(),"File created: " + result.getDriveId(),Style.CONFIRM);
    }
}

In Ihrem onConnected Methode erstellen Sie die neue Datei, aber Sie können niemals, stellen Sie keine neuen Inhalte drin. Erstellen Sie die neuen Inhalte in dieser Zeile:

result = Drive.DriveApi.newContents(mGoogleApiClient).await();

Als Sie in den Griff bekommen die stream-Ausgabe in dieser Zeile:

OutputStream outputStream = result.getContents().getOutputStream();

Und als Sie erstellen Sie eine leere byte array output-stream in dieser Zeile:

ByteArrayOutputStream bitmapStream = new ByteArrayOutputStream();

Aber Sie nie füllen Sie dieses 'bitmapStream' mit beliebigem Inhalt, und das Schlimmste: man kann nie schreiben Sie es, um Ihre Inhalte s 'Ausgabestrom'.

Was Sie als Nächstes tun sollten, ist schreiben Sie Ihre audio-Datei Inhalt zu "bitmapStream' so etwas wie dieses:

InputStream in = file.getInputStream(/*you need to get the file's path and put it here*/ "some_audio_file.mp3");
int singleByte;
while((singleByte = in.read()) != -1){
   bitmapStream.write(b);
}

Jetzt müsstest du deine Datei-Inhalt in 'bitmapStrea' und Sie können schreiben Sie es auf den neuen content 's" Ausgabestrom " wie diese:

outputStream.write(bitmapStream.toByteArray());

Als du-das 'MetadataChangeSet" Zeug, und Sie sollten in Ordnung sein.

Einige Hinweise:
1. Es ist nicht eine gute Praxis zu tun-I/O-Operationen, wie Datei-oder Netzwerk-Aktivitäten (oder Datei-UND Netzwerk-Aktivitäten in deinem Fall) auf dem Haupt-thread. Besser verwenden Sie einen AsyncTask, es zu tun in einem hintergrund-thread.

1. Nicht, rufen Sie Ihren ByteArrayOutputStream Instanz 'bitmapStream' wenn Sie es hochladen einer audio-Datei.

Hier ist ein Beispiel einer Klasse, verwendet einen AsyncTask, um ein Bild hochzuladen (und ratet mal, was ich genannt ByteArrayOutputStream... richtig - 'bitmapStream'):

public class TakePhotoActivity extends Activity implements
        GoogleApiClient.ConnectionCallbacks,
        GoogleApiClient.OnConnectionFailedListener {

    /**
     * Request code for auto Google Play Services error resolution.
     */
    protected static final int REQUEST_CODE_RESOLUTION = 1;
    private static final String TAG = "TakePhotoActivity";
    private static final String KEY_IN_RESOLUTION = "is_in_resolution";
    private static final int REQUEST_CODE_CREATOR = 2;

    /**
     * Google API client.
     */
    private GoogleApiClient mGoogleApiClient;

    /**
     * Receives the new file's contents and executes the editor AsyncTask
     */
    private ResultCallback<DriveApi.ContentsResult> mSaveFileCallback = new ResultCallback<DriveApi.ContentsResult>() {
        @Override
        public void onResult(DriveApi.ContentsResult contentsResult) {
            EditFileAsyncTask editFileAsyncTask = new EditFileAsyncTask();
            editFileAsyncTask.execute(contentsResult);
        }
    };

    /**
     * Determines if the client is in a resolution state, and
     * waiting for resolution intent to return.
     */
    private boolean mIsInResolution;

    private Bitmap mBitmapToSave;

    /**
     * Called when the activity is starting. Restores the activity state.
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_take_menu_photo);

        if (savedInstanceState != null) {
            mIsInResolution = savedInstanceState.getBoolean(KEY_IN_RESOLUTION, false);
        }

        try {
            InputStream inputStream = getAssets().open("some_image.jpg");
            mBitmapToSave = BitmapFactory.decodeStream(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Called when the Activity is made visible.
     * A connection to Play Services need to be initiated as
     * soon as the activity is visible. Registers {@code ConnectionCallbacks}
     * and {@code OnConnectionFailedListener} on the
     * activities itself.
     */
    @Override
    protected void onStart() {
        super.onStart();
        if (mGoogleApiClient == null) {
            mGoogleApiClient = new GoogleApiClient.Builder(this)
                    .addApi(Drive.API)
                    .addScope(Drive.SCOPE_FILE)
                            //Optionally, add additional APIs and scopes if required.
                    .addConnectionCallbacks(this)
                    .addOnConnectionFailedListener(this)
                    .build();
        }
        Log.d("test", "connect()");
        mGoogleApiClient.connect();
    }

    /**
     * Called when activity gets invisible. Connection to Play Services needs to
     * be disconnected as soon as an activity is invisible.
     */
    @Override
    protected void onStop() {
        if (mGoogleApiClient != null) {
            mGoogleApiClient.disconnect();
        }
        super.onStop();
    }

    /**
     * Saves the resolution state.
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putBoolean(KEY_IN_RESOLUTION, mIsInResolution);
    }

    /**
     * Handles Google Play Services resolution callbacks.
     */
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case REQUEST_CODE_RESOLUTION:
                retryConnecting();
                break;
        }
    }

    private void retryConnecting() {
        mIsInResolution = false;
        if (!mGoogleApiClient.isConnecting()) {
            Log.d("test", "connect()");
            mGoogleApiClient.connect();
        }
    }

    /**
     * Called when {@code mGoogleApiClient} is connected.
     */
    @Override
    public void onConnected(Bundle connectionHint) {
        Log.i(TAG, "GoogleApiClient connected");
        //TODO: Start making API requests.
        if (mBitmapToSave != null) {
            saveFileToDrive();
        }
    }

    /**
     * Called when {@code mGoogleApiClient} connection is suspended.
     */
    @Override
    public void onConnectionSuspended(int cause) {
        Log.i(TAG, "GoogleApiClient connection suspended");
        retryConnecting();
    }

    /**
     * Called when {@code mGoogleApiClient} is trying to connect but failed.
     * Handle {@code result.getResolution()} if there is a resolution
     * available.
     */
    @Override
    public void onConnectionFailed(ConnectionResult result) {
        Log.i(TAG, "GoogleApiClient connection failed: " + result.toString());
        if (!result.hasResolution()) {
            //Show a localized error dialog.
            GooglePlayServicesUtil.getErrorDialog(
                    result.getErrorCode(), this, 0, new OnCancelListener() {
                        @Override
                        public void onCancel(DialogInterface dialog) {
                            retryConnecting();
                        }
                    }
            ).show();
            return;
        }
        //If there is an existing resolution error being displayed or a resolution
        //activity has started before, do nothing and wait for resolution
        //progress to be completed.
        if (mIsInResolution) {
            return;
        }
        mIsInResolution = true;
        try {
            result.startResolutionForResult(this, REQUEST_CODE_RESOLUTION);
        } catch (SendIntentException e) {
            Log.e(TAG, "Exception while starting resolution activity", e);
            retryConnecting();
        }
    }

    private void saveFileToDrive() {
        Log.i(TAG, "Creating new contents.");
        Drive.DriveApi.newContents(mGoogleApiClient).setResultCallback(mSaveFileCallback);
    }

    private void showMessage(String message) {
        Log.i(TAG, message);
//       Toast.makeText(this, message, Toast.LENGTH_LONG).show();
    }

    private class EditFileAsyncTask extends AsyncTask<DriveApi.ContentsResult, Void, Boolean> {

        @Override
        protected Boolean doInBackground(DriveApi.ContentsResult... params) {
            DriveApi.ContentsResult contentsResult = params[0];
            if (!contentsResult.getStatus().isSuccess()) {
                showMessage("Failed to create new contents.");
                return false;
            }
            showMessage("New contents created.");
            OutputStream outputStream = contentsResult.getContents().getOutputStream();
            ByteArrayOutputStream bitmapStream = new ByteArrayOutputStream();
            mBitmapToSave.compress(Bitmap.CompressFormat.PNG, 100, bitmapStream);
            try {
                outputStream.write(bitmapStream.toByteArray());
            } catch (IOException e) {
                showMessage("Unable to write file contents.");
                e.printStackTrace();
            }

            MetadataChangeSet metadataChangeSet = new MetadataChangeSet.Builder()
                    .setMimeType("image/jpeg")
                    .setTitle("some_image.jpg")
                    .build();

            IntentSender intentSender = Drive.DriveApi
                    .newCreateFileActivityBuilder()
                    .setInitialMetadata(metadataChangeSet)
                    .setInitialContents(contentsResult.getContents())
                    .build(mGoogleApiClient);

            try {
                startIntentSenderForResult(intentSender, REQUEST_CODE_CREATOR, null, 0, 0, 0);
            } catch (SendIntentException e) {
                showMessage("Failed to launch file chooser.");
                e.printStackTrace();
            }
            return true;
        }

        @Override
        protected void onPostExecute(Boolean result) {
            if (!result) {
                showMessage("Error while editing contents");
                return;
            }
            showMessage("Successfully edited contents");
        }
    }
}

• By the way, der meiste code in dieser Klasse wurde automatisch generiert von Android Studio, denn wenn ich das Projekt erstellt habe ich die erste Klasse zu sein, eine google-Dienste Klasse.