如何同时上传多个文件到谷歌驱动器上的不同文件夹 [英] How to upload multi files to different folders on google drive at the same time

查看：145
本文介绍了如何同时上传多个文件到谷歌驱动器上的不同文件夹的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

首先，这是我第一次在SO上发表一个问题，所以如果我犯了错误，你可以随时给我建议。我的问题是帖子的标题，我成功上传多个文件到谷歌驱动器，但我不能上传到驱动器上的不同子文件夹。在此先感谢

这里是我的代码：

上传类来处理上传函数：



'pre> 公共类UploadFileActivity / *实现
GoogleApiClient.ConnectionCallbacks，
GoogleApiClient.OnConnectionFailedListener * / {
私有静态最后String TAG =upload_file;
private static final int REQUEST_CODE = 101;
public File textFile;
public GoogleApiClient googleApiClient;
public static String drive_id;
public static DriveId driveID;
public Context mContext;
public String folder_id;
public String foler_backup_id;
public String foler_backup_name;
SharedPreferences sharedPreferences;

$ b public void testDrive（）{

Drive.DriveApi.fetchDriveId（googleApiClient，folder_id）.setResultCallback（idCallback）;
}

final private ResultCallback< DriveApi.DriveIdResult> idCallback = new
ResultCallback< DriveApi.DriveIdResult>（）{
@Override
public void onResult（DriveApi.DriveIdResult driveIdResult）{
if（！driveIdResult.getStatus（） （））{
Toast.makeText（mContext，Can not find DriveId。You have authorized to view this file？，Toast.LENGTH_LONG）.show（）;
return;
}
Log.d（check_up，1）;
driveID = driveIdResult.getDriveId（）;


最终DriveFolder文件夹= driveID.asDriveFolder（）;
folder.listChildren（googleApiClient）.setResultCallback（metadataResult）;
$ b / * Drive.DriveApi.newDriveContents（googleApiClient）

.setResultCallback（driveContentsCallback）; * /
}
};

/ *获取驱动器内容的回调，包含在结果中* /
final private ResultCallback< DriveContentsResult> driveContentsCallback =新
ResultCallback< DriveContentsResult>（）{
@覆盖
公共无效onResult（DriveContentsResult结果）{
如果{（result.getStatus（）isSuccess（）！）。
Log.i（标签，创建新文件内容时出错）;
return;
}
final DriveFolder folder = driveID.asDriveFolder（）;

Log.d（check_folder，folder.toString（））;
final DriveContents driveContents = result.getDriveContents（）;
new Thread（）{
@Override
public void run（）{
OutputStream outputStream = driveContents.getOutputStream（）;
addTextfileToOutputStream（outputStream）;
MetadataChangeSet changeSet = new MetadataChangeSet.Builder（）
.setTitle（textFile.getName（））
.setMimeType（text / plain）
.setDescription（This is a从设备上传的文本文件）
.setStarred（true）.build（）;
$ b $ //根文件夹
/*Drive.DriveApi.getRootFolder（googleApiClient）
.createFile（googleApiClient，changeSet，driveContents）
.setResultCallback（fileCallback）; * /

//文件夹中的文件
folder.createFile（googleApiClient，changeSet，driveContents）
.setResultCallback（fileCallback）;

//文件在app文件夹
/*Drive.DriveApi.getAppFolder(googleApiClient）
.createFile（googleApiClient，变更，driveContents）
.setResultCallback（fileCallback） ; * /
}

} .start（）;
}
};
$ b $ *从文本文件中获取输入流，读取并放入输出流* /
private void addTextfileToOutputStream（OutputStream outputStream）{
Log.i（TAG，添加文本文件到outputstream ...）;
byte [] buffer = new byte [1024];
int bytesRead;
try {
BufferedInputStream inputStream = new BufferedInputStream（
FileInputStream（textFile））; （（bytesRead = inputStream.read（buffer））！= -1）{
outputStream.write（buffer，0，bytesRead）;

} catch（IOException e）{
Log.i（TAG，将输入流转换为输出流的问题：+ e）;
e.printStackTrace（）;


$ b / *创建文件后回调，可以从结果中获取文件信息* /
final private ResultCallback< DriveFileResult> fileCallback =新
ResultCallback< DriveFileResult>（）{
@覆盖
公共无效onResult（DriveFileResult结果）{
如果{（result.getStatus（）isSuccess（）！）。
Log.i（TAG，创建文件时出错）;
Toast.makeText（mContext，
将文件添加到驱动器时​​出错，Toast.LENGTH_SHORT）.show（）;
return;


Log.i（TAG，File added to Drive）;
Log.i（TAG，创建一个包含内容的文件：
+ result.getDriveFile（）。getDriveId（））;
/*Toast.makeText(mContext，
成功添加到Drive的文件，Toast.LENGTH_SHORT）.show（）; * /
listener.onReceive（）;
final PendingResult< DriveResource.MetadataResult>元数据
= result.getDriveFile（）。getMetadata（googleApiClient）;
metadata.setResultCallback（新
ResultCallback< DriveResource.MetadataResult>（）{
@覆盖
公共无效onResult（DriveResource.MetadataResult metadataResult）{

元数据data = metadataResult.getMetadata（）;
Log.i（TAG，Title：+ data.getTitle（））;
drive_id = data.getDriveId（）。encodeToString（）;
Log.i（TAG，DrivId：+ drive_id）;
driveID = data.getDriveId（）;
Log.i（TAG，Description：+ data.getDescription（）。的toString（））;
Log.i（TAG，MimeType：+ data.getMimeType（））;
Log.i（TAG，File size：+ String.valueOf（data.getFileSize（）））;
}
}）;
}
};

final private ResultCallback< DriveApi.MetadataBufferResult> metadataResult = new
ResultCallback< DriveApi.MetadataBufferResult>（）{
@Override $ b $ public void onResult（DriveApi.MetadataBufferResult result）{
if（！result.getStatus（）。isSuccess （））{
// showMessage（检索文件时出现问题）;
Log.d（check_title，检索文件时出现问题）;
return;
}
Log.d（check_folder_backup，foler_backup_name）;
for（int i = 0; i< result.getMetadataBuffer（）。getCount（）; i ++）{
Metadata metadata = result.getMetadataBuffer（）。get（i）;如果（metadata.isFolder（））{
if（metadata.getTitle（）。equals（foler_backup_name））{
foler_backup_id = metadata.getDriveId（）。getResourceId（）;
break;

$ b Log.d（check_title，metadata.getTitle（）++ metadata.isFolder（））;
}
//Log.d(\"check_folder_backup_id\",foler_backup_id）;
if（foler_backup_id == null）{
Drive.DriveApi.fetchDriveId（googleApiClient，folder_id）.setResultCallback（preCreateFolder）;
} else {
Drive.DriveApi.fetchDriveId（googleApiClient，foler_backup_id）.setResultCallback（preCreateFile）;
}

}
};

final private ResultCallback< DriveApi.DriveIdResult> preCreateFile = new
ResultCallback< DriveApi.DriveIdResult>（）{
@Override
public void onResult（DriveApi.DriveIdResult driveIdResult）{
if（！driveIdResult.getStatus（）。isSuccess （））{
Toast.makeText（mContext，Can not find DriveId。You have authorized to view this file？，Toast.LENGTH_LONG）.show（）;
return;
}
Log.d（check_up，10）;
driveID = driveIdResult.getDriveId（）;

Log.d（check_drive_id，driveID.toString（））;

//folder.listChildren（googleApiClient）.setResultCallback (metadataResult）;

Drive.DriveApi.newDriveContents（googleApiClient）

.setResultCallback（driveContentsCallback）;
}
};
$ b $ final ResultCallback< DriveApi.DriveIdResult> preCreateFolder = new ResultCallback< DriveApi.DriveIdResult>（）{
@Override
public void onResult（DriveApi.DriveIdResult driveIdResult）{
）if（！driveIdResult.getStatus（）。isSuccess（））{
Log.d（Check_error，Can not find DriveId。You have authorized to view this file？）;
return;
}
Log.d（Check_error，4）;
DriveId driveId = driveIdResult.getDriveId（）;
DriveFolder folder = driveId.asDriveFolder（）;
MetadataChangeSet changeSet = new MetadataChangeSet.Builder（）
.setTitle（foler_backup_name）.build（）;
folder.createFolder（googleApiClient，changeSet）
.setResultCallback（createFolderCallBack）;
}
};

final ResultCallback< DriveFolder.DriveFolderResult> createFolderCallBack = new ResultCallback< DriveFolder.DriveFolderResult>（）{
@Override
public void onResult（DriveFolder.DriveFolderResult driveFolderResult）{
if（！driveFolderResult.getStatus（）。isSuccess（））{
return;
}
Log.d（thong_bao，文件夹成功创建）;
Drive.DriveApi.fetchDriveId（googleApiClient，foler_backup_id）.setResultCallback（preCreateFile）;
}
};


public interface OnCatch {
public void onReceive（）;
}

私有OnCatch侦听器;
$ b $ public void setCatch（OnCatch listener）{
this.listener = listener;

$ / code>

}

解决方案

您正在创建基于1个驱动器的文件。您希望从不同的子文件夹创建/上传文件，每个子文件夹需要不同的driveId对象。



另一个可能的解决方案是使用Drive REST API，请在创建/上传文件到不同的子文件夹时调用批量请求（通过asynctask）。

firstly, it's my first time i post a question on SO so you can feel free to give me advices if i make something wrong. My question is post's title, i am success to upload multi file to google drive but i can not upload them into different sub folders on drive. Thanks in advance

Here is my code:

Upload class to handle upload function:

public class UploadFileActivity  /*implements
    GoogleApiClient.ConnectionCallbacks,
    GoogleApiClient.OnConnectionFailedListener*/ {
private static final String TAG = "upload_file";
private static final int REQUEST_CODE = 101;
public File textFile;
public GoogleApiClient googleApiClient;
public static String drive_id;
public static DriveId driveID;
public Context mContext;
public String folder_id;
public  String foler_backup_id;
public String foler_backup_name;
SharedPreferences sharedPreferences;


public void testDrive(){

    Drive.DriveApi.fetchDriveId(googleApiClient,folder_id).setResultCallback(idCallback);
}

final private ResultCallback<DriveApi.DriveIdResult> idCallback = new
        ResultCallback<DriveApi.DriveIdResult>() {
            @Override
            public void onResult(DriveApi.DriveIdResult driveIdResult) {
                if(!driveIdResult.getStatus().isSuccess()){
                    Toast.makeText(mContext,"Cannot find DriveId. Are you authorized to view this file?",Toast.LENGTH_LONG).show();
                    return;
                }
                Log.d("check_up", "1");
                driveID = driveIdResult.getDriveId();


                final DriveFolder folder = driveID.asDriveFolder();
                folder.listChildren(googleApiClient).setResultCallback(metadataResult);

               /* Drive.DriveApi.newDriveContents(googleApiClient)

                        .setResultCallback(driveContentsCallback);*/
            }
        };

/*callback on getting the drive contents, contained in result*/
final private ResultCallback<DriveContentsResult> driveContentsCallback = new
        ResultCallback<DriveContentsResult>() {
            @Override
            public void onResult(DriveContentsResult result) {
                if (!result.getStatus().isSuccess()) {
                    Log.i(TAG, "Error creating new file contents");
                    return;
                }
                final DriveFolder folder = driveID.asDriveFolder();

                Log.d("check_folder",folder.toString());
                final DriveContents driveContents = result.getDriveContents();
                new Thread() {
                    @Override
                    public void run() {
                        OutputStream outputStream = driveContents.getOutputStream();
                        addTextfileToOutputStream(outputStream);
                        MetadataChangeSet changeSet = new MetadataChangeSet.Builder()
                                .setTitle(textFile.getName())
                                .setMimeType("text/plain")
                                .setDescription("This is a text file uploaded from device")
                                .setStarred(true).build();

                        //root folder
                        /*Drive.DriveApi.getRootFolder(googleApiClient)
                                .createFile(googleApiClient, changeSet, driveContents)
                                .setResultCallback(fileCallback);*/

                        //file in folder
                        folder.createFile(googleApiClient, changeSet, driveContents)
                                .setResultCallback(fileCallback);

                        //file in app folder
                        /*Drive.DriveApi.getAppFolder(googleApiClient)
                                .createFile(googleApiClient, changeSet, driveContents)
                                .setResultCallback(fileCallback);*/
                    }

                }.start();
            }
        };

/*get input stream from text file, read it and put into the output stream*/
private void addTextfileToOutputStream(OutputStream outputStream) {
    Log.i(TAG, "adding text file to outputstream...");
    byte[] buffer = new byte[1024];
    int bytesRead;
    try {
        BufferedInputStream inputStream = new BufferedInputStream(
                new FileInputStream(textFile));
        while ((bytesRead = inputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, bytesRead);
        }
    } catch (IOException e) {
        Log.i(TAG, "problem converting input stream to output stream: " + e);
        e.printStackTrace();
    }
}

/*callback after creating the file, can get file info out of the result*/
final private ResultCallback<DriveFileResult> fileCallback = new
        ResultCallback<DriveFileResult>() {
            @Override
            public void onResult(DriveFileResult result) {
                if (!result.getStatus().isSuccess()) {
                    Log.i(TAG, "Error creating the file");
                    Toast.makeText(mContext,
                            "Error adding file to Drive", Toast.LENGTH_SHORT).show();
                    return;
                }

                Log.i(TAG, "File added to Drive");
                Log.i(TAG, "Created a file with content: "
                        + result.getDriveFile().getDriveId());
                /*Toast.makeText(mContext,
                        "Files successfully added to Drive", Toast.LENGTH_SHORT).show();*/
                listener.onReceive();
                final PendingResult<DriveResource.MetadataResult> metadata
                        = result.getDriveFile().getMetadata(googleApiClient);
                metadata.setResultCallback(new
                                                   ResultCallback<DriveResource.MetadataResult>() {
                                                       @Override
                                                       public void onResult(DriveResource.MetadataResult metadataResult) {

                                                           Metadata data = metadataResult.getMetadata();
                                                           Log.i(TAG, "Title: " + data.getTitle());
                                                           drive_id = data.getDriveId().encodeToString();
                                                           Log.i(TAG, "DrivId: " + drive_id);
                                                           driveID = data.getDriveId();
                                                           Log.i(TAG, "Description: " + data.getDescription().toString());
                                                           Log.i(TAG, "MimeType: " + data.getMimeType());
                                                           Log.i(TAG, "File size: " + String.valueOf(data.getFileSize()));
                                                       }
                                                   });
            }
        };

final private ResultCallback<DriveApi.MetadataBufferResult> metadataResult = new
        ResultCallback<DriveApi.MetadataBufferResult>() {
            @Override
            public void onResult(DriveApi.MetadataBufferResult result) {
                if (!result.getStatus().isSuccess()) {
                    //showMessage("Problem while retrieving files");
                    Log.d("check_title", "Problem while retrieving files");
                    return;
                }
                Log.d("check_folder_backup",foler_backup_name);
                for(int i = 0;i<result.getMetadataBuffer().getCount();i++){
                    Metadata metadata = result.getMetadataBuffer().get(i);
                    if(metadata.isFolder()){
                        if(metadata.getTitle().equals(foler_backup_name)){
                            foler_backup_id = metadata.getDriveId().getResourceId();
                            break;
                        }
                    }
                    Log.d("check_title",metadata.getTitle() + " " + metadata.isFolder());
                }
                //Log.d("check_folder_backup_id",foler_backup_id);
                if(foler_backup_id==null){
                    Drive.DriveApi.fetchDriveId(googleApiClient,folder_id).setResultCallback(preCreateFolder);
                }else {
                    Drive.DriveApi.fetchDriveId(googleApiClient,foler_backup_id).setResultCallback(preCreateFile);
                }

            }
        };

final private ResultCallback<DriveApi.DriveIdResult> preCreateFile = new
        ResultCallback<DriveApi.DriveIdResult>() {
            @Override
            public void onResult(DriveApi.DriveIdResult driveIdResult) {
                if(!driveIdResult.getStatus().isSuccess()){
                    Toast.makeText(mContext,"Cannot find DriveId. Are you authorized to view this file?",Toast.LENGTH_LONG).show();
                    return;
                }
                Log.d("check_up", "10");
                 driveID = driveIdResult.getDriveId();

                Log.d("check_drive_id",driveID.toString());

                //folder.listChildren(googleApiClient).setResultCallback(metadataResult);

                Drive.DriveApi.newDriveContents(googleApiClient)

                        .setResultCallback(driveContentsCallback);
            }
        };

final ResultCallback<DriveApi.DriveIdResult>preCreateFolder = new ResultCallback<DriveApi.DriveIdResult>() {
    @Override
    public void onResult(DriveApi.DriveIdResult driveIdResult) {
        if(!driveIdResult.getStatus().isSuccess()){
            Log.d("Check_error","Cannot find DriveId. Are you authorized to view this file?");
            return;
        }
        Log.d("Check_error","4");
        DriveId driveId = driveIdResult.getDriveId();
        DriveFolder folder = driveId.asDriveFolder();
        MetadataChangeSet changeSet = new MetadataChangeSet.Builder()
                .setTitle(foler_backup_name).build();
        folder.createFolder(googleApiClient,changeSet)
                .setResultCallback(createFolderCallBack);
    }
};

final ResultCallback<DriveFolder.DriveFolderResult> createFolderCallBack = new ResultCallback<DriveFolder.DriveFolderResult>() {
    @Override
    public void onResult(DriveFolder.DriveFolderResult driveFolderResult) {
        if(!driveFolderResult.getStatus().isSuccess()){
            return;
        }
        Log.d("thong_bao","Folder successfully created");
        Drive.DriveApi.fetchDriveId(googleApiClient,foler_backup_id).setResultCallback(preCreateFile);
    }
};


public interface OnCatch{
    public void onReceive();
}

private OnCatch listener;

public void setCatch(OnCatch listener){
    this.listener = listener;
}

}

解决方案

You're creating files based on 1 driveId. You want to create/upload files from different subfolders, you need to have different driveId objects per subfolder.

Another possible solution would be for you to use the Drive REST APIs and call Batch Requests (thru asynctask) when creating/uploading files in to different subfolders.

这篇关于如何同时上传多个文件到谷歌驱动器上的不同文件夹的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！

查看全文
相关文章
移动开发最新文章
热门教程
热门工具
登录 关闭
扫码关注1秒登录
发送“验证码”获取 | 15天全站免登陆