Android 驱动Api保存到文件夹，如果文件夹不存在，则创建而不是保存

我使用GoogleDriveAPI在那里保存（用作备份）一个数据库，它工作得很好，但是如果我使用根目录的话

Api调用：

  MetadataChangeSet metadataChangeSet = new MetadataChangeSet.Builder()
                           ......build();


Drive.DriveApi.getRootFolder(mGoogleApiClient)
                        .createFile(mGoogleApiClient, metadataChangeSet, result.getDriveContents())
                        .setResultCallback(fileCallback);

回调以保存文件：

final public ResultCallback < DriveFolder.DriveFileResult > fileCallback = new
            ResultCallback < DriveFolder.DriveFileResult > () {
                @Override
                public void onResult(DriveFolder.DriveFileResult result) {

                    if (!result.getStatus().isSuccess()) {


                        return;
                    }

                    Log.i(TAG, "Successfull !");
                }
            };

final public ResultCallbackfileCallback=new
结果回调（）{
@凌驾
public void onResult（DriveFolder.DriveFileResult）{
如果（！result.getStatus（）.issucess（））{
返回；
}
Log.i（标记“Successfull！”）；
}
};

我知道我必须获取文件夹，但如果我这样做，我需要进行回调以调用另一个回调，然后保存

---

在文件夹中没有直接执行.createNewFile的方法吗？不必再查询文件夹，检查文件夹是否存在，然后创建文件夹、使用DriveID、创建文件？

记住，在GooDrive世界中，树结构（文件夹、子文件夹等）是一种幻影。驱动器是一个对象（文件、文件夹）的平面系统，其中一个元数据字段是“父ID集”，它实际上形成了parentobject-childobject结构的概念。实际上，经典树（一个父对象多个子对象）甚至没有强制执行，因此子对象可以“出现”在多个父对象中。
这一事实说明，不能一次创建操作系统类型的路径。必须先创建对象（父对象），然后才能将其ID插入子对象的元数据

所以，唯一的办法就是照你说的去做：

    if folder exists
      return it's ID
    else
      return ID of newly created one

   create a child object with parent's ID

。。。下面是我如何创建类型为的结构的示例：

   / MYROOT / 2015 / 2015-12

（其中MYROOT、2015、2015-12是驱动根目录的子目录）

new线程（new Runnable（））{
@凌驾
公开募捐{
DriveId Id=getFolder（getFolder）（getFolder(
Drive.DriveApi.getRootFolder（mGAC.getDriveId（），“MYROOT”），
"2015",
"2015-12"
);
}
}).start（）；
GoogleapClient mGAC；
DriveId getFolder（DriveId parentId，字符串标题）{
DriveId dId=null；
如果（parentId！=null&&titl！=null）尝试{
ArrayList fltrs=新的ArrayList（）；
fltrs.add（Filters.in（SearchableField.PARENTS，parentId））；
外文添加（Filters.eq（SearchableField.TITLE，titl））；
fltrs.add（Filters.eq（SearchableField.MIME_TYPE，“application/vnd.googleapps.folder”）；
Query qry=new Query.Builder（）.addFilter（Filters.and（fltrs））.build（）；
MetadataBuffer mdb=null；
DriveApi.MetadataBufferResult rslt=Drive.DriveApi.query（mGAC，qry.await（）；
如果（rslt.getStatus（）.issucess（））尝试{
mdb=rslt.getMetadataBuffer（）；
如果（mdb.getCount（）>0）
dId=mdb.get（0.getDriveId（）；
}捕获（异常忽略）{}
最后{if（mdb！=null）mdb.close（）；}
if（dId==null）{
MetadataChangeSet meta=new Builder（）.setTitle（titl）.setMimeType（UT.MIME_FLDR）.build（）；
DriveFolderResult r1=parentId.asDriveFolder（）.createFolder（mGAC，meta）.await（）；
DriveFolder dFld=（r1！=null）和&r1.getStatus（）.issucess（）？r1.getDriveFolder（）：null；
如果（dFld！=null）{
MetadataResult r2=dFld.getMetadata（mGAC.await（）；
if（（r2！=null）&&r2.getStatus（）.issucess（））{
dId=r2.getMetadata（）.getDriveId（）；
}
}
}
}catch（异常e）{e.printStackTrace（）；}
返回没有；
}

