Offer to cache ContentResolver-related Bundles.
There are a handful of core system services that collect data from
third-party ContentProviders by spinning them up and then caching the
results locally in memory. However, if those apps are killed due to
low-memory pressure, they lose that cached data and have to collect
it again from scratch. It's impossible for those apps to maintain a
correct cache when not running, since they'll miss out on Uri change
notifications.
To work around this, this change introducing a narrowly-scoped
caching mechanism that maps from Uris to Bundles. The cache is
isolated per-user and per-calling-package, and internally it's
optimized to keep the Uri notification flow as fast as possible.
Each Bundle is invalidated whenever a notification event for a Uri
key is sent, or when the package hosting the provider is changed.
This change also wires up DocumentsUI to use this new mechanism,
which improves cold-start performance from 3300ms to 1800ms. The
more DocumentsProviders a system has, the more pronounced this
benefit is. Use BOOT_COMPLETED to build the cache at boot.
Add more permission docs, send a missing extra in DATA_CLEARED
broadcast.
Bug: 18406595
Change-Id: If3eae14bb3c69a8b83a65f530e081efc3b34d4bc
diff --git a/core/java/android/content/ContentResolver.java b/core/java/android/content/ContentResolver.java
index 4e1b6e0..441f188 100644
--- a/core/java/android/content/ContentResolver.java
+++ b/core/java/android/content/ContentResolver.java
@@ -2440,6 +2440,28 @@
}
}
+ /** {@hide} */
+ public void putCache(Uri key, Bundle value) {
+ try {
+ getContentService().putCache(mContext.getPackageName(), key, value,
+ mContext.getUserId());
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+
+ /** {@hide} */
+ public Bundle getCache(Uri key) {
+ try {
+ final Bundle bundle = getContentService().getCache(mContext.getPackageName(), key,
+ mContext.getUserId());
+ if (bundle != null) bundle.setClassLoader(mContext.getClassLoader());
+ return bundle;
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+
/**
* Returns sampling percentage for a given duration.
*
diff --git a/core/java/android/content/IContentService.aidl b/core/java/android/content/IContentService.aidl
index 8b471a0..d47e780 100644
--- a/core/java/android/content/IContentService.aidl
+++ b/core/java/android/content/IContentService.aidl
@@ -179,6 +179,8 @@
int userId);
void addStatusChangeListener(int mask, ISyncStatusObserver callback);
-
void removeStatusChangeListener(ISyncStatusObserver callback);
+
+ void putCache(in String packageName, in Uri key, in Bundle value, int userId);
+ Bundle getCache(in String packageName, in Uri key, int userId);
}
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index fbc96c2..6444c6c 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -1483,11 +1483,21 @@
<!-- Allows an application to manage access to documents, usually as part
of a document picker.
+ <p>This permission should <em>only</em> be requested by the platform
+ document management app. This permission cannot be granted to
+ third-party apps.
<p>Protection level: signature
-->
<permission android:name="android.permission.MANAGE_DOCUMENTS"
android:protectionLevel="signature" />
+ <!-- @hide Allows an application to cache content.
+ <p>Not for use by third-party applications.
+ <p>Protection level: signature
+ -->
+ <permission android:name="android.permission.CACHE_CONTENT"
+ android:protectionLevel="signature" />
+
<!-- ================================== -->
<!-- Permissions for screenlock -->
<!-- ================================== -->
diff --git a/packages/DocumentsUI/AndroidManifest.xml b/packages/DocumentsUI/AndroidManifest.xml
index 6f38e25..6fe239e 100644
--- a/packages/DocumentsUI/AndroidManifest.xml
+++ b/packages/DocumentsUI/AndroidManifest.xml
@@ -5,6 +5,8 @@
<uses-permission android:name="android.permission.MANAGE_DOCUMENTS" />
<uses-permission android:name="android.permission.REMOVE_TASKS" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
+ <uses-permission android:name="android.permission.CACHE_CONTENT" />
+ <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<application
android:name=".DocumentsApplication"
@@ -105,6 +107,12 @@
</intent-filter>
</receiver>
+ <receiver android:name=".BootReceiver">
+ <intent-filter>
+ <action android:name="android.intent.action.BOOT_COMPLETED" />
+ </intent-filter>
+ </receiver>
+
<service
android:name=".services.FileOperationService"
android:exported="false">
diff --git a/packages/DocumentsUI/src/com/android/documentsui/BootReceiver.java b/packages/DocumentsUI/src/com/android/documentsui/BootReceiver.java
new file mode 100644
index 0000000..cdea9d7
--- /dev/null
+++ b/packages/DocumentsUI/src/com/android/documentsui/BootReceiver.java
@@ -0,0 +1,34 @@
+/*
+ * 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.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+
+/**
+ * Prime {@link RootsCache} when the system is booted.
+ */
+public class BootReceiver extends BroadcastReceiver {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ // We already spun up our application object before getting here, which
+ // kicked off a task to load roots, so this broadcast is finished once
+ // that first pass is done.
+ DocumentsApplication.getRootsCache(context).setBootCompletedResult(goAsync());
+ }
+}
diff --git a/packages/DocumentsUI/src/com/android/documentsui/RootsCache.java b/packages/DocumentsUI/src/com/android/documentsui/RootsCache.java
index 2b7294a..6efe9c8 100644
--- a/packages/DocumentsUI/src/com/android/documentsui/RootsCache.java
+++ b/packages/DocumentsUI/src/com/android/documentsui/RootsCache.java
@@ -18,6 +18,7 @@
import static com.android.documentsui.Shared.DEBUG;
+import android.content.BroadcastReceiver.PendingResult;
import android.content.ContentProviderClient;
import android.content.ContentResolver;
import android.content.Context;
@@ -30,6 +31,7 @@
import android.database.Cursor;
import android.net.Uri;
import android.os.AsyncTask;
+import android.os.Bundle;
import android.os.Handler;
import android.os.SystemClock;
import android.provider.DocumentsContract;
@@ -40,11 +42,11 @@
import com.android.documentsui.model.RootInfo;
import com.android.internal.annotations.GuardedBy;
+import libcore.io.IoUtils;
+
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
-import libcore.io.IoUtils;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
@@ -63,6 +65,8 @@
private static final String TAG = "RootsCache";
+ private static final boolean ENABLE_SYSTEM_CACHE = true;
+
private final Context mContext;
private final ContentObserver mObserver;
private OnCacheUpdateListener mCacheUpdateListener;
@@ -73,6 +77,11 @@
private final CountDownLatch mFirstLoad = new CountDownLatch(1);
@GuardedBy("mLock")
+ private boolean mFirstLoadDone;
+ @GuardedBy("mLock")
+ private PendingResult mBootCompletedResult;
+
+ @GuardedBy("mLock")
private Multimap<String, RootInfo> mRoots = ArrayListMultimap.create();
@GuardedBy("mLock")
private HashSet<String> mStoppedAuthorities = new HashSet<>();
@@ -118,7 +127,7 @@
public void updateAsync() {
// NOTE: This method is called when the UI language changes.
- // For that reason we upadte our RecentsRoot to reflect
+ // For that reason we update our RecentsRoot to reflect
// the current language.
mRecentsRoot.title = mContext.getString(R.string.root_recent);
@@ -152,7 +161,25 @@
}
}
- private void waitForFirstLoad() {
+ public void setBootCompletedResult(PendingResult result) {
+ synchronized (mLock) {
+ // Quickly check if we've already finished loading, otherwise hang
+ // out until first pass is finished.
+ if (mFirstLoadDone) {
+ result.finish();
+ } else {
+ mBootCompletedResult = result;
+ }
+ }
+ }
+
+ /**
+ * Block until the first {@link UpdateTask} pass has finished.
+ *
+ * @return {@code true} if cached roots is ready to roll, otherwise
+ * {@code false} if we timed out while waiting.
+ */
+ private boolean waitForFirstLoad() {
boolean success = false;
try {
success = mFirstLoad.await(15, TimeUnit.SECONDS);
@@ -161,6 +188,7 @@
if (!success) {
Log.w(TAG, "Timeout waiting for first update");
}
+ return success;
}
/**
@@ -222,9 +250,11 @@
final long start = SystemClock.elapsedRealtime();
if (mFilterPackage != null) {
- // Need at least first load, since we're going to be using
- // previously cached values for non-matching packages.
- waitForFirstLoad();
+ // We must have previously cached values to fill in non-matching
+ // packages, so wait around for successful first load.
+ if (!waitForFirstLoad()) {
+ return null;
+ }
}
mTaskRoots.put(mRecentsRoot.authority, mRecentsRoot);
@@ -243,6 +273,11 @@
if (DEBUG)
Log.d(TAG, "Update found " + mTaskRoots.size() + " roots in " + delta + "ms");
synchronized (mLock) {
+ mFirstLoadDone = true;
+ if (mBootCompletedResult != null) {
+ mBootCompletedResult.finish();
+ mBootCompletedResult = null;
+ }
mRoots = mTaskRoots;
mStoppedAuthorities = mTaskStoppedAuthorities;
}
@@ -300,9 +335,18 @@
}
}
- final List<RootInfo> roots = new ArrayList<>();
final Uri rootsUri = DocumentsContract.buildRootsUri(authority);
+ if (ENABLE_SYSTEM_CACHE) {
+ // Look for roots data that we might have cached for ourselves in the
+ // long-lived system process.
+ final Bundle systemCache = resolver.getCache(rootsUri);
+ if (systemCache != null) {
+ if (DEBUG) Log.d(TAG, "System cache hit for " + authority);
+ return systemCache.getParcelableArrayList(TAG);
+ }
+ }
+ final ArrayList<RootInfo> roots = new ArrayList<>();
ContentProviderClient client = null;
Cursor cursor = null;
try {
@@ -318,6 +362,16 @@
IoUtils.closeQuietly(cursor);
ContentProviderClient.releaseQuietly(client);
}
+
+ if (ENABLE_SYSTEM_CACHE) {
+ // Cache these freshly parsed roots over in the long-lived system
+ // process, in case our process goes away. The system takes care of
+ // invalidating the cache if the package or Uri changes.
+ final Bundle systemCache = new Bundle();
+ systemCache.putParcelableArrayList(TAG, roots);
+ resolver.putCache(rootsUri, systemCache);
+ }
+
return roots;
}
diff --git a/packages/DocumentsUI/src/com/android/documentsui/model/RootInfo.java b/packages/DocumentsUI/src/com/android/documentsui/model/RootInfo.java
index 3eaf10a..3960475 100644
--- a/packages/DocumentsUI/src/com/android/documentsui/model/RootInfo.java
+++ b/packages/DocumentsUI/src/com/android/documentsui/model/RootInfo.java
@@ -55,7 +55,7 @@
private static final int VERSION_DROP_TYPE = 2;
// The values of these constants determine the sort order of various roots in the RootsFragment.
- @IntDef(flag = true, value = {
+ @IntDef(flag = false, value = {
TYPE_IMAGES,
TYPE_VIDEO,
TYPE_AUDIO,
diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java
index 07f668b..f99d035 100644
--- a/services/core/java/com/android/server/am/ActivityManagerService.java
+++ b/services/core/java/com/android/server/am/ActivityManagerService.java
@@ -5347,6 +5347,7 @@
Intent intent = new Intent(Intent.ACTION_PACKAGE_DATA_CLEARED,
Uri.fromParts("package", packageName, null));
intent.putExtra(Intent.EXTRA_UID, pkgUid);
+ intent.putExtra(Intent.EXTRA_USER_HANDLE, UserHandle.getUserId(pkgUid));
broadcastIntentInPackage("android", Process.SYSTEM_UID, intent,
null, null, 0, null, null, null, null, false, false, userId);
} catch (RemoteException e) {
diff --git a/services/core/java/com/android/server/content/ContentService.java b/services/core/java/com/android/server/content/ContentService.java
index 212e077..03191a0 100644
--- a/services/core/java/com/android/server/content/ContentService.java
+++ b/services/core/java/com/android/server/content/ContentService.java
@@ -18,12 +18,16 @@
import android.Manifest;
import android.accounts.Account;
+import android.annotation.Nullable;
import android.app.ActivityManager;
+import android.app.AppOpsManager;
+import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.Context;
import android.content.IContentService;
import android.content.Intent;
+import android.content.IntentFilter;
import android.content.ISyncStatusObserver;
import android.content.PeriodicSync;
import android.content.SyncAdapterType;
@@ -32,6 +36,7 @@
import android.content.SyncStatusInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManagerInternal;
+import android.content.pm.ProviderInfo;
import android.database.IContentObserver;
import android.database.sqlite.SQLiteException;
import android.net.Uri;
@@ -44,30 +49,64 @@
import android.os.SystemProperties;
import android.os.UserHandle;
import android.text.TextUtils;
+import android.util.ArrayMap;
import android.util.Log;
+import android.util.Pair;
import android.util.Slog;
+import android.util.SparseArray;
import android.util.SparseIntArray;
+
+import com.android.internal.annotations.GuardedBy;
+import com.android.internal.util.IndentingPrintWriter;
+import com.android.internal.util.Preconditions;
import com.android.server.LocalServices;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.security.InvalidParameterException;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
+import java.util.Objects;
/**
* {@hide}
*/
public final class ContentService extends IContentService.Stub {
private static final String TAG = "ContentService";
+
private Context mContext;
private boolean mFactoryTest;
+
private final ObserverNode mRootNode = new ObserverNode("");
+
private SyncManager mSyncManager = null;
private final Object mSyncManagerLock = new Object();
+ /**
+ * Map from userId to providerPackageName to [clientPackageName, uri] to
+ * value. This structure is carefully optimized to keep invalidation logic
+ * as cheap as possible.
+ */
+ @GuardedBy("mCache")
+ private final SparseArray<ArrayMap<String, ArrayMap<Pair<String, Uri>, Bundle>>>
+ mCache = new SparseArray<>();
+
+ private BroadcastReceiver mCacheReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ final Uri data = intent.getData();
+ if (data != null) {
+ final int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE,
+ UserHandle.USER_NULL);
+ final String packageName = data.getSchemeSpecificPart();
+ invalidateCacheLocked(userId, packageName, null);
+ }
+ }
+ };
+
private SyncManager getSyncManager() {
if (SystemProperties.getBoolean("config.disable_network", false)) {
return null;
@@ -85,13 +124,15 @@
}
@Override
- protected synchronized void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+ protected synchronized void dump(FileDescriptor fd, PrintWriter pw_, String[] args) {
mContext.enforceCallingOrSelfPermission(Manifest.permission.DUMP,
"caller doesn't have the DUMP permission");
+ final IndentingPrintWriter pw = new IndentingPrintWriter(pw_, " ");
+
// This makes it so that future permission checks will be in the context of this
// process rather than the caller's process. We will restore this before returning.
- long identityToken = clearCallingIdentity();
+ final long identityToken = clearCallingIdentity();
try {
if (mSyncManager == null) {
pw.println("No SyncManager created! (Disk full?)");
@@ -132,6 +173,19 @@
pw.print(" Total number of nodes: "); pw.println(counts[0]);
pw.print(" Total number of observers: "); pw.println(counts[1]);
}
+
+ synchronized (mCache) {
+ pw.println();
+ pw.println("Cached content:");
+ pw.increaseIndent();
+ for (int i = 0; i < mCache.size(); i++) {
+ pw.println("User " + mCache.keyAt(i) + ":");
+ pw.increaseIndent();
+ pw.println(mCache.valueAt(i));
+ pw.decreaseIndent();
+ }
+ pw.decreaseIndent();
+ }
} finally {
restoreCallingIdentity(identityToken);
}
@@ -167,6 +221,15 @@
return getSyncAdapterPackagesForAuthorityAsUser(authority, userId);
}
});
+
+ final IntentFilter packageFilter = new IntentFilter();
+ packageFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
+ packageFilter.addAction(Intent.ACTION_PACKAGE_CHANGED);
+ packageFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
+ packageFilter.addAction(Intent.ACTION_PACKAGE_DATA_CLEARED);
+ packageFilter.addDataScheme("package");
+ mContext.registerReceiverAsUser(mCacheReceiver, UserHandle.ALL,
+ packageFilter, null, null);
}
public void systemReady() {
@@ -312,6 +375,11 @@
uri.getAuthority());
}
}
+
+ synchronized (mCache) {
+ final String providerPackageName = getProviderPackageName(uri);
+ invalidateCacheLocked(userHandle, providerPackageName, uri);
+ }
} finally {
restoreCallingIdentity(identityToken);
}
@@ -915,6 +983,86 @@
}
}
+ private @Nullable String getProviderPackageName(Uri uri) {
+ final ProviderInfo pi = mContext.getPackageManager()
+ .resolveContentProvider(uri.getAuthority(), 0);
+ return (pi != null) ? pi.packageName : null;
+ }
+
+ private ArrayMap<Pair<String, Uri>, Bundle> findOrCreateCacheLocked(int userId,
+ String providerPackageName) {
+ ArrayMap<String, ArrayMap<Pair<String, Uri>, Bundle>> userCache = mCache.get(userId);
+ if (userCache == null) {
+ userCache = new ArrayMap<>();
+ mCache.put(userId, userCache);
+ }
+ ArrayMap<Pair<String, Uri>, Bundle> packageCache = userCache.get(providerPackageName);
+ if (packageCache == null) {
+ packageCache = new ArrayMap<>();
+ userCache.put(providerPackageName, packageCache);
+ }
+ return packageCache;
+ }
+
+ private void invalidateCacheLocked(int userId, String providerPackageName, Uri uri) {
+ ArrayMap<String, ArrayMap<Pair<String, Uri>, Bundle>> userCache = mCache.get(userId);
+ if (userCache == null) return;
+
+ ArrayMap<Pair<String, Uri>, Bundle> packageCache = userCache.get(providerPackageName);
+ if (packageCache == null) return;
+
+ if (uri != null) {
+ for (int i = 0; i < packageCache.size();) {
+ final Uri key = packageCache.keyAt(i).second;
+ if (Objects.equals(key, uri)) {
+ packageCache.removeAt(i);
+ } else {
+ i++;
+ }
+ }
+ } else {
+ packageCache.clear();
+ }
+ }
+
+ @Override
+ public void putCache(String packageName, Uri key, Bundle value, int userId) {
+ enforceCrossUserPermission(userId, TAG);
+ mContext.enforceCallingOrSelfPermission(android.Manifest.permission.CACHE_CONTENT, TAG);
+ mContext.getSystemService(AppOpsManager.class).checkPackage(Binder.getCallingUid(),
+ packageName);
+
+ final String providerPackageName = getProviderPackageName(key);
+ final Pair<String, Uri> fullKey = Pair.create(packageName, key);
+
+ synchronized (mCache) {
+ final ArrayMap<Pair<String, Uri>, Bundle> cache = findOrCreateCacheLocked(userId,
+ providerPackageName);
+ if (value != null) {
+ cache.put(fullKey, value);
+ } else {
+ cache.remove(fullKey);
+ }
+ }
+ }
+
+ @Override
+ public Bundle getCache(String packageName, Uri key, int userId) {
+ enforceCrossUserPermission(userId, TAG);
+ mContext.enforceCallingOrSelfPermission(android.Manifest.permission.CACHE_CONTENT, TAG);
+ mContext.getSystemService(AppOpsManager.class).checkPackage(Binder.getCallingUid(),
+ packageName);
+
+ final String providerPackageName = getProviderPackageName(key);
+ final Pair<String, Uri> fullKey = Pair.create(packageName, key);
+
+ synchronized (mCache) {
+ final ArrayMap<Pair<String, Uri>, Bundle> cache = findOrCreateCacheLocked(userId,
+ providerPackageName);
+ return cache.get(fullKey);
+ }
+ }
+
public static ContentService main(Context context, boolean factoryTest) {
ContentService service = new ContentService(context, factoryTest);
ServiceManager.addService(ContentResolver.CONTENT_SERVICE_NAME, service);