How to use com.dropbox.core.v2

public static boolean isValid(String path)
{
  String error = findError(path);
  return (error == null);
}

  @Override
  protected DbxRawClientV2 withPathRoot(PathRoot pathRoot) {
    return new DbxUserRawClientV2(
      this.getRequestConfig(),
      this.accessToken,
      this.getHost(),
      this.getUserId(),
      pathRoot
    );
  }
}

  @Override
  protected DbxRawClientV2 withPathRoot(PathRoot pathRoot) {
    return new DbxTeamRawClientV2(
      this.getRequestConfig(),
      this.getHost(),
      this.accessToken,
      this.getUserId(),
      this.memberId,
      this.adminId,
      pathRoot
    );
  }
}

/**
 * Returns a {@link DbxClientV2} that performs requests against Dropbox API
 * user endpoints as the given team member.
 *
 * <p> This method performs no validation of the team member ID. </p>
 *
 * @param memberId  Team member ID of member in this client's team, never
 *     {@code null}.
 *
 * @return Dropbox client that issues requests to user endpoints as the
 *     given team member
 *
 * @throws IllegalArgumentException  If {@code memberId} is {@code null}
 */
public DbxClientV2 asMember(String memberId) {
  if (memberId == null) {
    throw new IllegalArgumentException("'memberId' should not be null");
  }
  DbxRawClientV2 asMemberClient = new DbxTeamRawClientV2(
    _client.getRequestConfig(),
    _client.getHost(),
    accessToken,
    _client.getUserId(),
    memberId,
    null,
    null
  );
  return new DbxClientV2(asMemberClient);
}

/**
 * Returns a new {@link DbxClientV2} that performs requests against Dropbox API
 * user endpoints relative to a namespace without including the namespace as
 * part of the path variable for every request.
 * (<a href="https://www.dropbox.com/developers/reference/namespace-guide#pathrootmodes">https://www.dropbox.com/developers/reference/namespace-guide#pathrootmodes</a>).
 *
 * <p> This method performs no validation of the namespace ID. </p>
 *
 * @param pathRoot  the path root for this client, never {@code null}.
 *
 * @return Dropbox client that issues requests with Dropbox-API-Path-Root header.
 *
 * @throws IllegalArgumentException  If {@code pathRoot} is {@code null}
 */
public DbxClientV2 withPathRoot(PathRoot pathRoot) {
  if (pathRoot == null) {
    throw new IllegalArgumentException("'pathRoot' should not be null");
  }
  return new DbxClientV2(_client.withPathRoot(pathRoot));
}

/**
 * Obtain a new instance of DbxClient and store it in configuration.
 */
public void createClient() {
  DbxRequestConfig config = new DbxRequestConfig(clientIdentifier, Locale.getDefault().toString());
  this.client = new DbxClientV2(config, accessToken);
}

/**
 * Updates an existing Paper doc with the provided content.
 *
 *
 * @return Uploader used to upload the request body and finish request.
 */
DocsUpdateUploader docsUpdate(PaperDocUpdateArgs arg) throws DbxException {
  HttpRequestor.Uploader _uploader = this.client.uploadStyle(this.client.getHost().getApi(),
                                "2/paper/docs/update",
                                arg,
                                false,
                                PaperDocUpdateArgs.Serializer.INSTANCE);
  return new DocsUpdateUploader(_uploader, this.client.getUserId());
}

/**
 * Creates a new Paper doc with the provided content.
 *
 *
 * @return Uploader used to upload the request body and finish request.
 */
DocsCreateUploader docsCreate(PaperDocCreateArgs arg) throws DbxException {
  HttpRequestor.Uploader _uploader = this.client.uploadStyle(this.client.getHost().getApi(),
                                "2/paper/docs/create",
                                arg,
                                false,
                                PaperDocCreateArgs.Serializer.INSTANCE);
  return new DocsCreateUploader(_uploader, this.client.getUserId());
}

/**
 * Retries the execution at most a maximum number of times.
 *
 * <p> This method is an alternative implementation to {@code DbxRequestUtil.runAndRetry(..)}
 * that does <b>not</b> retry 500 errors ({@link com.dropbox.core.ServerException}). To maintain
 * behavior backwards compatibility in v1, we leave the old implementation in {@code
 * DbxRequestUtil} unchanged.
 */