在“mdb.get（0）.getDriveId（）”区域中，您可以看到，当您尝试在驱动器上强制使用经典树结构时，它会变得多么粗糙。此处的搜索可能会返回多个同名对象，因此我使用第一个对象。此处应该有某种错误报告

正如您所看到的，可以用“await（）”方法替换回调，只要将整个序列从UI线程（asynctask，thread，…）中移出，就可以将代码扁平化为经典的DOS风格的意大利面代码

不过，实现这一点的更优雅（IMO）的选项是使用结果回调的递归调用

  fromPath(Drive.DriveApi.getRootFolder(mGAC).getDriveId(), "MYROOT/2015/2015-12/file.jpg");
  ....
  void fromPath(final DriveId parentId, final String path) {
    if (parentId != null && path != null) {

      final int idx = path.indexOf('/');
      if (idx < 0) {
        // reached last path item - probably file name
        // CREATE FILE WITH patentID AND QUIT
        return;    //--- DONE -------------------->>>
      }

      final String titl = path.substring(0, idx);

      ArrayList<Filter> fltrs = new ArrayList<>();
      fltrs.add(Filters.in(SearchableField.PARENTS, parentId));
      fltrs.add(Filters.eq(SearchableField.TITLE, titl));
      fltrs.add(Filters.eq(SearchableField.MIME_TYPE, UT.MIME_FLDR));
      Query qry = new Query.Builder().addFilter(Filters.and(fltrs)).build();

      Drive.DriveApi.query(mGAC, qry).setResultCallback(new ResultCallback<DriveApi.MetadataBufferResult>() {
        @Override
        public void onResult(DriveApi.MetadataBufferResult rslt) {
          MetadataBuffer mdb = null;
          if (rslt != null && rslt.getStatus().isSuccess()) {
            try {
              mdb = rslt.getMetadataBuffer();
              for (Metadata md : mdb) {
                if (md.isTrashed()) continue;
                fromPath(md.getDriveId(), path.substring(idx + 1));
                return; //+++ first found, NEXT +++++++>>>
              }
            } finally { if (mdb != null) mdb.close(); }
          }

          MetadataChangeSet meta = new Builder().setTitle(titl).setMimeType(UT.MIME_FLDR).build();
          parentId.asDriveFolder().createFolder(mGAC, meta)
          .setResultCallback(new ResultCallback<DriveFolderResult>() {
            @Override
            public void onResult(DriveFolderResult rslt) {
              DriveFolder dFld = rslt != null && rslt.getStatus().isSuccess() ? rslt.getDriveFolder() : null;
              if (dFld != null) {
                dFld.getMetadata(mGAC).setResultCallback(new ResultCallback<MetadataResult>() {
                  @Override
                  public void onResult(MetadataResult rslt) {
                    if (rslt != null && rslt.getStatus().isSuccess()) {
                      fromPath(rslt.getMetadata().getDriveId(), path.substring(idx + 1));
                      return; //+++ created, NEXT +++++++>>>
                    }
                  }
                });
              }
            }
          });
        }
      });
    }
  }

