/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.documentsui;
import android.content.Context;
import android.content.pm.ProviderInfo;
import android.content.res.AssetFileDescriptor;
import android.database.Cursor;
import android.database.MatrixCursor.RowBuilder;
import android.database.MatrixCursor;
import android.graphics.Point;
import android.os.CancellationSignal;
import android.os.FileUtils;
import android.os.ParcelFileDescriptor;
import android.provider.DocumentsContract.Document;
import android.provider.DocumentsContract.Root;
import android.provider.DocumentsContract;
import android.provider.DocumentsProvider;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
/**
* Provider with thousands of files for testing loading time of directories in DocumentsUI.
* It doesn't support any file operations.
*/
public class StressProvider extends DocumentsProvider {
public static final String DEFAULT_AUTHORITY = "com.android.documentsui.stressprovider";
// Empty root.
public static final String STRESS_ROOT_0_ID = "STRESS_ROOT_0";
// Root with thousands of directories.
public static final String STRESS_ROOT_1_ID = "STRESS_ROOT_1";
// Root with hundreds of files.
public static final String STRESS_ROOT_2_ID = "STRESS_ROOT_2";
private static final String STRESS_ROOT_0_DOC_ID = "STRESS_ROOT_0_DOC";
private static final String STRESS_ROOT_1_DOC_ID = "STRESS_ROOT_1_DOC";
private static final String STRESS_ROOT_2_DOC_ID = "STRESS_ROOT_2_DOC";
private static final int STRESS_ROOT_1_ITEMS = 10000;
private static final int STRESS_ROOT_2_ITEMS = 300;
private static final String MIME_TYPE_IMAGE = "image/jpeg";
private static final long REFERENCE_TIMESTAMP = 1459159369359L;
private static final String[] DEFAULT_ROOT_PROJECTION = new String[] {
Root.COLUMN_ROOT_ID, Root.COLUMN_FLAGS, Root.COLUMN_TITLE, Root.COLUMN_DOCUMENT_ID,
Root.COLUMN_AVAILABLE_BYTES
};
private static final String[] DEFAULT_DOCUMENT_PROJECTION = new String[] {
Document.COLUMN_DOCUMENT_ID, Document.COLUMN_MIME_TYPE, Document.COLUMN_DISPLAY_NAME,
Document.COLUMN_LAST_MODIFIED, Document.COLUMN_FLAGS, Document.COLUMN_SIZE,
};
private String mAuthority = DEFAULT_AUTHORITY;
// Map from a root document id to children document ids.
private Map<String, ArrayList<StubDocument>> mChildDocuments = new HashMap<>();
private Map<String, StubDocument> mDocuments = new HashMap<>();
private Map<String, StubRoot> mRoots = new HashMap<>();
@Override
public void attachInfo(Context context, ProviderInfo info) {
mAuthority = info.authority;
super.attachInfo(context, info);
}
@Override
public boolean onCreate() {
StubDocument document;
ArrayList<StubDocument> children = new ArrayList<StubDocument>();
mChildDocuments.put(STRESS_ROOT_1_DOC_ID, children);
for (int i = 0; i < STRESS_ROOT_1_ITEMS; i++) {
document = StubDocument.createDirectory(i);
mDocuments.put(document.id, document);
children.add(document);
}
children = new ArrayList<StubDocument>();
mChildDocuments.put(STRESS_ROOT_2_DOC_ID, children);
for (int i = 0; i < STRESS_ROOT_2_ITEMS; i++) {
try {
document = StubDocument.createFile(
getContext(), MIME_TYPE_IMAGE,
com.android.documentsui.perftests.R.raw.earth_small,
STRESS_ROOT_1_ITEMS + i);
} catch (IOException e) {
return false;
}
mDocuments.put(document.id, document);
children.add(document);
}
mRoots.put(STRESS_ROOT_0_ID, new StubRoot(STRESS_ROOT_0_ID, STRESS_ROOT_0_DOC_ID));
mRoots.put(STRESS_ROOT_1_ID, new StubRoot(STRESS_ROOT_1_ID, STRESS_ROOT_1_DOC_ID));
mRoots.put(STRESS_ROOT_2_ID, new StubRoot(STRESS_ROOT_2_ID, STRESS_ROOT_2_DOC_ID));
mDocuments.put(STRESS_ROOT_0_DOC_ID, StubDocument.createDirectory(STRESS_ROOT_0_DOC_ID));
mDocuments.put(STRESS_ROOT_1_DOC_ID, StubDocument.createDirectory(STRESS_ROOT_1_DOC_ID));
mDocuments.put(STRESS_ROOT_2_DOC_ID, StubDocument.createDirectory(STRESS_ROOT_2_DOC_ID));
return true;
}
@Override
public Cursor queryRoots(String[] projection) throws FileNotFoundException {
final MatrixCursor result = new MatrixCursor(DEFAULT_ROOT_PROJECTION);
for (StubRoot root : mRoots.values()) {
includeRoot(result, root);
}
return result;
}
@Override
public Cursor queryDocument(String documentId, String[] projection)
throws FileNotFoundException {
final MatrixCursor result = new MatrixCursor(DEFAULT_DOCUMENT_PROJECTION);
final StubDocument document = mDocuments.get(documentId);
includeDocument(result, document);
return result;
}
@Override
public Cursor queryChildDocuments(String parentDocumentId, String[] projection,
String sortOrder)
throws FileNotFoundException {
final MatrixCursor result = new MatrixCursor(DEFAULT_DOCUMENT_PROJECTION);
final ArrayList<StubDocument> childDocuments = mChildDocuments.get(parentDocumentId);
if (childDocuments != null) {
for (StubDocument document : childDocuments) {
includeDocument(result, document);
}
}
return result;
}
@Override
public AssetFileDescriptor openDocumentThumbnail(String docId, Point sizeHint,
CancellationSignal signal)
throws FileNotFoundException {
final StubDocument document = mDocuments.get(docId);
return getContext().getResources().openRawResourceFd(document.thumbnail);
}
@Override
public ParcelFileDescriptor openDocument(String docId, String mode,
CancellationSignal signal)
throws FileNotFoundException {
throw new UnsupportedOperationException();
}
private void includeRoot(MatrixCursor result, StubRoot root) {
final RowBuilder row = result.newRow();
row.add(Root.COLUMN_ROOT_ID, root.id);
row.add(Root.COLUMN_FLAGS, 0);
row.add(Root.COLUMN_TITLE, root.id);
row.add(Root.COLUMN_DOCUMENT_ID, root.documentId);
}
private void includeDocument(MatrixCursor result, StubDocument document) {
final RowBuilder row = result.newRow();
row.add(Document.COLUMN_DOCUMENT_ID, document.id);
row.add(Document.COLUMN_DISPLAY_NAME, document.id);
row.add(Document.COLUMN_SIZE, document.size);
row.add(Document.COLUMN_MIME_TYPE, document.mimeType);
row.add(Document.COLUMN_FLAGS,
document.thumbnail != -1 ? Document.FLAG_SUPPORTS_THUMBNAIL : 0);
row.add(Document.COLUMN_LAST_MODIFIED, document.lastModified);
}
private static String getStubDocumentIdForFile(File file) {
return file.getAbsolutePath();
}
private static class StubDocument {
final String mimeType;
final String id;
final int size;
final long lastModified;
final int thumbnail;
private StubDocument(String mimeType, String id, int size, long lastModified,
int thumbnail) {
this.mimeType = mimeType;
this.id = id;
this.size = size;
this.lastModified = lastModified;
this.thumbnail = thumbnail;
}
public static StubDocument createDirectory(int index) {
return new StubDocument(
DocumentsContract.Document.MIME_TYPE_DIR, createRandomId(index), 0,
createRandomTime(index), -1);
}
public static StubDocument createDirectory(String id) {
return new StubDocument(DocumentsContract.Document.MIME_TYPE_DIR, id, 0, 0, -1);
}
public static StubDocument createFile(Context context, String mimeType, int thumbnail,
int index) throws IOException {
return new StubDocument(
mimeType, createRandomId(index), createRandomSize(index),
createRandomTime(index), thumbnail);
}
private static String createRandomId(int index) {
final Random random = new Random(index);
final StringBuilder builder = new StringBuilder();
for (int i = 0; i < 20; i++) {
builder.append((char) (random.nextInt(96) + 32));
}
builder.append(index); // Append a number to guarantee uniqueness.
return builder.toString();
}
private static int createRandomSize(int index) {
final Random random = new Random(index);
return random.nextInt(1024 * 1024 * 100); // Up to 100 MB.
}
private static long createRandomTime(int index) {
final Random random = new Random(index);
// Up to 30 days backwards from REFERENCE_TIMESTAMP.
return REFERENCE_TIMESTAMP - random.nextLong() % 1000L * 60 * 60 * 24 * 30;
}
}
private static class StubRoot {
final String id;
final String documentId;
public StubRoot(String id, String documentId) {
this.id = id;
this.documentId = documentId;
}
}
}