private static <T> T executeRetriable(int maxRetries, RetriableExecution<T> execution) throws DbxWrappedException, DbxException {
  if (maxRetries == 0) {
    return execution.execute();
  }
  int retries = 0;
  while (true) {
    try {
      return execution.execute();
    } catch (RetryException ex) {
      if (retries < maxRetries) {
        ++retries;
        sleepQuietlyWithJitter(ex.getBackoffMillis());
      } else {
        throw ex;
      }
    }
  }
}

@Override
protected void logout() throws BackgroundException {
  try {
    ((DropboxCommonsHttpRequestExecutor) client.getRequestConfig().getHttpRequestor()).close();
  }
  catch(IOException e) {
    throw new DefaultIOExceptionMappingService().map(e);
  }
}

/**
 * Convenience method for {@link DbxUploader#uploadAndFinish(InputStream)}:
 *
 * <pre><code>
 *    builder.start().uploadAndFinish(in);
 * </code></pre>
 *
 * @param in {@code InputStream} containing data to upload
 *
 * @return Response from server
 *
 * @throws X if the server sent an error response for the request
 * @throws DbxException if an error occurs uploading the data or reading the response
 * @throws IOException if an error occurs reading the input stream.
 */
public R uploadAndFinish(InputStream in) throws X, DbxException, IOException
{
  return start().uploadAndFinish(in);
}

/**
 * Same as {@link #DbxAppClientV2(DbxRequestConfig, String, String)} except you can also set the
 * hostnames of the Dropbox API servers. This is used in testing. You don't normally need to
 * call this.
 *
 * @param requestConfig  Default attributes to use for each request
 * @param key Dropbox app key (e.g. consumer key in OAuth)
 * @param secret Dropbox app secret (e.g. consumer secret in OAuth)
 * @param host  Dropbox hosts to send requests to (used for mocking and
 *     testing)
 */
public DbxAppClientV2(DbxRequestConfig requestConfig, String key, String secret, DbxHost host) {
  super(new DbxAppRawClientV2(requestConfig, key, secret, host, null));
}

/**
 * Same as {@link #DbxClientV2(DbxRequestConfig, String, DbxHost)} except you can
 * also set the userId for multiple Dropbox accounts.
 *
 * @param requestConfig  Default attributes to use for each request
 * @param accessToken  OAuth 2 access token (that you got from Dropbox) that
 *     gives your app the ability to make Dropbox API calls. Typically
 *     acquired through {@link com.dropbox.core.DbxWebAuth}
 * @param host  Dropbox hosts to send requests to (used for mocking and
 *     testing)
 * @param userId The user ID of the current Dropbox account. Used for multi-Dropbox
 *               account use-case.
 */
public DbxClientV2(DbxRequestConfig requestConfig, String accessToken, DbxHost host, String userId) {
  super(new DbxUserRawClientV2(requestConfig, accessToken, host, userId, null));
}

/**
 * Same as {@link #DbxTeamClientV2(DbxRequestConfig, String, DbxHost)} except you can
 * also set the userId for multiple Dropbox accounts.
 *
 * @param requestConfig  Default attributes to use for each request
 * @param accessToken  OAuth 2 access token (that you got from Dropbox) that
 *     gives your app the ability to make Dropbox API calls. Typically
 *     acquired through {@link com.dropbox.core.DbxWebAuth}
 * @param host  Dropbox hosts to send requests to (used for mocking and
 *     testing)
 * @param userId The user ID of the current Dropbox account. Used for
 *               multi-Dropbox account use-case.
 */
public DbxTeamClientV2(DbxRequestConfig requestConfig, String accessToken, DbxHost host, String userId) {
  super(new DbxTeamRawClientV2(requestConfig, host, accessToken, userId, null, null, null));
  this.accessToken = accessToken;
}

  /**
   * Convenience method for {@link DbxDownloader#download(OutputStream)}:
   *
   * <pre><code>
   *    builder.start().download(out);
   * </code></pre>
   *
   * @param out {@code OutputStream} to write response body to
   *
   * @return Response from server
   *
   * @throws DbxException if an error occurs reading the response or response body
   * @throws IOException if an error occurs writing the response body to the output stream.
   */
  public R download(OutputStream out) throws DbxException, IOException {
    return start().download(out);
  }
}

