/*
* 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 static android.os.Environment.STANDARD_DIRECTORIES;
import static com.android.documentsui.Shared.DEBUG;
import android.annotation.IntDef;
import android.annotation.Nullable;
import android.annotation.StringDef;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ResolveInfo;
import android.net.Uri;
import android.provider.DocumentsContract;
import android.util.Log;
import android.view.KeyEvent;
import com.android.documentsui.State.ActionType;
import com.android.documentsui.model.DocumentInfo;
import com.android.documentsui.model.RootInfo;
import com.android.documentsui.services.FileOperationService;
import com.android.documentsui.services.FileOperationService.OpType;
import com.android.internal.logging.MetricsLogger;
import com.android.internal.logging.MetricsProto.MetricsEvent;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.List;
/** @hide */
public final class Metrics {
private static final String TAG = "Metrics";
// These are the native provider authorities that the metrics code is capable of recognizing and
// explicitly counting.
private static final String AUTHORITY_MEDIA = "com.android.providers.media.documents";
private static final String AUTHORITY_STORAGE = "com.android.externalstorage.documents";
private static final String AUTHORITY_DOWNLOADS = "com.android.providers.downloads.documents";
private static final String AUTHORITY_MTP = "com.android.mtp.documents";
// These strings have to be whitelisted in tron. Do not change them.
private static final String COUNT_LAUNCH_ACTION = "docsui_launch_action";
private static final String COUNT_ROOT_VISITED = "docsui_root_visited";
private static final String COUNT_OPEN_MIME = "docsui_open_mime";
private static final String COUNT_CREATE_MIME = "docsui_create_mime";
private static final String COUNT_GET_CONTENT_MIME = "docsui_get_content_mime";
private static final String COUNT_BROWSE_ROOT = "docsui_browse_root";
@Deprecated private static final String COUNT_MANAGE_ROOT = "docsui_manage_root";
@Deprecated private static final String COUNT_MULTI_WINDOW = "docsui_multi_window";
private static final String COUNT_FILEOP_SYSTEM = "docsui_fileop_system";
private static final String COUNT_FILEOP_EXTERNAL = "docsui_fileop_external";
private static final String COUNT_FILEOP_CANCELED = "docsui_fileop_canceled";
private static final String COUNT_STARTUP_MS = "docsui_startup_ms";
private static final String COUNT_DRAWER_OPENED = "docsui_drawer_opened";
private static final String COUNT_USER_ACTION = "docsui_menu_action";
// Indices for bucketing roots in the roots histogram. "Other" is the catch-all index for any
// root that is not explicitly recognized by the Metrics code (see {@link
// #getSanitizedRootIndex}). Apps are also bucketed in this histogram.
// Do not change or rearrange these values, that will break historical data. Only add to the end
// of the list.
// Do not use negative numbers or zero; clearcut only handles positive integers.
private static final int ROOT_NONE = 1;
private static final int ROOT_OTHER = 2;
private static final int ROOT_AUDIO = 3;
private static final int ROOT_DEVICE_STORAGE = 4;
private static final int ROOT_DOWNLOADS = 5;
private static final int ROOT_HOME = 6;
private static final int ROOT_IMAGES = 7;
private static final int ROOT_RECENTS = 8;
private static final int ROOT_VIDEOS = 9;
private static final int ROOT_MTP = 10;
// Apps aren't really "roots", but they are treated as such in the roots fragment UI and so they
// are logged analogously to roots.
private static final int ROOT_THIRD_PARTY_APP = 100;
@IntDef(flag = true, value = {
ROOT_NONE,
ROOT_OTHER,
ROOT_AUDIO,
ROOT_DEVICE_STORAGE,
ROOT_DOWNLOADS,
ROOT_HOME,
ROOT_IMAGES,
ROOT_RECENTS,
ROOT_VIDEOS,
ROOT_MTP,
ROOT_THIRD_PARTY_APP
})
@Retention(RetentionPolicy.SOURCE)
public @interface Root {}
// Indices for bucketing mime types.
// Do not change or rearrange these values, that will break historical data. Only add to the end
// of the list.
// Do not use negative numbers or zero; clearcut only handles positive integers.
private static final int MIME_NONE = 1; // null mime
private static final int MIME_ANY = 2; // */*
private static final int MIME_APPLICATION = 3; // application/*
private static final int MIME_AUDIO = 4; // audio/*
private static final int MIME_IMAGE = 5; // image/*
private static final int MIME_MESSAGE = 6; // message/*
private static final int MIME_MULTIPART = 7; // multipart/*
private static final int MIME_TEXT = 8; // text/*
private static final int MIME_VIDEO = 9; // video/*
private static final int MIME_OTHER = 10; // anything not enumerated below
@IntDef(flag = true, value = {
MIME_NONE,
MIME_ANY,
MIME_APPLICATION,
MIME_AUDIO,
MIME_IMAGE,
MIME_MESSAGE,
MIME_MULTIPART,
MIME_TEXT,
MIME_VIDEO,
MIME_OTHER
})
@Retention(RetentionPolicy.SOURCE)
public @interface Mime {}
// Codes representing different kinds of file operations. These are used for bucketing
// operations in the COUNT_FILEOP_{SYSTEM|EXTERNAL} histograms.
// Do not change or rearrange these values, that will break historical data. Only add to the
// list.
// Do not use negative numbers or zero; clearcut only handles positive integers.
private static final int FILEOP_OTHER = 1; // any file operation not listed below
private static final int FILEOP_COPY_INTRA_PROVIDER = 2; // Copy within a provider
private static final int FILEOP_COPY_SYSTEM_PROVIDER = 3; // Copy to a system provider.
private static final int FILEOP_COPY_EXTERNAL_PROVIDER = 4; // Copy to a 3rd-party provider.
private static final int FILEOP_MOVE_INTRA_PROVIDER = 5; // Move within a provider.
private static final int FILEOP_MOVE_SYSTEM_PROVIDER = 6; // Move to a system provider.
private static final int FILEOP_MOVE_EXTERNAL_PROVIDER = 7; // Move to a 3rd-party provider.
private static final int FILEOP_DELETE = 8;
private static final int FILEOP_RENAME = 9;
private static final int FILEOP_CREATE_DIR = 10;
private static final int FILEOP_OTHER_ERROR = 100;
private static final int FILEOP_DELETE_ERROR = 101;
private static final int FILEOP_MOVE_ERROR = 102;
private static final int FILEOP_COPY_ERROR = 103;
private static final int FILEOP_RENAME_ERROR = 104;
private static final int FILEOP_CREATE_DIR_ERROR = 105;
@IntDef(flag = true, value = {
FILEOP_OTHER,
FILEOP_COPY_INTRA_PROVIDER,
FILEOP_COPY_SYSTEM_PROVIDER,
FILEOP_COPY_EXTERNAL_PROVIDER,
FILEOP_MOVE_INTRA_PROVIDER,
FILEOP_MOVE_SYSTEM_PROVIDER,
FILEOP_MOVE_EXTERNAL_PROVIDER,
FILEOP_DELETE,
FILEOP_RENAME,
FILEOP_CREATE_DIR,
FILEOP_OTHER_ERROR,
FILEOP_COPY_ERROR,
FILEOP_MOVE_ERROR,
FILEOP_DELETE_ERROR,
FILEOP_RENAME_ERROR,
FILEOP_CREATE_DIR_ERROR
})
@Retention(RetentionPolicy.SOURCE)
public @interface FileOp {}
// Codes representing different kinds of file operations. These are used for bucketing
// operations in the COUNT_FILEOP_CANCELED histogram.
// Do not change or rearrange these values, that will break historical data. Only add to the
// list.
// Do not use negative numbers or zero; clearcut only handles positive integers.
private static final int OPERATION_UNKNOWN = 1;
private static final int OPERATION_COPY = 2;
private static final int OPERATION_MOVE = 3;
private static final int OPERATION_DELETE= 4;
@IntDef(flag = true, value = {
OPERATION_UNKNOWN,
OPERATION_COPY,
OPERATION_MOVE,
OPERATION_DELETE
})
@Retention(RetentionPolicy.SOURCE)
public @interface MetricsOpType {}
// Codes representing different provider types. Used for sorting file operations when logging.
private static final int PROVIDER_INTRA = 0;
private static final int PROVIDER_SYSTEM = 1;
private static final int PROVIDER_EXTERNAL = 2;
@IntDef(flag = false, value = {
PROVIDER_INTRA,
PROVIDER_SYSTEM,
PROVIDER_EXTERNAL
})
@Retention(RetentionPolicy.SOURCE)
public @interface Provider {}
// Codes representing different user actions. These are used for bucketing stats in the
// COUNT_USER_ACTION histogram.
// The historgram includes action triggered from menu or invoked by keyboard shortcut.
// Do not change or rearrange these values, that will break historical data. Only add to the
// list.
// Do not use negative numbers or zero; clearcut only handles positive integers.
public static final int USER_ACTION_OTHER = 1;
public static final int USER_ACTION_GRID = 2;
public static final int USER_ACTION_LIST = 3;
public static final int USER_ACTION_SORT_NAME = 4;
public static final int USER_ACTION_SORT_DATE = 5;
public static final int USER_ACTION_SORT_SIZE = 6;
public static final int USER_ACTION_SEARCH = 7;
public static final int USER_ACTION_SHOW_SIZE = 8;
public static final int USER_ACTION_HIDE_SIZE = 9;
public static final int USER_ACTION_SETTINGS = 10;
public static final int USER_ACTION_COPY_TO = 11;
public static final int USER_ACTION_MOVE_TO = 12;
public static final int USER_ACTION_DELETE = 13;
public static final int USER_ACTION_RENAME = 14;
public static final int USER_ACTION_CREATE_DIR = 15;
public static final int USER_ACTION_SELECT_ALL = 16;
public static final int USER_ACTION_SHARE = 17;
public static final int USER_ACTION_OPEN = 18;
public static final int USER_ACTION_SHOW_ADVANCED = 19;
public static final int USER_ACTION_HIDE_ADVANCED = 20;
public static final int USER_ACTION_NEW_WINDOW = 21;
public static final int USER_ACTION_PASTE_CLIPBOARD = 22;
public static final int USER_ACTION_COPY_CLIPBOARD = 23;
public static final int USER_ACTION_DRAG_N_DROP = 24;
public static final int USER_ACTION_DRAG_N_DROP_MULTI_WINDOW = 25;
@IntDef(flag = false, value = {
USER_ACTION_OTHER,
USER_ACTION_GRID,
USER_ACTION_LIST,
USER_ACTION_SORT_NAME,
USER_ACTION_SORT_DATE,
USER_ACTION_SORT_SIZE,
USER_ACTION_SEARCH,
USER_ACTION_SHOW_SIZE,
USER_ACTION_HIDE_SIZE,
USER_ACTION_SETTINGS,
USER_ACTION_COPY_TO,
USER_ACTION_MOVE_TO,
USER_ACTION_DELETE,
USER_ACTION_RENAME,
USER_ACTION_CREATE_DIR,
USER_ACTION_SELECT_ALL,
USER_ACTION_SHARE,
USER_ACTION_OPEN,
USER_ACTION_SHOW_ADVANCED,
USER_ACTION_HIDE_ADVANCED,
USER_ACTION_NEW_WINDOW,
USER_ACTION_PASTE_CLIPBOARD,
USER_ACTION_COPY_CLIPBOARD,
USER_ACTION_DRAG_N_DROP,
USER_ACTION_DRAG_N_DROP_MULTI_WINDOW
})
@Retention(RetentionPolicy.SOURCE)
public @interface UserAction {}
// Codes representing different menu actions. These are used for bucketing stats in the
// COUNT_MENU_ACTION histogram.
// Do not change or rearrange these values, that will break historical data. Only add to the
// list.
// Do not use negative numbers or zero; clearcut only handles positive integers.
private static final int ACTION_OTHER = 1;
private static final int ACTION_OPEN = 2;
private static final int ACTION_CREATE = 3;
private static final int ACTION_GET_CONTENT = 4;
private static final int ACTION_OPEN_TREE = 5;
@Deprecated private static final int ACTION_MANAGE = 6;
private static final int ACTION_BROWSE = 7;
private static final int ACTION_PICK_COPY_DESTINATION = 8;
@IntDef(flag = true, value = {
ACTION_OTHER,
ACTION_OPEN,
ACTION_CREATE,
ACTION_GET_CONTENT,
ACTION_OPEN_TREE,
ACTION_MANAGE,
ACTION_BROWSE,
ACTION_PICK_COPY_DESTINATION
})
@Retention(RetentionPolicy.SOURCE)
public @interface MetricsAction {}
// Codes representing different actions to open the drawer. They are used for bucketing stats in
// the COUNT_DRAWER_OPENED histogram.
// Do not change or rearrange these values, that will break historical data. Only add to the
// list.
// Do not use negative numbers or zero; clearcut only handles positive integers.
private static final int DRAWER_OPENED_HAMBURGER = 1;
private static final int DRAWER_OPENED_SWIPE = 2;
@IntDef(flag = true, value = {
DRAWER_OPENED_HAMBURGER,
DRAWER_OPENED_SWIPE
})
@Retention(RetentionPolicy.SOURCE)
public @interface DrawerTrigger {}
/**
* Logs when DocumentsUI is started, and how. Call this when DocumentsUI first starts up.
*
* @param context
* @param state
* @param intent
*/
public static void logActivityLaunch(Context context, State state, Intent intent) {
// Log the launch action.
logHistogram(context, COUNT_LAUNCH_ACTION, toMetricsAction(state.action));
// Then log auxiliary data (roots/mime types) associated with some actions.
Uri uri = intent.getData();
switch (state.action) {
case State.ACTION_OPEN:
logHistogram(context, COUNT_OPEN_MIME, sanitizeMime(intent.getType()));
break;
case State.ACTION_CREATE:
logHistogram(context, COUNT_CREATE_MIME, sanitizeMime(intent.getType()));
break;
case State.ACTION_GET_CONTENT:
logHistogram(context, COUNT_GET_CONTENT_MIME, sanitizeMime(intent.getType()));
break;
case State.ACTION_BROWSE:
logHistogram(context, COUNT_BROWSE_ROOT, sanitizeRoot(uri));
break;
default:
break;
}
}
/**
* Logs a root visited event. Call this when the user clicks on a root in the RootsFragment.
*
* @param context
* @param info
*/
public static void logRootVisited(Context context, RootInfo info) {
logHistogram(context, COUNT_ROOT_VISITED, sanitizeRoot(info));
}
/**
* Logs an app visited event. Call this when the user clicks on an app in the RootsFragment.
*
* @param context
* @param info
*/
public static void logAppVisited(Context context, ResolveInfo info) {
logHistogram(context, COUNT_ROOT_VISITED, sanitizeRoot(info));
}
/**
* Logs a drawer opened event. Call this when the user opens drawer by swipe or by clicking the
* hamburger icon.
* @param context
* @param trigger type of action that opened the drawer
*/
public static void logDrawerOpened(Context context, @DrawerController.Trigger int trigger) {
if (trigger == DrawerController.OPENED_HAMBURGER) {
logHistogram(context, COUNT_DRAWER_OPENED, DRAWER_OPENED_HAMBURGER);
} else if (trigger == DrawerController.OPENED_SWIPE) {
logHistogram(context, COUNT_DRAWER_OPENED, DRAWER_OPENED_SWIPE);
}
}
/**
* Logs file operation stats. Call this when a file operation has completed. The given
* DocumentInfo is only used to distinguish broad categories of actions (e.g. copying from one
* provider to another vs copying within a given provider). No PII is logged.
*
* @param context
* @param operationType
* @param srcs
* @param dst
*/
public static void logFileOperation(
Context context,
@OpType int operationType,
List<DocumentInfo> srcs,
@Nullable DocumentInfo dst) {
ProviderCounts counts = countProviders(srcs, dst);
if (counts.intraProvider > 0) {
logIntraProviderFileOps(context, dst.authority, operationType);
}
if (counts.systemProvider > 0) {
// Log file operations on system providers.
logInterProviderFileOps(context, COUNT_FILEOP_SYSTEM, dst, operationType);
}
if (counts.externalProvider > 0) {
// Log file operations on external providers.
logInterProviderFileOps(context, COUNT_FILEOP_EXTERNAL, dst, operationType);
}
}
/**
* Logs create directory operation. It is a part of file operation stats. We do not
* differentiate between internal and external locations, all create directory operations are
* logged under COUNT_FILEOP_SYSTEM. Call this when a create directory operation has completed.
*
* @param context
*/
public static void logCreateDirOperation(Context context) {
logHistogram(context, COUNT_FILEOP_SYSTEM, FILEOP_CREATE_DIR);
}
/**
* Logs rename file operation. It is a part of file operation stats. We do not differentiate
* between internal and external locations, all rename operations are logged under
* COUNT_FILEOP_SYSTEM. Call this when a rename file operation has completed.
*
* @param context
*/
public static void logRenameFileOperation(Context context) {
logHistogram(context, COUNT_FILEOP_SYSTEM, FILEOP_RENAME);
}
/**
* Logs some kind of file operation error. Call this when a file operation (e.g. copy, delete)
* fails.
*
* @param context
* @param operationType
* @param failedFiles
*/
public static void logFileOperationErrors(Context context, @OpType int operationType,
List<DocumentInfo> failedFiles) {
ProviderCounts counts = countProviders(failedFiles, null);
@FileOp int opCode = FILEOP_OTHER_ERROR;
switch (operationType) {
case FileOperationService.OPERATION_COPY:
opCode = FILEOP_COPY_ERROR;
break;
case FileOperationService.OPERATION_DELETE:
opCode = FILEOP_DELETE_ERROR;
break;
case FileOperationService.OPERATION_MOVE:
opCode = FILEOP_MOVE_ERROR;
break;
}
if (counts.systemProvider > 0) {
logHistogram(context, COUNT_FILEOP_SYSTEM, opCode);
}
if (counts.externalProvider > 0) {
logHistogram(context, COUNT_FILEOP_EXTERNAL, opCode);
}
}
/**
* Logs create directory operation error. We do not differentiate between internal and external
* locations, all create directory errors are logged under COUNT_FILEOP_SYSTEM. Call this when a
* create directory operation fails.
*
* @param context
*/
public static void logCreateDirError(Context context) {
logHistogram(context, COUNT_FILEOP_SYSTEM, FILEOP_CREATE_DIR_ERROR);
}
/**
* Logs rename file operation error. We do not differentiate between internal and external
* locations, all rename errors are logged under COUNT_FILEOP_SYSTEM. Call this
* when a rename file operation fails.
*
* @param context
*/
public static void logRenameFileError(Context context) {
logHistogram(context, COUNT_FILEOP_SYSTEM, FILEOP_RENAME_ERROR);
}
/**
* Logs the cancellation of a file operation. Call this when a Job is canceled.
* @param context
* @param operationType
*/
public static void logFileOperationCancelled(Context context, @OpType int operationType) {
logHistogram(context, COUNT_FILEOP_CANCELED, toMetricsOpType(operationType));
}
/**
* Logs startup time in milliseconds.
* @param context
* @param startupMs Startup time in milliseconds.
*/
public static void logStartupMs(Context context, int startupMs) {
logHistogram(context, COUNT_STARTUP_MS, startupMs);
}
private static void logInterProviderFileOps(
Context context,
String histogram,
DocumentInfo dst,
@OpType int operationType) {
if (operationType == FileOperationService.OPERATION_DELETE) {
logHistogram(context, histogram, FILEOP_DELETE);
} else {
assert(dst != null);
@Provider int providerType =
isSystemProvider(dst.authority) ? PROVIDER_SYSTEM : PROVIDER_EXTERNAL;
logHistogram(context, histogram, getOpCode(operationType, providerType));
}
}
private static void logIntraProviderFileOps(
Context context, String authority, @OpType int operationType) {
// Find the right histogram to log to, then log the operation.
String histogram = isSystemProvider(authority) ? COUNT_FILEOP_SYSTEM : COUNT_FILEOP_EXTERNAL;
logHistogram(context, histogram, getOpCode(operationType, PROVIDER_INTRA));
}
// Types for logInvalidScopedAccessRequest
public static final String SCOPED_DIRECTORY_ACCESS_INVALID_ARGUMENTS =
"docsui_scoped_directory_access_invalid_args";
public static final String SCOPED_DIRECTORY_ACCESS_INVALID_DIRECTORY =
"docsui_scoped_directory_access_invalid_dir";
public static final String SCOPED_DIRECTORY_ACCESS_ERROR =
"docsui_scoped_directory_access_error";
@StringDef(value = {
SCOPED_DIRECTORY_ACCESS_INVALID_ARGUMENTS,
SCOPED_DIRECTORY_ACCESS_INVALID_DIRECTORY,
SCOPED_DIRECTORY_ACCESS_ERROR
})
@Retention(RetentionPolicy.SOURCE)
public @interface InvalidScopedAccess{}
public static void logInvalidScopedAccessRequest(Context context,
@InvalidScopedAccess String type) {
switch (type) {
case SCOPED_DIRECTORY_ACCESS_INVALID_ARGUMENTS:
case SCOPED_DIRECTORY_ACCESS_INVALID_DIRECTORY:
case SCOPED_DIRECTORY_ACCESS_ERROR:
logCount(context, type);
break;
default:
Log.wtf(TAG, "invalid InvalidScopedAccess: " + type);
}
}
// Types for logValidScopedAccessRequest
public static final int SCOPED_DIRECTORY_ACCESS_ALREADY_GRANTED = 0;
public static final int SCOPED_DIRECTORY_ACCESS_GRANTED = 1;
public static final int SCOPED_DIRECTORY_ACCESS_DENIED = 2;
public static final int SCOPED_DIRECTORY_ACCESS_DENIED_AND_PERSIST = 3;
public static final int SCOPED_DIRECTORY_ACCESS_ALREADY_DENIED = 4;
@IntDef(flag = true, value = {
SCOPED_DIRECTORY_ACCESS_ALREADY_GRANTED,
SCOPED_DIRECTORY_ACCESS_GRANTED,
SCOPED_DIRECTORY_ACCESS_DENIED,
SCOPED_DIRECTORY_ACCESS_DENIED_AND_PERSIST,
SCOPED_DIRECTORY_ACCESS_ALREADY_DENIED
})
@Retention(RetentionPolicy.SOURCE)
public @interface ScopedAccessGrant {}
public static void logValidScopedAccessRequest(Activity activity, String directory,
@ScopedAccessGrant int type) {
int index = -1;
if (OpenExternalDirectoryActivity.DIRECTORY_ROOT.equals(directory)) {
index = -2;
} else {
for (int i = 0; i < STANDARD_DIRECTORIES.length; i++) {
if (STANDARD_DIRECTORIES[i].equals(directory)) {
index = i;
break;
}
}
}
final String packageName = activity.getCallingPackage();
switch (type) {
case SCOPED_DIRECTORY_ACCESS_ALREADY_GRANTED:
MetricsLogger.action(activity, MetricsEvent
.ACTION_SCOPED_DIRECTORY_ACCESS_ALREADY_GRANTED_BY_PACKAGE, packageName);
MetricsLogger.action(activity, MetricsEvent
.ACTION_SCOPED_DIRECTORY_ACCESS_ALREADY_GRANTED_BY_FOLDER, index);
break;
case SCOPED_DIRECTORY_ACCESS_GRANTED:
MetricsLogger.action(activity, MetricsEvent
.ACTION_SCOPED_DIRECTORY_ACCESS_GRANTED_BY_PACKAGE, packageName);
MetricsLogger.action(activity, MetricsEvent
.ACTION_SCOPED_DIRECTORY_ACCESS_GRANTED_BY_FOLDER, index);
break;
case SCOPED_DIRECTORY_ACCESS_DENIED:
MetricsLogger.action(activity, MetricsEvent
.ACTION_SCOPED_DIRECTORY_ACCESS_DENIED_BY_PACKAGE, packageName);
MetricsLogger.action(activity, MetricsEvent
.ACTION_SCOPED_DIRECTORY_ACCESS_DENIED_BY_FOLDER, index);
break;
case SCOPED_DIRECTORY_ACCESS_DENIED_AND_PERSIST:
MetricsLogger.action(activity, MetricsEvent
.ACTION_SCOPED_DIRECTORY_ACCESS_DENIED_AND_PERSIST_BY_PACKAGE, packageName);
MetricsLogger.action(activity, MetricsEvent
.ACTION_SCOPED_DIRECTORY_ACCESS_DENIED_AND_PERSIST_BY_FOLDER, index);
break;
case SCOPED_DIRECTORY_ACCESS_ALREADY_DENIED:
MetricsLogger.action(activity, MetricsEvent
.ACTION_SCOPED_DIRECTORY_ACCESS_ALREADY_DENIED_BY_PACKAGE, packageName);
MetricsLogger.action(activity, MetricsEvent
.ACTION_SCOPED_DIRECTORY_ACCESS_ALREADY_DENIED_BY_FOLDER, index);
break;
default:
Log.wtf(TAG, "invalid ScopedAccessGrant: " + type);
}
}
/**
* Logs the action that was started by user.
* @param context
* @param userAction
*/
public static void logUserAction(Context context, @UserAction int userAction) {
logHistogram(context, COUNT_USER_ACTION, userAction);
}
/**
* Internal method for making a MetricsLogger.count call. Increments the given counter by 1.
*
* @param context
* @param name The counter to increment.
*/
private static void logCount(Context context, String name) {
if (DEBUG) Log.d(TAG, name + ": " + 1);
MetricsLogger.count(context, name, 1);
}
/**
* Internal method for making a MetricsLogger.histogram call.
*
* @param context
* @param name The name of the histogram.
* @param bucket The bucket to increment.
*/
private static void logHistogram(Context context, String name, @ActionType int bucket) {
if (DEBUG) Log.d(TAG, name + ": " + bucket);
MetricsLogger.histogram(context, name, bucket);
}
/**
* Generates an integer identifying the given root. For privacy, this function only recognizes a
* small set of hard-coded roots (ones provided by the system). Other roots are all grouped into
* a single ROOT_OTHER bucket.
*/
private static @Root int sanitizeRoot(Uri uri) {
if (uri == null || uri.getAuthority() == null || LauncherActivity.isLaunchUri(uri)) {
return ROOT_NONE;
}
switch (uri.getAuthority()) {
case AUTHORITY_MEDIA:
switch (DocumentsContract.getRootId(uri)) {
case "audio_root":
return ROOT_AUDIO;
case "images_root":
return ROOT_IMAGES;
case "videos_root":
return ROOT_VIDEOS;
default:
return ROOT_OTHER;
}
case AUTHORITY_STORAGE:
if ("home".equals(DocumentsContract.getRootId(uri))) {
return ROOT_HOME;
} else {
return ROOT_DEVICE_STORAGE;
}
case AUTHORITY_DOWNLOADS:
return ROOT_DOWNLOADS;
case AUTHORITY_MTP:
return ROOT_MTP;
default:
return ROOT_OTHER;
}
}
/** @see #sanitizeRoot(Uri) */
private static @Root int sanitizeRoot(RootInfo root) {
if (root.isRecents()) {
// Recents root is special and only identifiable via this method call. Other roots are
// identified by URI.
return ROOT_RECENTS;
} else {
return sanitizeRoot(root.getUri());
}
}
/** @see #sanitizeRoot(Uri) */
private static @Root int sanitizeRoot(ResolveInfo info) {
// Log all apps under a single bucket in the roots histogram.
return ROOT_THIRD_PARTY_APP;
}
/**
* Generates an int identifying a mime type. For privacy, this function only recognizes a small
* set of hard-coded types. For any other type, this function returns "other".
*
* @param mimeType
* @return
*/
private static @Mime int sanitizeMime(String mimeType) {
if (mimeType == null) {
return MIME_NONE;
} else if ("*/*".equals(mimeType)) {
return MIME_ANY;
} else {
String type = mimeType.substring(0, mimeType.indexOf('/'));
switch (type) {
case "application":
return MIME_APPLICATION;
case "audio":
return MIME_AUDIO;
case "image":
return MIME_IMAGE;
case "message":
return MIME_MESSAGE;
case "multipart":
return MIME_MULTIPART;
case "text":
return MIME_TEXT;
case "video":
return MIME_VIDEO;
}
}
// Bucket all other types into one bucket.
return MIME_OTHER;
}
private static boolean isSystemProvider(String authority) {
switch (authority) {
case AUTHORITY_MEDIA:
case AUTHORITY_STORAGE:
case AUTHORITY_DOWNLOADS:
return true;
default:
return false;
}
}
/**
* @param operation
* @param providerType
* @return An opcode, suitable for use as histogram bucket, for the given operation/provider
* combination.
*/
private static @FileOp int getOpCode(@OpType int operation, @Provider int providerType) {
switch (operation) {
case FileOperationService.OPERATION_COPY:
switch (providerType) {
case PROVIDER_INTRA:
return FILEOP_COPY_INTRA_PROVIDER;
case PROVIDER_SYSTEM:
return FILEOP_COPY_SYSTEM_PROVIDER;
case PROVIDER_EXTERNAL:
return FILEOP_COPY_EXTERNAL_PROVIDER;
}
case FileOperationService.OPERATION_MOVE:
switch (providerType) {
case PROVIDER_INTRA:
return FILEOP_MOVE_INTRA_PROVIDER;
case PROVIDER_SYSTEM:
return FILEOP_MOVE_SYSTEM_PROVIDER;
case PROVIDER_EXTERNAL:
return FILEOP_MOVE_EXTERNAL_PROVIDER;
}
case FileOperationService.OPERATION_DELETE:
return FILEOP_DELETE;
default:
Log.w(TAG, "Unrecognized operation type when logging a file operation");
return FILEOP_OTHER;
}
}
/**
* Maps FileOperationService OpType values, to MetricsOpType values.
*/
private static @MetricsOpType int toMetricsOpType(@OpType int operation) {
switch (operation) {
case FileOperationService.OPERATION_COPY:
return OPERATION_COPY;
case FileOperationService.OPERATION_MOVE:
return OPERATION_MOVE;
case FileOperationService.OPERATION_DELETE:
return OPERATION_DELETE;
case FileOperationService.OPERATION_UNKNOWN:
default:
return OPERATION_UNKNOWN;
}
}
private static @MetricsAction int toMetricsAction(int action) {
switch(action) {
case State.ACTION_OPEN:
return ACTION_OPEN;
case State.ACTION_CREATE:
return ACTION_CREATE;
case State.ACTION_GET_CONTENT:
return ACTION_GET_CONTENT;
case State.ACTION_OPEN_TREE:
return ACTION_OPEN_TREE;
case State.ACTION_BROWSE:
return ACTION_BROWSE;
case State.ACTION_PICK_COPY_DESTINATION:
return ACTION_PICK_COPY_DESTINATION;
default:
return ACTION_OTHER;
}
}
/**
* Count the given src documents and provide a tally of how many come from the same provider as
* the dst document (if a dst is provided), how many come from system providers, and how many
* come from external 3rd-party providers.
*/
private static ProviderCounts countProviders(
List<DocumentInfo> srcs, @Nullable DocumentInfo dst) {
ProviderCounts counts = new ProviderCounts();
for (DocumentInfo doc: srcs) {
if (dst != null && doc.authority.equals(dst.authority)) {
counts.intraProvider++;
} else if (isSystemProvider(doc.authority)){
counts.systemProvider++;
} else {
counts.externalProvider++;
}
}
return counts;
}
private static class ProviderCounts {
int intraProvider;
int systemProvider;
int externalProvider;
}
}