diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index f8856ae..ccf18b8 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -122,6 +122,7 @@
                 <action android:name="android.intent.action.MANAGE_APP_PERMISSION" />
                 <action android:name="android.intent.action.MANAGE_PERMISSION_APPS" />
                 <action android:name="android.intent.action.MANAGE_PERMISSIONS" />
+                <action android:name="android.intent.action.REVIEW_PERMISSION_USAGE" />
                 <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
         </activity>
@@ -132,6 +133,7 @@
                   android:theme="@android:style/Theme.NoDisplay">
             <intent-filter android:priority="1">
                 <action android:name="com.android.permissioncontroller.settingssearch.action.MANAGE_PERMISSION_APPS" />
+                <action android:name="com.android.permissioncontroller.settingssearch.action.REVIEW_PERMISSION_USAGE" />
                 <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
         </activity>
@@ -160,6 +162,17 @@
                   android:excludeFromRecents="true"
                   android:theme="@style/PermissionDialog.FilterTouches" />
 
+        <activity android:name="com.android.permissioncontroller.permission.debug.ReviewOngoingUsageActivity"
+                  android:excludeFromRecents="true"
+                  android:theme="@style/PermissionDialog"
+                  android:launchMode="singleInstance"
+                  android:permission="android.permission.GRANT_RUNTIME_PERMISSIONS" >
+            <intent-filter android:priority="1">
+                <action android:name="android.intent.action.REVIEW_ONGOING_PERMISSION_USAGE" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+
         <activity android:name="com.android.permissioncontroller.permission.ui.ReviewAccessibilityServicesActivity"
                   android:excludeFromRecents="true"
                   android:theme="@style/PermissionDialog.FilterTouches"
diff --git a/res/layout/ongoing_usage_dialog_content.xml b/res/layout/ongoing_usage_dialog_content.xml
new file mode 100644
index 0000000..219b4f9
--- /dev/null
+++ b/res/layout/ongoing_usage_dialog_content.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2019 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.
+-->
+
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+            android:id="@+id/container"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            style="@style/PermissionUsageDialogContainerScrollView">
+
+    <LinearLayout
+        android:id="@+id/dialog_container"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        style="@style/PermissionUsageDialogContainerLayout">
+
+        <TextView
+            android:id="@+id/title"
+            style="@style/PermissionUsageDialogTitle"/>
+
+        <LinearLayout
+            android:id="@+id/items_container"
+            style="@style/PermissionUsageDialogItemsContainer"/>
+
+    </LinearLayout>
+
+</ScrollView>
diff --git a/res/layout/ongoing_usage_dialog_item.xml b/res/layout/ongoing_usage_dialog_item.xml
new file mode 100644
index 0000000..37ab9b4
--- /dev/null
+++ b/res/layout/ongoing_usage_dialog_item.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2020 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.
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              style="@style/PermissionUsageDialogItemContainer">
+
+    <FrameLayout
+        style="@style/PermissionUsageDialogItemIconFrame">
+
+        <ImageView
+            android:id="@+id/app_icon"
+            style="@style/PermissionUsageDialogItemIcon"/>
+
+    </FrameLayout>
+
+    <TextView
+        android:id="@+id/app_name"
+        style="@style/PermissionUsageDialogItemAppName"/>
+
+    <LinearLayout
+        android:id="@+id/icons"
+        style="@style/PermissionUsageDialogItemIconsContainer"/>
+
+</LinearLayout>
\ No newline at end of file
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 9180ca9..a0ad216 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -740,6 +740,21 @@
     <!-- Label for the button to set an application as the default application [CHAR LIMIT=20] -->
     <string name="request_role_set_as_default">Set as default</string>
 
+    <!-- Action for accepting the Ongoing usage dialog [CHAR LIMIT=10]-->
+    <string name="ongoing_usage_dialog_ok">Got it</string>
+
+    <!-- Action on Ongoing usage dialog to open the Privacy settings. [CHAR LIMIT=23]-->
+    <string name="ongoing_usage_dialog_open_settings">Privacy settings</string>
+
+    <!-- Title for Ongoing usage dialog title when multiple apps are using app ops [CHAR LIMIT=NONE] -->
+    <string name="ongoing_usage_dialog_title">Apps using your <xliff:g id="types_list" example="camera( and location)">%s</xliff:g></string>
+
+    <!-- Separator for permissions. Include spaces before and after if needed [CHAR LIMIT=10] -->
+    <string name="ongoing_usage_dialog_separator">,\u0020</string>
+
+    <!-- Separator for permissions, before last type. Include spaces before and after if needed [CHAR LIMIT=10] -->
+    <string name="ongoing_usage_dialog_last_separator">\u0020and\u0020</string>
+
     <!-- Keyword in the Settings app's search functionality that can be used to find links to the default app management screens [CHAR LIMIT=none] -->
     <string name="default_app_search_keyword">default apps</string>
 
