Java DbxException.printStackTrace方法代码示例

import com.dropbox.core.DbxException; //导入方法依赖的package包/类
public void delete(String path) throws IOException {
    linkedOrThrow();

    try {
        dbxClient.files().delete(path);

    } catch (DbxException e) {
        e.printStackTrace();

        if (e.getMessage() != null) {
            throw new IOException("Failed deleting " + path + " on Dropbox: " + e.getMessage());
        } else {
            throw new IOException("Failed deleting " + path + " on Dropbox: " + e.toString());
        }
    }
}
 

import com.dropbox.core.DbxException; //导入方法依赖的package包/类
@Override
public boolean isFolderAlreadyExists(String folder) {
    ListFolderResult dropboxFolders = null;
    if (android.os.Build.VERSION.SDK_INT > 9) {
        StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
        StrictMode.setThreadPolicy(policy);
        try {
            String dir = "/" + folder.substring(0, folder.lastIndexOf("/"));
            dropboxFolders = DropboxClientFactory.getClient().files().listFolder(dir);
        } catch (DbxException e) {
            e.printStackTrace();
        }
    }
    if (dropboxFolders != null) {
        Log.d(TAG, dropboxFolders.toString());
        String s = dropboxFolders.toStringMultiline();
        if (s.contains("/" + folder))
            return true;
    }
    return false;
}
 

import com.dropbox.core.DbxException; //导入方法依赖的package包/类
public static List<String> dropboxGetFiles(String code) {

        DbxRequestConfig config = new DbxRequestConfig("Media Information Service Configuration");
        DbxClientV2 client = new DbxClientV2(config, code);
        ListFolderResult result = null;
        List<String> elements = new LinkedList<String>();


        try {
            result = client.files().listFolderBuilder("/media").withRecursive(true).start();
            while (true) {
                for (Metadata metadata : result.getEntries()) {
                    if (metadata instanceof FileMetadata) {
                        elements.add(metadata.getName());
                    }
                }

                if (!result.getHasMore()) {
                    break;
                }

                result = client.files().listFolderContinue(result.getCursor());
            }

            //System.out.println(elements.toString());
        } catch (DbxException e) {
            e.printStackTrace();
        }


        return elements;


    }
 

import com.dropbox.core.DbxException; //导入方法依赖的package包/类
public Files.FileMetadata uploadFile(String path, InputStream inputStream) throws IOException, DbxException {
    if(Reference.testing) return null;

    try {
        dropbox.dbxClientV2.files.delete(path);
    } catch (DbxException e) {
        e.printStackTrace();
    }

    return dropbox.dbxClientV2.files.uploadBuilder(path).run(inputStream);
}
 

import com.dropbox.core.DbxException; //导入方法依赖的package包/类
public String shareableUrlForPath(String path) {
    if(Reference.testing) return "TESTURL";

    try {
        String url = dropbox.dbxClientV2.sharing.createSharedLink(path).url;
        url = url.split("\\?")[0];
        return url + "?raw=1";
    } catch (DbxException e) {
        e.printStackTrace();
        return null;
    }
}
 

import com.dropbox.core.DbxException; //导入方法依赖的package包/类
@Override
public boolean authenticate(String code) {

    try {
        DbxAuthFinish authFinish = webAuth.finish(code);

        dbClient = new DbxClient(config, authFinish.accessToken);

        Credentials cred = new Credentials();

        //Remove old credentials, if they exist
        cred.removeCredentials("dropbox");

        //Save new credentials
        cred.saveCredentials("dropbox", authFinish.accessToken);

        bearerToken = authFinish.accessToken;

        authenticated = true;

        return true;
    } catch (DbxException e) {
        e.printStackTrace();
        authenticated = false;
        return false;
    }
}
 

import com.dropbox.core.DbxException; //导入方法依赖的package包/类
@Override
public void finalizeUpload(MultiPartUpload mpu) {
    try {
        String path = (String) mpu.getObject("path");
        String id = (String) mpu.getObject("id");
        dbClient.chunkedUploadFinish(path, DbxWriteMode.add(), id);
    } catch (DbxException ex) {
        ex.printStackTrace();
    }
}
 

import com.dropbox.core.DbxException; //导入方法依赖的package包/类
@Override
public boolean restoreToRevision(String path, String rev) {
	try {
		return client.restoreFile(path, rev) != null;
	} catch (DbxException e) {
		e.printStackTrace();
		return false;
	}
}
 

import com.dropbox.core.DbxException; //导入方法依赖的package包/类
public void downloadFolder(String remotePath, String targetPath, int depth)
		throws CSPException {
	try {
		DbxEntry folder = client.getMetadata(remotePath);
		if (folder.isFolder()) {
			File remoteFolder = new File(remotePath);
			File targetFolder = new File(targetPath + File.separator
					+ remoteFolder.getName());
			if (!targetFolder.exists()) {
				targetFolder.mkdirs();
			}
			DbxEntry.WithChildren folderWithChildren = client
					.getMetadataWithChildren(remotePath);
			for (DbxEntry file : folderWithChildren.children) {
				if (depth >= DropboxConstants.MAX_TREE_SEARCH_DEPTH) {
					break;
				}
				if (file.isFile()) {
					downloadFile(file.path, targetPath + "/" + folder.name
							+ "/" + file.name);
				} else if (file.isFolder()) {
					downloadFolder(file.path, targetPath + "/"
							+ folder.name, depth + 1);
				}
			}
		}
	} catch (DbxException e) {
		e.printStackTrace();
	}
}
 

import com.dropbox.core.DbxException; //导入方法依赖的package包/类
public List<VersionedRook> getBooks(Uri repoUri) throws IOException {
    linkedOrThrow();

    List<VersionedRook> list = new ArrayList<>();

    String path = repoUri.getPath();

    /* Fix root path. */
    if (path == null || path.equals("/")) {
        path = ROOT_PATH;
    }

    /* Strip trailing slashes. */
    path = path.replaceAll("/+$", "");

    try {
        if (ROOT_PATH.equals(path) || dbxClient.files().getMetadata(path) instanceof FolderMetadata) {
            /* Get folder content. */
            ListFolderResult result = dbxClient.files().listFolder(path);
            while (true) {
                for (Metadata metadata : result.getEntries()) {
                    if (metadata instanceof FileMetadata) {
                        FileMetadata file = (FileMetadata) metadata;

                        if (BookName.isSupportedFormatFileName(file.getName())) {
                            Uri uri = repoUri.buildUpon().appendPath(file.getName()).build();
                            VersionedRook book = new VersionedRook(
                                    repoUri,
                                    uri,
                                    file.getRev(),
                                    file.getServerModified().getTime());

                            list.add(book);
                        }
                    }
                }

                if (!result.getHasMore()) {
                    break;
                }

                result = dbxClient.files().listFolderContinue(result.getCursor());
            }

        } else {
            throw new IOException("Not a directory: " + repoUri);
        }

    } catch (DbxException e) {
        e.printStackTrace();

        /* If we get NOT_FOUND from Dropbox, just return the empty list. */
        if (e instanceof GetMetadataErrorException) {
            if (((GetMetadataErrorException) e).errorValue.getPathValue() == LookupError.NOT_FOUND) {
                return list;
            }
        }

        throw new IOException("Failed getting the list of files in " + repoUri +
                              " listing " + path + ": " +
                              (e.getMessage() != null ? e.getMessage() : e.toString()));
    }

    return list;
}