Java FileMetadata类代码示例

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
/**
 * Download file from Dropbox and store it to a local file.
 */
public VersionedRook download(Uri repoUri, Uri uri, File localFile) throws IOException {
    linkedOrThrow();

    OutputStream out = new BufferedOutputStream(new FileOutputStream(localFile));

    try {
        Metadata pathMetadata = dbxClient.files().getMetadata(uri.getPath());

        if (pathMetadata instanceof FileMetadata) {
            FileMetadata metadata = (FileMetadata) pathMetadata;

            String rev = metadata.getRev();
            long mtime = metadata.getServerModified().getTime();

            dbxClient.files().download(metadata.getPathLower(), rev).download(out);

            return new VersionedRook(repoUri, uri, rev, mtime);

        } else {
            throw new IOException("Failed downloading Dropbox file " + uri + ": Not a file");
        }

    } catch (DbxException e) {
        if (e.getMessage() != null) {
            throw new IOException("Failed downloading Dropbox file " + uri + ": " + e.getMessage());
        } else {
            throw new IOException("Failed downloading Dropbox file " + uri + ": " + e.toString());
        }
    } finally {
        out.close();
    }
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
public VersionedRook move(Uri repoUri, Uri from, Uri to) throws IOException {
    linkedOrThrow();

    try {
        FileMetadata metadata = (FileMetadata) dbxClient.files().move(from.getPath(), to.getPath());

        String rev = metadata.getRev();
        long mtime = metadata.getServerModified().getTime();

        return new VersionedRook(repoUri, to, rev, mtime);

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

        if (e.getMessage() != null) { // TODO: Move this throwing to utils
            throw new IOException("Failed moving " + from + " to " + to + ": " + e.getMessage(), e);
        } else {
            throw new IOException("Failed moving " + from + " to " + to + ": " + e.toString(), e);
        }
    }
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
public FileMetadata uploadFile(File file) throws Exception {
    if (authSession()) {
        try {
            InputStream is = new FileInputStream(file);
            try {
                FileMetadata fileMetadata = dropboxClient.files().uploadBuilder("/" + file.getName()).withMode(WriteMode.ADD).uploadAndFinish(is);
                Log.i("Financisto", "Dropbox: The uploaded file's rev is: " + fileMetadata.getRev());
                return fileMetadata;
            } finally {
                IOUtil.closeInput(is);
            }
        } catch (Exception e) {
            Log.e("Financisto", "Dropbox: Something wrong", e);
            throw new ImportExportException(R.string.dropbox_error, e);
        }
    } else {
        throw new ImportExportException(R.string.dropbox_auth_error);
    }
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
@Override
public FileMetadata backup(BackupConfiguration backupConf) throws BackupException {
	dropboxService.assumeAvailable();
	String localFileBackup = null;
	try {	
		localFileBackup = mongoDumpService.backup(backupConf);
		FileMetadata dbFile;
		String dropTarget = getDropboxFilename(backupConf);
		try {
			dbFile = dropboxService.uploadFile(localFileBackup, dropTarget);
			log.debug("backup uploaded '{}'", dbFile.getPathLower());
		} catch (Throwable e) {
			String exMsg = String.format("Unable to upload backup '%s' to dropbox : %s", dropTarget, e.getMessage());
			throw new BackupException(exMsg, e);
		}
		return dbFile;
	} catch (BackupException be) {
		throw be;
	} finally {
		if (localFileBackup != null) {
			new File(localFileBackup).delete();
		}
	}
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
private void uploadFiles(List<MotionEvent> motionEvents) throws IOException {
    for (MotionEvent motionEvent : motionEvents) {
        try (InputStream in = new ByteArrayInputStream(motionEvent.getImage())) {
            String dropboxPath = "/motion_events/" + eyeballsConfiguration.getCameraName() + "/" + concurrentDateFormatAccess.convertDateToString(motionEvent.getTimestamp());
            createFolder(dropboxPath);

            FileMetadata metadata = dbxClientV2.files().uploadBuilder(dropboxPath + "/" + motionEvent.getId() + ".jpg")
                    .withMode(WriteMode.ADD)
                    .withClientModified(motionEvent.getTimestamp())
                    .uploadAndFinish(in);

            log.debug(metadata.toStringMultiline());
        } catch (Exception e) {
            log.error("Error uploading to Dropbox. ", e);
        }
    }
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
public static DropboxFileData convertMetadata(final Metadata metadata) {
    final DropboxFileData.DropboxFileDataBuilder builder = DropboxFileData.builder()
        .changeType(DropboxChangeType.fromMetadata(metadata))
        .pathDisplay(metadata.getPathDisplay())
        .pathLower(metadata.getPathLower());

    if (metadata instanceof FolderMetadata) {
        final FolderMetadata folderMetadata = (FolderMetadata) metadata;
        builder.id(folderMetadata.getId());

    } else if (metadata instanceof FileMetadata) {
        final FileMetadata fileMetadata = (FileMetadata) metadata;
        final ZoneId zoneId = ZoneOffset.UTC;
        final Instant clientModifiedInstant = fileMetadata.getClientModified().toInstant();
        final Instant serverModifiedInstant = fileMetadata.getServerModified().toInstant();
        builder
            .id(fileMetadata.getId())
            .rev(fileMetadata.getRev())
            .size(fileMetadata.getSize())
            .clientModified(LocalDateTime.ofInstant(clientModifiedInstant, zoneId))
            .serverModified(LocalDateTime.ofInstant(serverModifiedInstant, zoneId));
    }

    return builder.build();
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
private void renderFile(HttpServletResponse response, String path, FileMetadata f)
    throws IOException
{
    FormProtection fp = FormProtection.start(response);

    response.setContentType("text/html");
    response.setCharacterEncoding("utf-8");
    PrintWriter out = new PrintWriter(IOUtil.utf8Writer(response.getOutputStream()));

    out.println("<html>");
    out.println("<head><title>" + escapeHtml4(path) + "- Web File Browser</title></head>");
    out.println("<body>");
    fp.insertAntiRedressHtml(out);

    out.println("<h2>Path: " + escapeHtml4(path) + "</h2>");

    out.println("<pre>");
    out.print(escapeHtml4(f.toStringMultiline()));
    out.println("</pre>");

    out.println("</body>");
    out.println("</html>");

    out.flush();
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
@Override
protected FileMetadata doInBackground(String... params) {
    String localUri = params[0];
    File localFile = UriHelpers.getFileForUri(mContext, Uri.parse(localUri));

    if (localFile != null) {
        String remoteFolderPath = params[1];

        // Note - this is not ensuring the name is a valid dropbox file name
        String remoteFileName = localFile.getName();

        try (InputStream inputStream = new FileInputStream(localFile)) {
            return mDbxClient.files().uploadBuilder(remoteFolderPath + "/" + remoteFileName)
                    .withMode(WriteMode.OVERWRITE)
                    .uploadAndFinish(inputStream);
        } catch (DbxException | IOException e) {
            mException = e;
        }
    }

    return null;
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
@Test
public void testRangeDownload() throws Exception {
    DbxClientV2 client = ITUtil.newClientV2();

    byte [] contents = ITUtil.randomBytes(500);
    String path = ITUtil.path(getClass(), "/testRangeDownload.dat");

    FileMetadata metadata = client.files().uploadBuilder(path)
        .withAutorename(false)
        .withMode(WriteMode.OVERWRITE)
        .withMute(true)
        .uploadAndFinish(new ByteArrayInputStream(contents));

    assertEquals(metadata.getSize(), contents.length);

    assertRangeDownload(client, path, contents, 0, contents.length);
    assertRangeDownload(client, path, contents, 0, 200);
    assertRangeDownload(client, path, contents, 300, 200);
    assertRangeDownload(client, path, contents, 499, 1);
    assertRangeDownload(client, path, contents, 0, 600);
    assertRangeDownload(client, path, contents, 250, null);
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
private FileMetadata constructFileMetadate() throws Exception {
    Class builderClass = FileMetadata.Builder.class;
    Constructor constructor = builderClass.getDeclaredConstructors()[0];
    constructor.setAccessible(true);

    List<Object> arguments = new ArrayList<Object>(Arrays.asList(
            "bar.txt",
            "id:1HkLjqifwMAAAAAAAAAAAQ",
            new Date(1456169040985L),
            new Date(1456169040985L),
            "2e0c38735597",
            2091603
    ));

    // hack for internal version of SDK
    if (constructor.getParameterTypes().length > 6) {
        arguments.addAll(Arrays.asList("20MB", "text.png", "text/plain"));
    }

    FileMetadata.Builder builder = (FileMetadata.Builder) constructor.newInstance(arguments.toArray());
    return builder.build();
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
/** Upload file to Dropbox. */
public VersionedRook upload(File file, Uri repoUri, String fileName) throws IOException {
    linkedOrThrow();

    Uri bookUri = repoUri.buildUpon().appendPath(fileName).build();

    if (file.length() > UPLOAD_FILE_SIZE_LIMIT * 1024 * 1024) {
        throw new IOException(LARGE_FILE);
    }

    FileMetadata metadata;
    InputStream in = new FileInputStream(file);

    try {
        metadata = dbxClient.files()
                .uploadBuilder(bookUri.getPath())
                .withMode(WriteMode.OVERWRITE)
                .uploadAndFinish(in);

    } catch (DbxException e) {
        if (e.getMessage() != null) {
            throw new IOException("Failed overwriting " + bookUri.getPath() + " on Dropbox: " + e.getMessage());
        } else {
            throw new IOException("Failed overwriting " + bookUri.getPath() + " on Dropbox: " + e.toString());
        }
    }

    String rev = metadata.getRev();
    long mtime = metadata.getServerModified().getTime();

    return new VersionedRook(repoUri, bookUri, rev, mtime);
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
@Override
public InputStream read(final Path file, final TransferStatus status, final ConnectionCallback callback) throws BackgroundException {
    try {
        final DownloadBuilder builder = new DbxUserFilesRequests(session.getClient()).downloadBuilder(file.getAbsolute());
        if(status.isAppend()) {
            final HttpRange range = HttpRange.withStatus(status);
            builder.range(range.getStart());
        }
        final DbxDownloader<FileMetadata> downloader = builder.start();
        return downloader.getInputStream();
    }
    catch(DbxException e) {
        throw new DropboxExceptionMappingService().map("Download {0} failed", e, file);
    }
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
@Override
public AttributedList<Path> search(final Path workdir, final Filter<Path> regex, final ListProgressListener listener) throws BackgroundException {
    try {
        final AttributedList<Path> list = new AttributedList<>();
        long start = 0;
        SearchResult result;
        do {
            result = new DbxUserFilesRequests(session.getClient()).searchBuilder(workdir.isRoot() ? StringUtils.EMPTY : workdir.getAbsolute(), regex.toPattern().pattern())
                    .withMode(SearchMode.FILENAME).withStart(start).start();
            final List<SearchMatch> matches = result.getMatches();
            for(SearchMatch match : matches) {
                final Metadata metadata = match.getMetadata();
                final EnumSet<AbstractPath.Type> type;
                if(metadata instanceof FileMetadata) {
                    type = EnumSet.of(Path.Type.file);
                }
                else if(metadata instanceof FolderMetadata) {
                    type = EnumSet.of(Path.Type.directory);
                }
                else {
                    log.warn(String.format("Skip file %s", metadata));
                    return null;
                }
                list.add(new Path(metadata.getPathDisplay(), type, attributes.convert(metadata)));
                listener.chunk(workdir, list);
            }
            start = result.getStart();
        }
        while(result.getMore());
        return list;
    }
    catch(DbxException e) {
        throw new DropboxExceptionMappingService().map("Failure to read attributes of {0}", e, workdir);
    }
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
protected Path parse(final Path directory, final Metadata metadata) {
    final EnumSet<AbstractPath.Type> type;
    if(metadata instanceof FileMetadata) {
        type = EnumSet.of(Path.Type.file);
    }
    else if(metadata instanceof FolderMetadata) {
        type = EnumSet.of(Path.Type.directory);
    }
    else {
        log.warn(String.format("Skip file %s", metadata));
        return null;
    }
    return new Path(directory, PathNormalizer.name(metadata.getName()), type, attributes.convert(metadata));
}
 

import com.dropbox.core.v2.files.FileMetadata; //导入依赖的package包/类
protected PathAttributes convert(final Metadata metadata) {
    final PathAttributes attributes = new PathAttributes();
    if(metadata instanceof FileMetadata) {
        final FileMetadata fm = (FileMetadata) metadata;
        attributes.setSize(fm.getSize());
        attributes.setModificationDate(fm.getClientModified().getTime());
    }
    return attributes;
}