diff --git a/src/com/android/permissioncontroller/permission/debug/AppPermissionUsage.java b/src/com/android/permissioncontroller/permission/debug/AppPermissionUsage.java
new file mode 100644
index 0000000..e168ee8
--- /dev/null
+++ b/src/com/android/permissioncontroller/permission/debug/AppPermissionUsage.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright (C) 2020 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.permissioncontroller.permission.debug;
+
+import android.app.AppOpsManager;
+import android.app.AppOpsManager.HistoricalOp;
+import android.app.AppOpsManager.HistoricalPackageOps;
+import android.app.AppOpsManager.OpEntry;
+import android.app.AppOpsManager.PackageOps;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.android.permissioncontroller.permission.model.AppPermissionGroup;
+import com.android.permissioncontroller.permission.model.Permission;
+import com.android.permissioncontroller.permission.model.legacy.PermissionApps.PermissionApp;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+/**
+ * Stats for permission usage of an app. This data is for a given time period,
+ * i.e. does not contain the full history.
+ */
+public final class AppPermissionUsage {
+    private final @NonNull List<GroupUsage> mGroupUsages = new ArrayList<>();
+    private final @NonNull PermissionApp mPermissionApp;
+
+    private AppPermissionUsage(@NonNull PermissionApp permissionApp,
+            @NonNull List<AppPermissionGroup> groups, @Nullable PackageOps lastUsage,
+            @Nullable HistoricalPackageOps historicalUsage) {
+        mPermissionApp = permissionApp;
+        final int groupCount = groups.size();
+        for (int i = 0; i < groupCount; i++) {
+            final AppPermissionGroup group = groups.get(i);
+            mGroupUsages.add(new GroupUsage(group, lastUsage, historicalUsage));
+        }
+    }
+
+    public @NonNull PermissionApp getApp() {
+        return mPermissionApp;
+    }
+
+    public @NonNull String getPackageName() {
+        return mPermissionApp.getPackageName();
+    }
+
+    public int getUid() {
+        return mPermissionApp.getUid();
+    }
+
+    public long getLastAccessTime() {
+        long lastAccessTime = 0;
+        final int permissionCount = mGroupUsages.size();
+        for (int i = 0; i < permissionCount; i++) {
+            final GroupUsage groupUsage = mGroupUsages.get(i);
+            lastAccessTime = Math.max(lastAccessTime, groupUsage.getLastAccessTime());
+        }
+        return lastAccessTime;
+    }
+
+    public long getAccessCount() {
+        long accessCount = 0;
+        final int permissionCount = mGroupUsages.size();
+        for (int i = 0; i < permissionCount; i++) {
+            final GroupUsage permission = mGroupUsages.get(i);
+            accessCount += permission.getAccessCount();
+        }
+        return accessCount;
+    }
+
+    public @NonNull List<GroupUsage> getGroupUsages() {
+        return mGroupUsages;
+    }
+
+    /**
+     * Stats for permission usage of a permission group. This data is for a
+     * given time period, i.e. does not contain the full history.
+     */
+    public static class GroupUsage {
+        private final @NonNull AppPermissionGroup mGroup;
+        private final @Nullable PackageOps mLastUsage;
+        private final @Nullable HistoricalPackageOps mHistoricalUsage;
+
+        GroupUsage(@NonNull AppPermissionGroup group, @Nullable PackageOps lastUsage,
+                @Nullable HistoricalPackageOps historicalUsage) {
+            mGroup = group;
+            mLastUsage = lastUsage;
+            mHistoricalUsage = historicalUsage;
+        }
+
+        public long getLastAccessTime() {
+            if (mLastUsage == null) {
+                return 0;
+            }
+            return lastAccessAggregate(
+                    (op) -> op.getLastAccessTime(AppOpsManager.OP_FLAGS_ALL_TRUSTED));
+        }
+
+        public long getLastAccessForegroundTime() {
+            if (mLastUsage == null) {
+                return 0;
+            }
+            return lastAccessAggregate(
+                    (op) -> op.getLastAccessForegroundTime(AppOpsManager.OP_FLAGS_ALL_TRUSTED));
+        }
+
+        public long getLastAccessBackgroundTime() {
+            if (mLastUsage == null) {
+                return 0;
+            }
+            return lastAccessAggregate(
+                    (op) -> op.getLastAccessBackgroundTime(AppOpsManager.OP_FLAGS_ALL_TRUSTED));
+        }
+
+        public long getForegroundAccessCount() {
+            if (mHistoricalUsage == null) {
+                return 0;
+            }
+            return extractAggregate((HistoricalOp op)
+                    -> op.getForegroundAccessCount(AppOpsManager.OP_FLAGS_ALL_TRUSTED));
+        }
+
+        public long getBackgroundAccessCount() {
+            if (mHistoricalUsage == null) {
+                return 0;
+            }
+            return extractAggregate((HistoricalOp op)
+                    -> op.getBackgroundAccessCount(AppOpsManager.OP_FLAGS_ALL_TRUSTED));
+        }
+
+        public long getAccessCount() {
+            if (mHistoricalUsage == null) {
+                return 0;
+            }
+            return extractAggregate((HistoricalOp op) ->
+                    op.getForegroundAccessCount(AppOpsManager.OP_FLAGS_ALL_TRUSTED)
+                            + op.getBackgroundAccessCount(AppOpsManager.OP_FLAGS_ALL_TRUSTED)
+            );
+        }
+
+        public long getAccessDuration() {
+            if (mHistoricalUsage == null) {
+                return 0;
+            }
+            return extractAggregate((HistoricalOp op) ->
+                    op.getForegroundAccessDuration(AppOpsManager.OP_FLAGS_ALL_TRUSTED)
+                            + op.getBackgroundAccessDuration(AppOpsManager.OP_FLAGS_ALL_TRUSTED)
+            );
+        }
+
+        public boolean isRunning() {
+            if (mLastUsage == null) {
+                return false;
+            }
+            final ArrayList<Permission> permissions = mGroup.getPermissions();
+            final int permissionCount = permissions.size();
+            for (int i = 0; i < permissionCount; i++) {
+                final Permission permission = permissions.get(i);
+                final String opName = permission.getAppOp();
+                final List<OpEntry> ops = mLastUsage.getOps();
+                final int opCount = ops.size();
+                for (int j = 0; j < opCount; j++) {
+                    final OpEntry op = ops.get(j);
+                    if (op.getOpStr().equals(opName) && op.isRunning()) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        private long extractAggregate(@NonNull Function<HistoricalOp, Long> extractor) {
+            long aggregate = 0;
+            final ArrayList<Permission> permissions = mGroup.getPermissions();
+            final int permissionCount = permissions.size();
+            for (int i = 0; i < permissionCount; i++) {
+                final Permission permission = permissions.get(i);
+                final String opName = permission.getAppOp();
+                final HistoricalOp historicalOp = mHistoricalUsage.getOp(opName);
+                if (historicalOp != null) {
+                    aggregate += extractor.apply(historicalOp);
+                }
+            }
+            return aggregate;
+        }
+
+        private long lastAccessAggregate(@NonNull Function<OpEntry, Long> extractor) {
+            long aggregate = 0;
+            final ArrayList<Permission> permissions = mGroup.getPermissions();
+            final int permissionCount = permissions.size();
+            for (int permissionNum = 0; permissionNum < permissionCount; permissionNum++) {
+                final Permission permission = permissions.get(permissionNum);
+                final String opName = permission.getAppOp();
+                final List<OpEntry> ops = mLastUsage.getOps();
+                final int opCount = ops.size();
+                for (int opNum = 0; opNum < opCount; opNum++) {
+                    final OpEntry op = ops.get(opNum);
+                    if (op.getOpStr().equals(opName)) {
+                        aggregate = Math.max(aggregate, extractor.apply(op));
+                    }
+                }
+            }
+            return aggregate;
+        }
+
+        public @NonNull AppPermissionGroup getGroup() {
+            return mGroup;
+        }
+    }
+
+    public static class Builder {
+        private final @NonNull List<AppPermissionGroup> mGroups = new ArrayList<>();
+        private final @NonNull PermissionApp mPermissionApp;
+        private @Nullable PackageOps mLastUsage;
+        private @Nullable HistoricalPackageOps mHistoricalUsage;
+
+        public Builder(@NonNull PermissionApp permissionApp) {
+            mPermissionApp = permissionApp;
+        }
+
+        public @NonNull Builder addGroup(@NonNull AppPermissionGroup group) {
+            mGroups.add(group);
+            return this;
+        }
+
+        public @NonNull Builder setLastUsage(@Nullable PackageOps lastUsage) {
+            mLastUsage = lastUsage;
+            return this;
+        }
+
+        public @NonNull Builder setHistoricalUsage(@Nullable HistoricalPackageOps historicalUsage) {
+            mHistoricalUsage = historicalUsage;
+            return this;
+        }
+
+        public @NonNull AppPermissionUsage build() {
+            if (mGroups.isEmpty()) {
+                throw new IllegalStateException("mGroups cannot be empty.");
+            }
+            return new AppPermissionUsage(mPermissionApp, mGroups, mLastUsage, mHistoricalUsage);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/permissioncontroller/permission/debug/PermissionUsages.java b/src/com/android/permissioncontroller/permission/debug/PermissionUsages.java
new file mode 100644
index 0000000..d45164e
--- /dev/null
+++ b/src/com/android/permissioncontroller/permission/debug/PermissionUsages.java
@@ -0,0 +1,342 @@
+/*
+ * Copyright (C) 2020 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.permissioncontroller.permission.debug;
+
+import android.app.AppOpsManager;
+import android.app.AppOpsManager.HistoricalOps;
+import android.app.AppOpsManager.HistoricalOpsRequest;
+import android.app.AppOpsManager.HistoricalPackageOps;
+import android.app.AppOpsManager.HistoricalUidOps;
+import android.app.AppOpsManager.PackageOps;
+import android.app.LoaderManager;
+import android.app.LoaderManager.LoaderCallbacks;
+import android.content.AsyncTaskLoader;
+import android.content.Context;
+import android.content.Loader;
+import android.os.Bundle;
+import android.os.Process;
+import android.util.ArrayMap;
+import android.util.ArraySet;
+import android.util.Pair;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.android.permissioncontroller.permission.debug.AppPermissionUsage.Builder;
+import com.android.permissioncontroller.permission.model.AppPermissionGroup;
+import com.android.permissioncontroller.permission.model.Permission;
+import com.android.permissioncontroller.permission.model.legacy.PermissionApps.PermissionApp;
+import com.android.permissioncontroller.permission.model.legacy.PermissionGroup;
+import com.android.permissioncontroller.permission.model.legacy.PermissionGroups;
+import com.android.permissioncontroller.permission.utils.Utils;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Loads all permission usages for a set of apps and permission groups.
+ */
+public final class PermissionUsages implements LoaderCallbacks<List<AppPermissionUsage>> {
+    public static final int USAGE_FLAG_LAST = 1 << 0;
+    public static final int USAGE_FLAG_HISTORICAL = 1 << 2;
+
+    private final ArrayList<AppPermissionUsage> mUsages = new ArrayList<>();
+    private final @NonNull Context mContext;
+
+    private static final String KEY_FILTER_UID =  "KEY_FILTER_UID";
+    private static final String KEY_FILTER_PACKAGE_NAME =  "KEY_FILTER_PACKAGE_NAME";
+    private static final String KEY_FILTER_PERMISSION_GROUP =  "KEY_FILTER_PERMISSION_GROUP";
+    private static final String KEY_FILTER_BEGIN_TIME_MILLIS =  "KEY_FILTER_BEGIN_TIME_MILLIS";
+    private static final String KEY_FILTER_END_TIME_MILLIS =  "KEY_FILTER_END_TIME_MILLIS";
+    private static final String KEY_USAGE_FLAGS =  "KEY_USAGE_FLAGS";
+    private static final String KEY_GET_UI_INFO =  "KEY_GET_UI_INFO";
+    private static final String KEY_GET_NON_PLATFORM_PERMISSIONS =
+            "KEY_GET_NON_PLATFORM_PERMISSIONS";
+
+    private @Nullable PermissionsUsagesChangeCallback mCallback;
+
+    public interface PermissionsUsagesChangeCallback {
+        void onPermissionUsagesChanged();
+    }
+
+    public PermissionUsages(@NonNull Context context) {
+        mContext = context;
+    }
+
+    public void load(@Nullable String filterPackageName,
+            @Nullable String[] filterPermissionGroups, long filterBeginTimeMillis,
+            long filterEndTimeMillis, int usageFlags, @NonNull LoaderManager loaderManager,
+            boolean getUiInfo, boolean getNonPlatformPermissions,
+            @NonNull PermissionsUsagesChangeCallback callback, boolean sync) {
+        load(Process.INVALID_UID, filterPackageName, filterPermissionGroups, filterBeginTimeMillis,
+                filterEndTimeMillis, usageFlags, loaderManager, getUiInfo,
+                getNonPlatformPermissions, callback, sync);
+    }
+
+    public void load(int filterUid, @Nullable String filterPackageName,
+            @Nullable String[] filterPermissionGroups, long filterBeginTimeMillis,
+            long filterEndTimeMillis, int usageFlags, @NonNull LoaderManager loaderManager,
+            boolean getUiInfo, boolean getNonPlatformPermissions,
+            @NonNull PermissionsUsagesChangeCallback callback, boolean sync) {
+        mCallback = callback;
+        final Bundle args = new Bundle();
+        args.putInt(KEY_FILTER_UID, filterUid);
+        args.putString(KEY_FILTER_PACKAGE_NAME, filterPackageName);
+        args.putStringArray(KEY_FILTER_PERMISSION_GROUP, filterPermissionGroups);
+        args.putLong(KEY_FILTER_BEGIN_TIME_MILLIS, filterBeginTimeMillis);
+        args.putLong(KEY_FILTER_END_TIME_MILLIS, filterEndTimeMillis);
+        args.putInt(KEY_USAGE_FLAGS, usageFlags);
+        args.putBoolean(KEY_GET_UI_INFO, getUiInfo);
+        args.putBoolean(KEY_GET_NON_PLATFORM_PERMISSIONS, getNonPlatformPermissions);
+        if (sync) {
+            final UsageLoader loader = new UsageLoader(mContext, args);
+            final List<AppPermissionUsage> usages = loader.loadInBackground();
+            onLoadFinished(loader, usages);
+        } else {
+            loaderManager.restartLoader(1, args, this);
+        }
+    }
+
+    @Override
+    public Loader<List<AppPermissionUsage>> onCreateLoader(int id, Bundle args) {
+        return new UsageLoader(mContext, args);
+    }
+
+    @Override
+    public void onLoadFinished(@NonNull Loader<List<AppPermissionUsage>> loader,
+            List<AppPermissionUsage> usages) {
+        mUsages.clear();
+        mUsages.addAll(usages);
+        if (mCallback != null) {
+            mCallback.onPermissionUsagesChanged();
+        }
+    }
+
+    @Override
+    public void onLoaderReset(@NonNull Loader<List<AppPermissionUsage>> loader) {
+        mUsages.clear();
+        mCallback.onPermissionUsagesChanged();
+    }
+
+    public @NonNull List<AppPermissionUsage> getUsages() {
+        return mUsages;
+    }
+
+    public void stopLoader(@NonNull LoaderManager loaderManager) {
+        loaderManager.destroyLoader(1);
+    }
+
+    public static @Nullable AppPermissionUsage.GroupUsage loadLastGroupUsage(
+            @NonNull Context context, @NonNull AppPermissionGroup group) {
+        final ArraySet<String> opNames = new ArraySet<>();
+        final List<Permission> permissions = group.getPermissions();
+        final int permCount = permissions.size();
+        for (int i = 0; i < permCount; i++) {
+            final Permission permission = permissions.get(i);
+            final String opName = permission.getAppOp();
+            if (opName != null) {
+                opNames.add(opName);
+            }
+        }
+        final String[] opNamesArray = opNames.toArray(new String[opNames.size()]);
+        final List<PackageOps> usageOps = context.getSystemService(AppOpsManager.class)
+                .getOpsForPackage(group.getApp().applicationInfo.uid,
+                        group.getApp().packageName, opNamesArray);
+        if (usageOps == null || usageOps.isEmpty()) {
+            return null;
+        }
+        return new AppPermissionUsage.GroupUsage(group, usageOps.get(0), null);
+    }
+
+    private static final class UsageLoader extends AsyncTaskLoader<List<AppPermissionUsage>> {
+        private final int mFilterUid;
+        private @Nullable String mFilterPackageName;
+        private @Nullable String[] mFilterPermissionGroups;
+        private final long mFilterBeginTimeMillis;
+        private final long mFilterEndTimeMillis;
+        private final int mUsageFlags;
+        private final boolean mGetUiInfo;
+        private final boolean mGetNonPlatformPermissions;
+
+        UsageLoader(@NonNull Context context, @NonNull Bundle args) {
+            super(context);
+            mFilterUid = args.getInt(KEY_FILTER_UID);
+            mFilterPackageName = args.getString(KEY_FILTER_PACKAGE_NAME);
+            mFilterPermissionGroups = args.getStringArray(KEY_FILTER_PERMISSION_GROUP);
+            mFilterBeginTimeMillis = args.getLong(KEY_FILTER_BEGIN_TIME_MILLIS);
+            mFilterEndTimeMillis = args.getLong(KEY_FILTER_END_TIME_MILLIS);
+            mUsageFlags = args.getInt(KEY_USAGE_FLAGS);
+            mGetUiInfo = args.getBoolean(KEY_GET_UI_INFO);
+            mGetNonPlatformPermissions = args.getBoolean(KEY_GET_NON_PLATFORM_PERMISSIONS);
+        }
+
+        @Override
+        protected void onStartLoading() {
+            forceLoad();
+        }
+
+        @Override
+        public @NonNull List<AppPermissionUsage> loadInBackground() {
+            final List<PermissionGroup> groups = PermissionGroups.getPermissionGroups(
+                    getContext(), this::isLoadInBackgroundCanceled, mGetUiInfo,
+                    mGetNonPlatformPermissions, mFilterPermissionGroups, mFilterPackageName);
+            if (!Utils.isPermissionUsageIconEnabled()) {
+                return Collections.emptyList();
+            }
+
+            if (groups.isEmpty()) {
+                return Collections.emptyList();
+            }
+
+            final List<AppPermissionUsage> usages = new ArrayList<>();
+            final ArraySet<String> opNames = new ArraySet<>();
+            final ArrayMap<Pair<Integer, String>, AppPermissionUsage.Builder> usageBuilders =
+                    new ArrayMap<>();
+
+            final int groupCount = groups.size();
+            for (int groupIdx = 0; groupIdx < groupCount; groupIdx++) {
+                final PermissionGroup group = groups.get(groupIdx);
+                // Filter out third party permissions
+                if (!group.getDeclaringPackage().equals(Utils.OS_PKG)) {
+                    continue;
+                }
+
+                groups.add(group);
+
+                final List<PermissionApp> permissionApps = group.getPermissionApps().getApps();
+                final int appCount = permissionApps.size();
+                for (int appIdx = 0; appIdx < appCount; appIdx++) {
+                    final PermissionApp permissionApp = permissionApps.get(appIdx);
+                    if (mFilterUid != Process.INVALID_UID
+                            && permissionApp.getAppInfo().uid != mFilterUid) {
+                        continue;
+                    }
+
+                    final AppPermissionGroup appPermGroup = permissionApp.getPermissionGroup();
+                    if (!Utils.shouldShowPermission(getContext(), appPermGroup)) {
+                        continue;
+                    }
+                    final Pair<Integer, String> usageKey = Pair.create(permissionApp.getUid(),
+                            permissionApp.getPackageName());
+                    AppPermissionUsage.Builder usageBuilder = usageBuilders.get(usageKey);
+                    if (usageBuilder == null) {
+                        usageBuilder = new Builder(permissionApp);
+                        usageBuilders.put(usageKey, usageBuilder);
+                    }
+                    usageBuilder.addGroup(appPermGroup);
+                    final List<Permission> permissions = appPermGroup.getPermissions();
+                    final int permCount = permissions.size();
+                    for (int permIdx = 0; permIdx < permCount; permIdx++) {
+                        final Permission permission = permissions.get(permIdx);
+                        final String opName = permission.getAppOp();
+                        if (opName != null) {
+                            opNames.add(opName);
+                        }
+                    }
+                }
+            }
+
+            if (usageBuilders.isEmpty()) {
+                return Collections.emptyList();
+            }
+
+            final AppOpsManager appOpsManager = getContext().getSystemService(AppOpsManager.class);
+
+            // Get last usage data and put in a map for a quick lookup.
+            final ArrayMap<Pair<Integer, String>, PackageOps> lastUsages =
+                    new ArrayMap<>(usageBuilders.size());
+            final String[] opNamesArray = opNames.toArray(new String[opNames.size()]);
+            if ((mUsageFlags & USAGE_FLAG_LAST) != 0) {
+                final List<PackageOps> usageOps;
+                if (mFilterPackageName != null || mFilterUid != Process.INVALID_UID) {
+                    usageOps = appOpsManager.getOpsForPackage(mFilterUid, mFilterPackageName,
+                            opNamesArray);
+                } else {
+                    usageOps = appOpsManager.getPackagesForOps(opNamesArray);
+                }
+                if (usageOps != null && !usageOps.isEmpty()) {
+                    final int usageOpsCount = usageOps.size();
+                    for (int i = 0; i < usageOpsCount; i++) {
+                        final PackageOps usageOp = usageOps.get(i);
+                        lastUsages.put(Pair.create(usageOp.getUid(), usageOp.getPackageName()),
+                                usageOp);
+                    }
+                }
+            }
+
+            if (isLoadInBackgroundCanceled()) {
+                return Collections.emptyList();
+            }
+
+            // Get historical usage data and put in a map for a quick lookup
+            final ArrayMap<Pair<Integer, String>, HistoricalPackageOps> historicalUsages =
+                    new ArrayMap<>(usageBuilders.size());
+            if ((mUsageFlags & USAGE_FLAG_HISTORICAL) != 0) {
+                final AtomicReference<HistoricalOps> historicalOpsRef = new AtomicReference<>();
+                final CountDownLatch latch = new CountDownLatch(1);
+                final HistoricalOpsRequest request = new HistoricalOpsRequest.Builder(
+                        mFilterBeginTimeMillis, mFilterEndTimeMillis)
+                        .setUid(mFilterUid)
+                        .setPackageName(mFilterPackageName)
+                        .setOpNames(new ArrayList<>(opNames))
+                        .setFlags(AppOpsManager.OP_FLAGS_ALL_TRUSTED)
+                        .build();
+                appOpsManager.getHistoricalOps(request, Runnable::run,
+                        (HistoricalOps ops) -> {
+                            historicalOpsRef.set(ops);
+                            latch.countDown();
+                        });
+                try {
+                    latch.await(5, TimeUnit.DAYS);
+                } catch (InterruptedException ignored) { }
+
+                final HistoricalOps historicalOps = historicalOpsRef.get();
+                if (historicalOps != null) {
+                    final int uidCount = historicalOps.getUidCount();
+                    for (int i = 0; i < uidCount; i++) {
+                        final HistoricalUidOps uidOps = historicalOps.getUidOpsAt(i);
+                        final int packageCount = uidOps.getPackageCount();
+                        for (int j = 0; j < packageCount; j++) {
+                            final HistoricalPackageOps packageOps = uidOps.getPackageOpsAt(j);
+                            historicalUsages.put(
+                                    Pair.create(uidOps.getUid(), packageOps.getPackageName()),
+                                    packageOps);
+                        }
+                    }
+                }
+            }
+
+            // Construct the historical usages based on data we fetched
+            final int builderCount = usageBuilders.size();
+            for (int i = 0; i < builderCount; i++) {
+                final Pair<Integer, String> key = usageBuilders.keyAt(i);
+                final Builder usageBuilder = usageBuilders.valueAt(i);
+                final PackageOps lastUsage = lastUsages.get(key);
+                usageBuilder.setLastUsage(lastUsage);
+                final HistoricalPackageOps historicalUsage = historicalUsages.get(key);
+                usageBuilder.setHistoricalUsage(historicalUsage);
+                usages.add(usageBuilder.build());
+            }
+
+            return usages;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/permissioncontroller/permission/debug/ReviewOngoingUsageActivity.java b/src/com/android/permissioncontroller/permission/debug/ReviewOngoingUsageActivity.java
new file mode 100644
index 0000000..c48b10f
--- /dev/null
+++ b/src/com/android/permissioncontroller/permission/debug/ReviewOngoingUsageActivity.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2020 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.permissioncontroller.permission.debug;
+
+import static android.view.WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.MenuItem;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.FragmentActivity;
+
+import com.android.permissioncontroller.DeviceUtils;
+
+/**
+ * A dialog listing the currently uses of camera, microphone, and location.
+ */
+public final class ReviewOngoingUsageActivity extends FragmentActivity {
+
+    // Number of milliseconds in the past to look for accesses if nothing was specified.
+    private static final long DEFAULT_MILLIS = 5000;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        getWindow().addSystemFlags(SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS);
+
+        long numMillis = getIntent().getLongExtra(Intent.EXTRA_DURATION_MILLIS, DEFAULT_MILLIS);
+        getSupportFragmentManager().beginTransaction().replace(android.R.id.content,
+                ReviewOngoingUsageFragment.newInstance(numMillis)).commit();
+    }
+
+
+    @Override
+    public boolean onOptionsItemSelected(@NonNull MenuItem item) {
+        switch (item.getItemId()) {
+            case android.R.id.home:
+                // in automotive mode, there's no system wide back button, so need to add that
+                if (DeviceUtils.isAuto(this)) {
+                    onBackPressed();
+                } else {
+                    finish();
+                }
+                return true;
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/permissioncontroller/permission/debug/ReviewOngoingUsageFragment.java b/src/com/android/permissioncontroller/permission/debug/ReviewOngoingUsageFragment.java
new file mode 100644
index 0000000..0174ec4
--- /dev/null
+++ b/src/com/android/permissioncontroller/permission/debug/ReviewOngoingUsageFragment.java
@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2020 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.permissioncontroller.permission.debug;
+
+import static android.Manifest.permission_group.CAMERA;
+import static android.Manifest.permission_group.LOCATION;
+import static android.Manifest.permission_group.MICROPHONE;
+
+import static com.android.permissioncontroller.PermissionControllerStatsLog.PRIVACY_INDICATORS_INTERACTED;
+import static com.android.permissioncontroller.PermissionControllerStatsLog.PRIVACY_INDICATORS_INTERACTED__TYPE__DIALOG_DISMISS;
+import static com.android.permissioncontroller.PermissionControllerStatsLog.PRIVACY_INDICATORS_INTERACTED__TYPE__DIALOG_LINE_ITEM;
+import static com.android.permissioncontroller.PermissionControllerStatsLog.PRIVACY_INDICATORS_INTERACTED__TYPE__DIALOG_PRIVACY_SETTINGS;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.UserHandle;
+import android.provider.Settings;
+import android.util.ArraySet;
+import android.util.Pair;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.preference.PreferenceFragmentCompat;
+
+import com.android.permissioncontroller.PermissionControllerStatsLog;
+import com.android.permissioncontroller.R;
+import com.android.permissioncontroller.permission.debug.AppPermissionUsage.GroupUsage;
+import com.android.permissioncontroller.permission.model.legacy.PermissionApps;
+import com.android.permissioncontroller.permission.model.legacy.PermissionApps.PermissionApp;
+import com.android.permissioncontroller.permission.utils.Utils;
+
+import java.text.Collator;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A dialog listing the currently uses of camera, microphone, and location.
+ */
+public class ReviewOngoingUsageFragment extends PreferenceFragmentCompat {
+
+    private @NonNull PermissionUsages mPermissionUsages;
+    private @Nullable AlertDialog mDialog;
+    private long mStartTime;
+
+    /**
+     * @return A new {@link ReviewOngoingUsageFragment}
+     */
+    public static ReviewOngoingUsageFragment newInstance(long numMillis) {
+        ReviewOngoingUsageFragment fragment = new ReviewOngoingUsageFragment();
+        Bundle arguments = new Bundle();
+        arguments.putLong(Intent.EXTRA_DURATION_MILLIS, numMillis);
+        fragment.setArguments(arguments);
+        return fragment;
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        if (!Utils.isPermissionUsageIconEnabled()) {
+            getActivity().finish();
+            return;
+        }
+
+        long numMillis = getArguments().getLong(Intent.EXTRA_DURATION_MILLIS);
+
+        mPermissionUsages = new PermissionUsages(getActivity());
+        mStartTime = Math.max(System.currentTimeMillis() - numMillis, Instant.EPOCH.toEpochMilli());
+        mPermissionUsages.load(null, new String[]{CAMERA, LOCATION, MICROPHONE}, mStartTime,
+                Long.MAX_VALUE, PermissionUsages.USAGE_FLAG_LAST, getActivity().getLoaderManager(),
+                false, false, this::onPermissionUsagesLoaded, false);
+    }
+
+    private void onPermissionUsagesLoaded() {
+        if (getActivity() == null) {
+            return;
+        }
+
+        List<AppPermissionUsage> appPermissionUsages = mPermissionUsages.getUsages();
+
+        List<Pair<AppPermissionUsage, List<GroupUsage>>> usages = new ArrayList<>();
+        ArrayList<PermissionApp> permApps = new ArrayList<>();
+        int numApps = appPermissionUsages.size();
+        for (int appNum = 0; appNum < numApps; appNum++) {
+            AppPermissionUsage appUsage = appPermissionUsages.get(appNum);
+
+            List<GroupUsage> usedGroups = new ArrayList<>();
+            List<GroupUsage> appGroups = appUsage.getGroupUsages();
+            int numGroups = appGroups.size();
+            for (int groupNum = 0; groupNum < numGroups; groupNum++) {
+                GroupUsage groupUsage = appGroups.get(groupNum);
+                String groupName = groupUsage.getGroup().getName();
+
+                if (groupUsage.getLastAccessTime() < mStartTime && !groupUsage.isRunning()) {
+                    continue;
+                }
+                if (!Utils.isGroupOrBgGroupUserSensitive(groupUsage.getGroup())) {
+                    continue;
+                }
+
+                usedGroups.add(appGroups.get(groupNum));
+            }
+
+            if (!usedGroups.isEmpty()) {
+                usages.add(Pair.create(appUsage, usedGroups));
+                permApps.add(appUsage.getApp());
+            }
+        }
+
+        if (usages.isEmpty()) {
+            getActivity().finish();
+            return;
+        }
+
+        new PermissionApps.AppDataLoader(getActivity(), () -> showDialog(usages))
+                .execute(permApps.toArray(new PermissionApps.PermissionApp[permApps.size()]));
+    }
+
+    private void showDialog(@NonNull List<Pair<AppPermissionUsage, List<GroupUsage>>> usages) {
+        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity())
+                .setView(createDialogView(usages))
+                .setPositiveButton(R.string.ongoing_usage_dialog_ok, (dialog, which) ->
+                        PermissionControllerStatsLog.write(PRIVACY_INDICATORS_INTERACTED,
+                                PRIVACY_INDICATORS_INTERACTED__TYPE__DIALOG_DISMISS, null))
+                .setOnDismissListener((dialog) -> getActivity().finish());
+        setNeutralButton(builder);
+        mDialog = builder.create();
+        mDialog.show();
+    }
+
+    protected void setNeutralButton(AlertDialog.Builder builder) {
+        builder.setNeutralButton(R.string.ongoing_usage_dialog_open_settings, (dialog, which) -> {
+            PermissionControllerStatsLog.write(PRIVACY_INDICATORS_INTERACTED,
+                    PRIVACY_INDICATORS_INTERACTED__TYPE__DIALOG_PRIVACY_SETTINGS, null);
+            startActivity(new Intent(Settings.ACTION_PRIVACY_SETTINGS).putExtra(
+                    Intent.EXTRA_DURATION_MILLIS, TimeUnit.MINUTES.toMillis(1)));
+        });
+    }
+
+    private @NonNull View createDialogView(
+            @NonNull List<Pair<AppPermissionUsage, List<GroupUsage>>> usages) {
+        Context context = getActivity();
+        LayoutInflater inflater = LayoutInflater.from(context);
+        View contentView = inflater.inflate(R.layout.ongoing_usage_dialog_content, null);
+        ViewGroup appsList = contentView.requireViewById(R.id.items_container);
+
+        // Compute all of the permission group labels that were used.
+        ArraySet<String> usedGroups = new ArraySet<>();
+        int numUsages = usages.size();
+        for (int usageNum = 0; usageNum < numUsages; usageNum++) {
+            List<GroupUsage> groups = usages.get(usageNum).second;
+            int numGroups = groups.size();
+            for (int groupNum = 0; groupNum < numGroups; groupNum++) {
+                usedGroups.add(groups.get(groupNum).getGroup().getLabel().toString().toLowerCase());
+            }
+        }
+
+        // Add the layout for each app.
+        for (int usageNum = 0; usageNum < numUsages; usageNum++) {
+            Pair<AppPermissionUsage, List<GroupUsage>> usage = usages.get(usageNum);
+            PermissionApp app = usage.first.getApp();
+            List<GroupUsage> groups = usage.second;
+
+            View itemView = inflater.inflate(R.layout.ongoing_usage_dialog_item, appsList, false);
+
+            ((TextView) itemView.requireViewById(R.id.app_name)).setText(app.getLabel());
+            ((ImageView) itemView.requireViewById(R.id.app_icon)).setImageDrawable(app.getIcon());
+
+            // Add the icons for the groups this app used as long as multiple groups were used by
+            // some app.
+            if (usedGroups.size() > 1) {
+                ViewGroup iconFrame = itemView.requireViewById(R.id.icons);
+                int numGroups = usages.get(usageNum).second.size();
+                for (int groupNum = 0; groupNum < numGroups; groupNum++) {
+                    ViewGroup group = (ViewGroup) inflater.inflate(R.layout.image_view, null);
+                    ((ImageView) group.requireViewById(R.id.icon)).setImageDrawable(
+                            Utils.applyTint(context, groups.get(groupNum).getGroup().getIconResId(),
+                                    android.R.attr.colorControlNormal));
+                    iconFrame.addView(group);
+                }
+                iconFrame.setVisibility(View.VISIBLE);
+            }
+
+            itemView.setOnClickListener((v) -> {
+                String packageName = app.getPackageName();
+                PermissionControllerStatsLog.write(PRIVACY_INDICATORS_INTERACTED,
+                        PRIVACY_INDICATORS_INTERACTED__TYPE__DIALOG_LINE_ITEM, packageName);
+                UserHandle user = UserHandle.getUserHandleForUid(app.getUid());
+                Intent intent = new Intent(Intent.ACTION_MANAGE_APP_PERMISSIONS);
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
+                intent.putExtra(Intent.EXTRA_PACKAGE_NAME, packageName);
+                intent.putExtra(Intent.EXTRA_USER, user);
+                context.startActivity(intent);
+                mDialog.dismiss();
+            });
+
+            appsList.addView(itemView);
+        }
+
+        // Set the title of the dialog based on all of the permissions used.
+        StringBuilder titleBuilder = new StringBuilder();
+        int numGroups = usedGroups.size();
+        List<String> sortedGroups = new ArrayList<>(usedGroups);
+        Collator collator = Collator.getInstance(
+                getResources().getConfiguration().getLocales().get(0));
+        sortedGroups.sort(collator);
+        for (int i = 0; i < numGroups; i++) {
+            titleBuilder.append(sortedGroups.get(i));
+            if (i < numGroups - 2) {
+                titleBuilder.append(getString(R.string.ongoing_usage_dialog_separator));
+            } else if (i < numGroups - 1) {
+                titleBuilder.append(getString(R.string.ongoing_usage_dialog_last_separator));
+            }
+        }
+
+        ((TextView) contentView.requireViewById(R.id.title)).setText(
+                getString(R.string.ongoing_usage_dialog_title, titleBuilder.toString()));
+
+        return contentView;
+    }
+
+    @Override
+    public void onCreatePreferences(Bundle bundle, String s) {
+        // empty
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/permissioncontroller/permission/model/legacy/PermissionApps.java b/src/com/android/permissioncontroller/permission/model/legacy/PermissionApps.java
index e837ade..e493e08 100644
--- a/src/com/android/permissioncontroller/permission/model/legacy/PermissionApps.java
+++ b/src/com/android/permissioncontroller/permission/model/legacy/PermissionApps.java
@@ -421,6 +421,19 @@
             return mAppPermissionGroup;
         }
 
+        /**
+         * Load this app's label and icon if they were not previously loaded.
+         *
+         * @param appDataCache the cache of already-loaded labels and icons.
+         */
+        public void loadLabelAndIcon(@NonNull AppDataCache appDataCache) {
+            if (mInfo.packageName.equals(mLabel) || mIcon == null) {
+                Pair<String, Drawable> appData = appDataCache.getAppData(getUid(), mInfo);
+                mLabel = appData.first;
+                mIcon = appData.second;
+            }
+        }
+
         @Override
         public int compareTo(PermissionApp another) {
             final int result = mLabel.compareTo(another.mLabel);
@@ -520,4 +533,33 @@
     public interface Callback {
         void onPermissionsLoaded(PermissionApps permissionApps);
     }
+
+    /**
+     * Class used to asynchronously load apps' labels and icons.
+     */
+    public static class AppDataLoader extends AsyncTask<PermissionApp, Void, Void> {
+
+        private final Context mContext;
+        private final Runnable mCallback;
+
+        public AppDataLoader(Context context, Runnable callback) {
+            mContext = context;
+            mCallback = callback;
+        }
+
+        @Override
+        protected Void doInBackground(PermissionApp... args) {
+            AppDataCache appDataCache = new AppDataCache(mContext.getPackageManager(), mContext);
+            int numArgs = args.length;
+            for (int i = 0; i < numArgs; i++) {
+                args[i].loadLabelAndIcon(appDataCache);
+            }
+            return null;
+        }
+
+        @Override
+        protected void onPostExecute(Void result) {
+            mCallback.run();
+        }
+    }
 }
diff --git a/src/com/android/permissioncontroller/permission/model/legacy/PermissionGroup.java b/src/com/android/permissioncontroller/permission/model/legacy/PermissionGroup.java
index da1039d..6b951c9 100644
--- a/src/com/android/permissioncontroller/permission/model/legacy/PermissionGroup.java
+++ b/src/com/android/permissioncontroller/permission/model/legacy/PermissionGroup.java
@@ -78,6 +78,13 @@
         return mGranted;
     }
 
+    /**
+     * @return The PermissionApps object for this permission group.
+     */
+    public PermissionApps getPermissionApps() {
+        return mPermApps;
+    }
+
     @Override
     public int compareTo(PermissionGroup another) {
         return mLabel.toString().compareTo(another.mLabel.toString());
diff --git a/src/com/android/permissioncontroller/permission/utils/Utils.java b/src/com/android/permissioncontroller/permission/utils/Utils.java
index 65fdd59..01123ba 100644
--- a/src/com/android/permissioncontroller/permission/utils/Utils.java
+++ b/src/com/android/permissioncontroller/permission/utils/Utils.java
@@ -1141,4 +1141,15 @@
             return false;
         }
     }
+
+    /**
+     * Whether the Permissions Hub is enabled.
+     *
+     * @return whether the Permissions Hub is enabled.
+     */
+    public static boolean isPermissionUsageIconEnabled() {
+        return true;
+        //return DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_PRIVACY,
+        //        PROPERTY_PERMISSIONS_HUB_ENABLED, false);
+    }
 }