/**
 * Returns a {@link DbxClientV2} that performs requests against Dropbox API
 * user endpoints as the given team admin.
 *
 * <p> This method performs no validation of the team admin ID. </p>
 *
 * @param adminId  Team member ID of the admin in client's team, never
 *     {@code null}.
 *
 * @return Dropbox client that issues requests to user endpoints as the
 *     given team Admin.
 *
 * @throws IllegalArgumentException  If {@code adminId} is {@code null}
 */
public DbxClientV2 asAdmin(String adminId) {
  if (adminId == null) {
    throw new IllegalArgumentException("'adminId' should not be null");
  }
  DbxRawClientV2 asAdminClient = new DbxTeamRawClientV2(
    _client.getRequestConfig(),
    _client.getHost(),
    accessToken,
    _client.getUserId(),
    null,
    adminId,
    null
  );
  return new DbxClientV2(asAdminClient);
}

public static void init(String accessToken) {
  if (sDbxClient == null || DropboxClientFactory.accessToken != accessToken) {
    DbxRequestConfig requestConfig = DbxRequestConfig.newBuilder("upm")
        .withHttpRequestor(new OkHttp3Requestor(OkHttp3Requestor.defaultOkHttpClient()))
        .build();
    sDbxClient = new DbxClientV2(requestConfig, accessToken);
    DropboxClientFactory.accessToken = accessToken;
  }
}

/**
 * Convenience method for {@link DbxUploader#uploadAndFinish(InputStream, long)}:
 *
 * <pre><code>
 *    builder.start().uploadAndFinish(in, limit);
 * </code></pre>
 *
 * @param in    {@code InputStream} containing data to upload
 * @param limit Maximum number of bytes to read from the given {@code InputStream}
 *
 * @return Response from server
 *
 * @throws X if the server sent an error response for the request
 * @throws DbxException if an error occurs uploading the data or reading the response
 * @throws IOException if an error occurs reading the input stream.
 */
public R uploadAndFinish(InputStream in, long limit) throws X, DbxException, IOException
{
  return start().uploadAndFinish(in, limit);
}

/**
 * Same as {@link #DbxAppClientV2(DbxRequestConfig, String, String)} except you can also set the
 * hostnames of the Dropbox API servers. This is used in testing. You don't normally need to
 * call this.
 *
 * @param requestConfig  Default attributes to use for each request
 * @param key Dropbox app key (e.g. consumer key in OAuth)
 * @param secret Dropbox app secret (e.g. consumer secret in OAuth)
 * @param host  Dropbox hosts to send requests to (used for mocking and
 *     testing)
 * @param userId The user ID of the current Dropbox account. Used for
 *               multi-Dropbox account use-case.
 */
public DbxAppClientV2(DbxRequestConfig requestConfig, String key, String secret, DbxHost host, String userId) {
  super(new DbxAppRawClientV2(requestConfig, key, secret, host, userId));
}

  /**
   * Convenience method for {@link DbxUploader#uploadAndFinish(InputStream, IOUtil.ProgressListener)}:
   *
   * <pre><code>
   *    builder.start().uploadAndFinish(in, progressListener);
   * </code></pre>
   *
   * @param in {@code InputStream} containing data to upload
   * @param progressListener {@code ProgressListener} to track the upload progress. Only support
   *  OKHttpRequester and StandardHttpRequester
   *
   * @return Response from server
   *
   * @throws X if the server sent an error response for the request
   * @throws DbxException if an error occurs uploading the data or reading the response
   * @throws IOException if an error occurs reading the input stream.
   */
  public R uploadAndFinish(InputStream in, IOUtil.ProgressListener progressListener)
      throws X, DbxException, IOException
  {
    return start().uploadAndFinish(in, progressListener);
  }
}