fromPath（Drive.DriveApi.getRootFolder（mGAC.getDriveId（），“MYROOT/2015/2015-12/file.jpg”）；
....
void fromPath（最终驱动器ID parentId，最终字符串路径）{
if（parentId！=null&&path！=null）{
final int idx=path.indexOf（'/'）；
if（idx<0）{
//到达最后一个路径项-可能是文件名
//使用patentID创建文件并退出
返回；//--完成-------------------------------->>
}
最终字符串titl=path.substring（0，idx）；
ArrayList fltrs=新的ArrayList（）；
fltrs.add（Filters.in（SearchableField.PARENTS，parentId））；
外文添加（Filters.eq（SearchableField.TITLE，titl））；
添加（Filters.eq（SearchableField.MIME_TYPE，UT.MIME_FLDR））；
Query qry=new Query.Builder（）.addFilter（Filters.and（fltrs））.build（）；
Drive.DriveApi.query（mGAC，qry）.setResultCallback（新的ResultCallback（）{
@凌驾
public void onResult（DriveApi.metadatabufferesult rslt）{
MetadataBuffer mdb=null；
if（rslt！=null&&rslt.getStatus（）.issucess（））{
试一试{
mdb=rslt.getMetadataBuffer（）；
for元数据（md:mdb）{
如果（md.isTrashed（））继续；
fromPath（md.getDriveId（），path.substring（idx+1））；
return；//+++第一次找到，下一次+>>
}
}最后{if（mdb！=null）mdb.close（）；}
}
MetadataChangeSet meta=new Builder（）.setTitle（titl）.setMimeType（UT.MIME_FLDR）.build（）；
parentId.asDriveFolder（）.createFolder（mGAC，meta）
.setResultCallback（新的ResultCallback（）{
@凌驾
公共无效onResult（DriveFolderResult rslt）{
DriveFolder dFld=rslt！=null&&rslt.getStatus（）.issucess（）？rslt.getDriveFolder（）：null；
如果（dFld！=null）{
getMetadata（mGAC）.setResultCallback（新的
  fromPath(Drive.DriveApi.getRootFolder(mGAC).getDriveId(), "MYROOT/2015/2015-12/file.jpg");
  ....
  void fromPath(final DriveId parentId, final String path) {
    if (parentId != null && path != null) {

      final int idx = path.indexOf('/');
      if (idx < 0) {
        // reached last path item - probably file name
        // CREATE FILE WITH patentID AND QUIT
        return;    //--- DONE -------------------->>>
      }

      final String titl = path.substring(0, idx);

      ArrayList<Filter> fltrs = new ArrayList<>();
      fltrs.add(Filters.in(SearchableField.PARENTS, parentId));
      fltrs.add(Filters.eq(SearchableField.TITLE, titl));
      fltrs.add(Filters.eq(SearchableField.MIME_TYPE, UT.MIME_FLDR));
      Query qry = new Query.Builder().addFilter(Filters.and(fltrs)).build();

      Drive.DriveApi.query(mGAC, qry).setResultCallback(new ResultCallback<DriveApi.MetadataBufferResult>() {
        @Override
        public void onResult(DriveApi.MetadataBufferResult rslt) {
          MetadataBuffer mdb = null;
          if (rslt != null && rslt.getStatus().isSuccess()) {
            try {
              mdb = rslt.getMetadataBuffer();
              for (Metadata md : mdb) {
                if (md.isTrashed()) continue;
                fromPath(md.getDriveId(), path.substring(idx + 1));
                return; //+++ first found, NEXT +++++++>>>
              }
            } finally { if (mdb != null) mdb.close(); }
          }

          MetadataChangeSet meta = new Builder().setTitle(titl).setMimeType(UT.MIME_FLDR).build();
          parentId.asDriveFolder().createFolder(mGAC, meta)
          .setResultCallback(new ResultCallback<DriveFolderResult>() {
            @Override
            public void onResult(DriveFolderResult rslt) {
              DriveFolder dFld = rslt != null && rslt.getStatus().isSuccess() ? rslt.getDriveFolder() : null;
              if (dFld != null) {
                dFld.getMetadata(mGAC).setResultCallback(new ResultCallback<MetadataResult>() {
                  @Override
                  public void onResult(MetadataResult rslt) {
                    if (rslt != null && rslt.getStatus().isSuccess()) {
                      fromPath(rslt.getMetadata().getDriveId(), path.substring(idx + 1));
                      return; //+++ created, NEXT +++++++>>>
                    }
                  }
                });
              }
            }
          });
        }
      });
    }
  }