7076cbc015
Use startActivityAsUser instead of startActivity API to start the AppLocalePickerActivity of different users
Bug: 274378136
Test: 1. Perform AppLocalePickerActivityTest robolectric test
2. Perform the manual test by switching different users
3. Perform the manual test by switching different profiles
Change-Id: I0dfc40b29a7a35f18f6bcffd22fb421c6ad9c230
Merged-In: I4405b3b7e832b71b9ef66fa71d9e42ce12da167c
1784 lines
78 KiB
Java
1784 lines
78 KiB
Java
/*
|
|
* Copyright (C) 2006 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.settings.applications.manageapplications;
|
|
|
|
import static androidx.recyclerview.widget.RecyclerView.SCROLL_STATE_IDLE;
|
|
|
|
import static com.android.settings.ChangeIds.CHANGE_RESTRICT_SAW_INTENT;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_ALL;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_BATTERY_OPTIMIZED;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_BATTERY_RESTRICTED;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_BATTERY_UNRESTRICTED;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_BLOCKED;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_DISABLED;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_ENABLED;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_FREQUENT;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_INSTANT;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_PERSONAL;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_POWER_ALLOWLIST;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_POWER_ALLOWLIST_ALL;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_RECENT;
|
|
import static com.android.settings.applications.manageapplications.AppFilterRegistry.FILTER_APPS_WORK;
|
|
import static com.android.settings.search.actionbar.SearchMenuController.MENU_SEARCH;
|
|
|
|
import android.annotation.Nullable;
|
|
import android.annotation.StringRes;
|
|
import android.app.Activity;
|
|
import android.app.ActivityManager;
|
|
import android.app.settings.SettingsEnums;
|
|
import android.app.usage.IUsageStatsManager;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.pm.ApplicationInfo;
|
|
import android.content.pm.PackageItemInfo;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.net.Uri;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.os.Environment;
|
|
import android.os.IBinder;
|
|
import android.os.RemoteException;
|
|
import android.os.ServiceManager;
|
|
import android.os.UserHandle;
|
|
import android.os.UserManager;
|
|
import android.preference.PreferenceFrameLayout;
|
|
import android.text.TextUtils;
|
|
import android.util.ArraySet;
|
|
import android.util.IconDrawableFactory;
|
|
import android.util.Log;
|
|
import android.view.LayoutInflater;
|
|
import android.view.Menu;
|
|
import android.view.MenuInflater;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.AdapterView;
|
|
import android.widget.AdapterView.OnItemSelectedListener;
|
|
import android.widget.Filter;
|
|
import android.widget.FrameLayout;
|
|
import android.widget.SearchView;
|
|
import android.widget.Spinner;
|
|
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.VisibleForTesting;
|
|
import androidx.annotation.WorkerThread;
|
|
import androidx.coordinatorlayout.widget.CoordinatorLayout;
|
|
import androidx.core.view.ViewCompat;
|
|
import androidx.recyclerview.widget.LinearLayoutManager;
|
|
import androidx.recyclerview.widget.RecyclerView;
|
|
|
|
import com.android.internal.compat.IPlatformCompat;
|
|
import com.android.settings.R;
|
|
import com.android.settings.Settings;
|
|
import com.android.settings.Settings.GamesStorageActivity;
|
|
import com.android.settings.Settings.HighPowerApplicationsActivity;
|
|
import com.android.settings.Settings.ManageExternalSourcesActivity;
|
|
import com.android.settings.Settings.OverlaySettingsActivity;
|
|
import com.android.settings.Settings.StorageUseActivity;
|
|
import com.android.settings.Settings.UsageAccessSettingsActivity;
|
|
import com.android.settings.Settings.WriteSettingsActivity;
|
|
import com.android.settings.SettingsActivity;
|
|
import com.android.settings.Utils;
|
|
import com.android.settings.applications.AppInfoBase;
|
|
import com.android.settings.applications.AppStateAlarmsAndRemindersBridge;
|
|
import com.android.settings.applications.AppStateAppBatteryUsageBridge;
|
|
import com.android.settings.applications.AppStateAppOpsBridge.PermissionState;
|
|
import com.android.settings.applications.AppStateBaseBridge;
|
|
import com.android.settings.applications.AppStateInstallAppsBridge;
|
|
import com.android.settings.applications.AppStateLocaleBridge;
|
|
import com.android.settings.applications.AppStateManageExternalStorageBridge;
|
|
import com.android.settings.applications.AppStateMediaManagementAppsBridge;
|
|
import com.android.settings.applications.AppStateNotificationBridge;
|
|
import com.android.settings.applications.AppStateNotificationBridge.NotificationsSentState;
|
|
import com.android.settings.applications.AppStateOverlayBridge;
|
|
import com.android.settings.applications.AppStatePowerBridge;
|
|
import com.android.settings.applications.AppStateUsageBridge;
|
|
import com.android.settings.applications.AppStateUsageBridge.UsageState;
|
|
import com.android.settings.applications.AppStateWriteSettingsBridge;
|
|
import com.android.settings.applications.AppStorageSettings;
|
|
import com.android.settings.applications.UsageAccessDetails;
|
|
import com.android.settings.applications.appinfo.AlarmsAndRemindersDetails;
|
|
import com.android.settings.applications.appinfo.AppInfoDashboardFragment;
|
|
import com.android.settings.applications.appinfo.AppLocaleDetails;
|
|
import com.android.settings.applications.appinfo.DrawOverlayDetails;
|
|
import com.android.settings.applications.appinfo.ExternalSourcesDetails;
|
|
import com.android.settings.applications.appinfo.ManageExternalStorageDetails;
|
|
import com.android.settings.applications.appinfo.MediaManagementAppsDetails;
|
|
import com.android.settings.applications.appinfo.WriteSettingsDetails;
|
|
import com.android.settings.core.InstrumentedFragment;
|
|
import com.android.settings.core.SubSettingLauncher;
|
|
import com.android.settings.dashboard.profileselector.ProfileSelectFragment;
|
|
import com.android.settings.fuelgauge.AdvancedPowerUsageDetail;
|
|
import com.android.settings.fuelgauge.HighPowerDetail;
|
|
import com.android.settings.localepicker.AppLocalePickerActivity;
|
|
import com.android.settings.notification.ConfigureNotificationSettings;
|
|
import com.android.settings.notification.NotificationBackend;
|
|
import com.android.settings.notification.app.AppNotificationSettings;
|
|
import com.android.settings.widget.LoadingViewController;
|
|
import com.android.settings.wifi.AppStateChangeWifiStateBridge;
|
|
import com.android.settings.wifi.ChangeWifiStateDetails;
|
|
import com.android.settingslib.RestrictedLockUtils;
|
|
import com.android.settingslib.RestrictedLockUtilsInternal;
|
|
import com.android.settingslib.applications.AppIconCacheManager;
|
|
import com.android.settingslib.applications.AppUtils;
|
|
import com.android.settingslib.applications.ApplicationsState;
|
|
import com.android.settingslib.applications.ApplicationsState.AppEntry;
|
|
import com.android.settingslib.applications.ApplicationsState.AppFilter;
|
|
import com.android.settingslib.applications.ApplicationsState.CompoundFilter;
|
|
import com.android.settingslib.applications.ApplicationsState.VolumeFilter;
|
|
import com.android.settingslib.fuelgauge.PowerAllowlistBackend;
|
|
import com.android.settingslib.utils.ThreadUtils;
|
|
import com.android.settingslib.widget.SettingsSpinnerAdapter;
|
|
|
|
import com.google.android.material.appbar.AppBarLayout;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.Set;
|
|
|
|
/**
|
|
* Activity to pick an application that will be used to display installation information and
|
|
* options to uninstall/delete user data for system applications. This activity
|
|
* can be launched through Settings or via the ACTION_MANAGE_PACKAGE_STORAGE
|
|
* intent.
|
|
*/
|
|
public class ManageApplications extends InstrumentedFragment
|
|
implements View.OnClickListener, OnItemSelectedListener, SearchView.OnQueryTextListener,
|
|
MenuItem.OnActionExpandListener {
|
|
|
|
static final String TAG = "ManageApplications";
|
|
static final boolean DEBUG = Build.IS_DEBUGGABLE;
|
|
|
|
// Intent extras.
|
|
public static final String EXTRA_CLASSNAME = "classname";
|
|
// Used for storage only.
|
|
public static final String EXTRA_VOLUME_UUID = "volumeUuid";
|
|
public static final String EXTRA_VOLUME_NAME = "volumeName";
|
|
public static final String EXTRA_STORAGE_TYPE = "storageType";
|
|
public static final String EXTRA_WORK_ID = "workId";
|
|
|
|
private static final String EXTRA_SORT_ORDER = "sortOrder";
|
|
private static final String EXTRA_SHOW_SYSTEM = "showSystem";
|
|
private static final String EXTRA_HAS_ENTRIES = "hasEntries";
|
|
private static final String EXTRA_HAS_BRIDGE = "hasBridge";
|
|
private static final String EXTRA_FILTER_TYPE = "filterType";
|
|
@VisibleForTesting
|
|
static final String EXTRA_EXPAND_SEARCH_VIEW = "expand_search_view";
|
|
|
|
// attributes used as keys when passing values to AppInfoDashboardFragment activity
|
|
public static final String APP_CHG = "chg";
|
|
|
|
// constant value that can be used to check return code from sub activity.
|
|
private static final int INSTALLED_APP_DETAILS = 1;
|
|
private static final int ADVANCED_SETTINGS = 2;
|
|
|
|
public static final int SIZE_TOTAL = 0;
|
|
public static final int SIZE_INTERNAL = 1;
|
|
public static final int SIZE_EXTERNAL = 2;
|
|
|
|
// Storage types. Used to determine what the extra item in the list of preferences is.
|
|
public static final int STORAGE_TYPE_DEFAULT = 0; // Show all apps that are not categorized.
|
|
public static final int STORAGE_TYPE_LEGACY = 1; // Show apps even if they can be categorized.
|
|
|
|
// sort order
|
|
@VisibleForTesting
|
|
int mSortOrder = R.id.sort_order_alpha;
|
|
|
|
// whether showing system apps.
|
|
private boolean mShowSystem;
|
|
|
|
private ApplicationsState mApplicationsState;
|
|
|
|
public int mListType;
|
|
private AppFilterItem mFilter;
|
|
private ApplicationsAdapter mApplications;
|
|
|
|
private View mLoadingContainer;
|
|
private SearchView mSearchView;
|
|
|
|
// Size resource used for packages whose size computation failed for some reason
|
|
CharSequence mInvalidSizeStr;
|
|
|
|
private String mCurrentPkgName;
|
|
private int mCurrentUid;
|
|
|
|
private Menu mOptionsMenu;
|
|
|
|
public static final int LIST_TYPE_MAIN = 0;
|
|
public static final int LIST_TYPE_NOTIFICATION = 1;
|
|
public static final int LIST_TYPE_STORAGE = 3;
|
|
public static final int LIST_TYPE_USAGE_ACCESS = 4;
|
|
public static final int LIST_TYPE_HIGH_POWER = 5;
|
|
public static final int LIST_TYPE_OVERLAY = 6;
|
|
public static final int LIST_TYPE_WRITE_SETTINGS = 7;
|
|
public static final int LIST_TYPE_MANAGE_SOURCES = 8;
|
|
public static final int LIST_TYPE_GAMES = 9;
|
|
public static final int LIST_TYPE_WIFI_ACCESS = 10;
|
|
public static final int LIST_MANAGE_EXTERNAL_STORAGE = 11;
|
|
public static final int LIST_TYPE_ALARMS_AND_REMINDERS = 12;
|
|
public static final int LIST_TYPE_MEDIA_MANAGEMENT_APPS = 13;
|
|
public static final int LIST_TYPE_APPS_LOCALE = 14;
|
|
public static final int LIST_TYPE_BATTERY_OPTIMIZATION = 15;
|
|
|
|
// List types that should show instant apps.
|
|
public static final Set<Integer> LIST_TYPES_WITH_INSTANT = new ArraySet<>(Arrays.asList(
|
|
LIST_TYPE_MAIN,
|
|
LIST_TYPE_STORAGE));
|
|
|
|
@VisibleForTesting
|
|
View mSpinnerHeader;
|
|
@VisibleForTesting
|
|
FilterSpinnerAdapter mFilterAdapter;
|
|
@VisibleForTesting
|
|
RecyclerView mRecyclerView;
|
|
// Whether or not search view is expanded.
|
|
@VisibleForTesting
|
|
boolean mExpandSearch;
|
|
|
|
private View mRootView;
|
|
private Spinner mFilterSpinner;
|
|
private IUsageStatsManager mUsageStatsManager;
|
|
private UserManager mUserManager;
|
|
private NotificationBackend mNotificationBackend;
|
|
private ResetAppsHelper mResetAppsHelper;
|
|
private String mVolumeUuid;
|
|
private int mStorageType;
|
|
private boolean mIsWorkOnly;
|
|
private int mWorkUserId;
|
|
private boolean mIsPersonalOnly;
|
|
private View mEmptyView;
|
|
private int mFilterType;
|
|
private AppBarLayout mAppBarLayout;
|
|
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
setHasOptionsMenu(true);
|
|
final Activity activity = getActivity();
|
|
mUserManager = activity.getSystemService(UserManager.class);
|
|
mApplicationsState = ApplicationsState.getInstance(activity.getApplication());
|
|
|
|
Intent intent = activity.getIntent();
|
|
Bundle args = getArguments();
|
|
final int screenTitle = getTitleResId(intent, args);
|
|
String className = args != null ? args.getString(EXTRA_CLASSNAME) : null;
|
|
if (className == null) {
|
|
className = intent.getComponent().getClassName();
|
|
}
|
|
if (className.equals(StorageUseActivity.class.getName())) {
|
|
if (args != null && args.containsKey(EXTRA_VOLUME_UUID)) {
|
|
mVolumeUuid = args.getString(EXTRA_VOLUME_UUID);
|
|
mStorageType = args.getInt(EXTRA_STORAGE_TYPE, STORAGE_TYPE_DEFAULT);
|
|
mListType = LIST_TYPE_STORAGE;
|
|
} else {
|
|
// No volume selected, display a normal list, sorted by size.
|
|
mListType = LIST_TYPE_MAIN;
|
|
}
|
|
mSortOrder = R.id.sort_order_size;
|
|
} else if (className.equals(UsageAccessSettingsActivity.class.getName())) {
|
|
mListType = LIST_TYPE_USAGE_ACCESS;
|
|
} else if (className.equals(HighPowerApplicationsActivity.class.getName())) {
|
|
mListType = LIST_TYPE_HIGH_POWER;
|
|
// Default to showing system.
|
|
mShowSystem = true;
|
|
} else if (className.equals(OverlaySettingsActivity.class.getName())) {
|
|
mListType = LIST_TYPE_OVERLAY;
|
|
|
|
reportIfRestrictedSawIntent(intent);
|
|
} else if (className.equals(WriteSettingsActivity.class.getName())) {
|
|
mListType = LIST_TYPE_WRITE_SETTINGS;
|
|
} else if (className.equals(ManageExternalSourcesActivity.class.getName())) {
|
|
mListType = LIST_TYPE_MANAGE_SOURCES;
|
|
} else if (className.equals(GamesStorageActivity.class.getName())) {
|
|
mListType = LIST_TYPE_GAMES;
|
|
mSortOrder = R.id.sort_order_size;
|
|
} else if (className.equals(Settings.ChangeWifiStateActivity.class.getName())) {
|
|
mListType = LIST_TYPE_WIFI_ACCESS;
|
|
} else if (className.equals(Settings.ManageExternalStorageActivity.class.getName())) {
|
|
mListType = LIST_MANAGE_EXTERNAL_STORAGE;
|
|
} else if (className.equals(Settings.MediaManagementAppsActivity.class.getName())) {
|
|
mListType = LIST_TYPE_MEDIA_MANAGEMENT_APPS;
|
|
} else if (className.equals(Settings.AlarmsAndRemindersActivity.class.getName())) {
|
|
mListType = LIST_TYPE_ALARMS_AND_REMINDERS;
|
|
} else if (className.equals(Settings.NotificationAppListActivity.class.getName())
|
|
|| className.equals(
|
|
Settings.NotificationReviewPermissionsActivity.class.getName())) {
|
|
mListType = LIST_TYPE_NOTIFICATION;
|
|
mUsageStatsManager = IUsageStatsManager.Stub.asInterface(
|
|
ServiceManager.getService(Context.USAGE_STATS_SERVICE));
|
|
mNotificationBackend = new NotificationBackend();
|
|
mSortOrder = R.id.sort_order_recent_notification;
|
|
if (className.equals(Settings.NotificationReviewPermissionsActivity.class.getName())) {
|
|
// Special-case for a case where a user is directed to the all apps notification
|
|
// preferences page via a notification prompt to review permissions settings.
|
|
android.provider.Settings.Global.putInt(getContext().getContentResolver(),
|
|
android.provider.Settings.Global.REVIEW_PERMISSIONS_NOTIFICATION_STATE,
|
|
1); // USER_INTERACTED
|
|
}
|
|
} else if (className.equals(AppLocaleDetails.class.getName())) {
|
|
mListType = LIST_TYPE_APPS_LOCALE;
|
|
} else if (className.equals(Settings.AppBatteryUsageActivity.class.getName())) {
|
|
mListType = LIST_TYPE_BATTERY_OPTIMIZATION;
|
|
} else {
|
|
mListType = LIST_TYPE_MAIN;
|
|
}
|
|
final AppFilterRegistry appFilterRegistry = AppFilterRegistry.getInstance();
|
|
mFilter = appFilterRegistry.get(appFilterRegistry.getDefaultFilterType(mListType));
|
|
mIsPersonalOnly = args != null ? args.getInt(ProfileSelectFragment.EXTRA_PROFILE)
|
|
== ProfileSelectFragment.ProfileType.PERSONAL : false;
|
|
mIsWorkOnly = args != null ? args.getInt(ProfileSelectFragment.EXTRA_PROFILE)
|
|
== ProfileSelectFragment.ProfileType.WORK : false;
|
|
mWorkUserId = args != null ? args.getInt(EXTRA_WORK_ID) : UserHandle.myUserId();
|
|
if (mIsWorkOnly && mWorkUserId == UserHandle.myUserId()) {
|
|
mWorkUserId = Utils.getManagedProfileId(mUserManager, UserHandle.myUserId());
|
|
}
|
|
|
|
mExpandSearch = activity.getIntent().getBooleanExtra(EXTRA_EXPAND_SEARCH_VIEW, false);
|
|
|
|
if (savedInstanceState != null) {
|
|
mSortOrder = savedInstanceState.getInt(EXTRA_SORT_ORDER, mSortOrder);
|
|
mShowSystem = savedInstanceState.getBoolean(EXTRA_SHOW_SYSTEM, mShowSystem);
|
|
mFilterType =
|
|
savedInstanceState.getInt(EXTRA_FILTER_TYPE, AppFilterRegistry.FILTER_APPS_ALL);
|
|
mExpandSearch = savedInstanceState.getBoolean(EXTRA_EXPAND_SEARCH_VIEW);
|
|
}
|
|
|
|
mInvalidSizeStr = activity.getText(R.string.invalid_size_value);
|
|
|
|
mResetAppsHelper = new ResetAppsHelper(activity);
|
|
|
|
if (screenTitle > 0) {
|
|
activity.setTitle(screenTitle);
|
|
}
|
|
}
|
|
|
|
private void reportIfRestrictedSawIntent(Intent intent) {
|
|
try {
|
|
Uri data = intent.getData();
|
|
if (data == null || !TextUtils.equals("package", data.getScheme())) {
|
|
// Not a restricted intent
|
|
return;
|
|
}
|
|
IBinder activityToken = getActivity().getActivityToken();
|
|
int callingUid = ActivityManager.getService().getLaunchedFromUid(activityToken);
|
|
if (callingUid == -1) {
|
|
Log.w(TAG, "Error obtaining calling uid");
|
|
return;
|
|
}
|
|
IPlatformCompat platformCompat = IPlatformCompat.Stub.asInterface(
|
|
ServiceManager.getService(Context.PLATFORM_COMPAT_SERVICE));
|
|
if (platformCompat == null) {
|
|
Log.w(TAG, "Error obtaining IPlatformCompat service");
|
|
return;
|
|
}
|
|
platformCompat.reportChangeByUid(CHANGE_RESTRICT_SAW_INTENT, callingUid);
|
|
} catch (RemoteException e) {
|
|
Log.w(TAG, "Error reporting SAW intent restriction", e);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public View onCreateView(LayoutInflater inflater, ViewGroup container,
|
|
Bundle savedInstanceState) {
|
|
if (mListType == LIST_TYPE_OVERLAY && !Utils.isSystemAlertWindowEnabled(getContext())) {
|
|
mRootView = inflater.inflate(R.layout.manage_applications_apps_unsupported, null);
|
|
setHasOptionsMenu(false);
|
|
return mRootView;
|
|
}
|
|
|
|
mRootView = inflater.inflate(R.layout.manage_applications_apps, null);
|
|
mLoadingContainer = mRootView.findViewById(R.id.loading_container);
|
|
mEmptyView = mRootView.findViewById(android.R.id.empty);
|
|
mRecyclerView = mRootView.findViewById(R.id.apps_list);
|
|
|
|
mApplications = new ApplicationsAdapter(mApplicationsState, this, mFilter,
|
|
savedInstanceState);
|
|
if (savedInstanceState != null) {
|
|
mApplications.mHasReceivedLoadEntries =
|
|
savedInstanceState.getBoolean(EXTRA_HAS_ENTRIES, false);
|
|
mApplications.mHasReceivedBridgeCallback =
|
|
savedInstanceState.getBoolean(EXTRA_HAS_BRIDGE, false);
|
|
}
|
|
mRecyclerView.setItemAnimator(null);
|
|
mRecyclerView.setLayoutManager(new LinearLayoutManager(
|
|
getContext(), RecyclerView.VERTICAL, false /* reverseLayout */));
|
|
mRecyclerView.setAdapter(mApplications);
|
|
|
|
// We have to do this now because PreferenceFrameLayout looks at it
|
|
// only when the view is added.
|
|
if (container instanceof PreferenceFrameLayout) {
|
|
((PreferenceFrameLayout.LayoutParams) mRootView.getLayoutParams()).removeBorders = true;
|
|
}
|
|
|
|
createHeader();
|
|
|
|
mResetAppsHelper.onRestoreInstanceState(savedInstanceState);
|
|
|
|
mAppBarLayout = getActivity().findViewById(R.id.app_bar);
|
|
disableToolBarScrollableBehavior();
|
|
|
|
return mRootView;
|
|
}
|
|
|
|
@VisibleForTesting
|
|
void createHeader() {
|
|
final Activity activity = getActivity();
|
|
final FrameLayout pinnedHeader = mRootView.findViewById(R.id.pinned_header);
|
|
mSpinnerHeader = activity.getLayoutInflater()
|
|
.inflate(R.layout.manage_apps_filter_spinner, pinnedHeader, false);
|
|
mFilterSpinner = mSpinnerHeader.findViewById(R.id.filter_spinner);
|
|
mFilterAdapter = new FilterSpinnerAdapter(this);
|
|
mFilterSpinner.setAdapter(mFilterAdapter);
|
|
mFilterSpinner.setOnItemSelectedListener(this);
|
|
pinnedHeader.addView(mSpinnerHeader, 0);
|
|
|
|
final AppFilterRegistry appFilterRegistry = AppFilterRegistry.getInstance();
|
|
final int filterType = appFilterRegistry.getDefaultFilterType(mListType);
|
|
mFilterAdapter.enableFilter(filterType);
|
|
|
|
if (mListType == LIST_TYPE_MAIN) {
|
|
if (UserManager.get(getActivity()).getUserProfiles().size() > 1 && !mIsWorkOnly
|
|
&& !mIsPersonalOnly) {
|
|
mFilterAdapter.enableFilter(FILTER_APPS_PERSONAL);
|
|
mFilterAdapter.enableFilter(FILTER_APPS_WORK);
|
|
}
|
|
}
|
|
if (mListType == LIST_TYPE_NOTIFICATION) {
|
|
mFilterAdapter.enableFilter(FILTER_APPS_RECENT);
|
|
mFilterAdapter.enableFilter(FILTER_APPS_FREQUENT);
|
|
mFilterAdapter.enableFilter(FILTER_APPS_BLOCKED);
|
|
mFilterAdapter.enableFilter(FILTER_APPS_ALL);
|
|
}
|
|
if (mListType == LIST_TYPE_HIGH_POWER) {
|
|
mFilterAdapter.enableFilter(FILTER_APPS_POWER_ALLOWLIST_ALL);
|
|
}
|
|
if (mListType == LIST_TYPE_BATTERY_OPTIMIZATION) {
|
|
mFilterAdapter.enableFilter(FILTER_APPS_ALL);
|
|
mFilterAdapter.enableFilter(FILTER_APPS_BATTERY_UNRESTRICTED);
|
|
mFilterAdapter.enableFilter(FILTER_APPS_BATTERY_OPTIMIZED);
|
|
mFilterAdapter.enableFilter(FILTER_APPS_BATTERY_RESTRICTED);
|
|
}
|
|
|
|
setCompositeFilter();
|
|
}
|
|
|
|
@VisibleForTesting
|
|
@Nullable
|
|
static AppFilter getCompositeFilter(int listType, int storageType, String volumeUuid) {
|
|
AppFilter filter = new VolumeFilter(volumeUuid);
|
|
if (listType == LIST_TYPE_STORAGE) {
|
|
if (storageType == STORAGE_TYPE_DEFAULT) {
|
|
filter = new CompoundFilter(ApplicationsState.FILTER_APPS_EXCEPT_GAMES, filter);
|
|
}
|
|
return filter;
|
|
}
|
|
if (listType == LIST_TYPE_GAMES) {
|
|
return new CompoundFilter(ApplicationsState.FILTER_GAMES, filter);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public int getMetricsCategory() {
|
|
switch (mListType) {
|
|
case LIST_TYPE_MAIN:
|
|
return SettingsEnums.MANAGE_APPLICATIONS;
|
|
case LIST_TYPE_NOTIFICATION:
|
|
return SettingsEnums.MANAGE_APPLICATIONS_NOTIFICATIONS;
|
|
case LIST_TYPE_STORAGE:
|
|
return SettingsEnums.APPLICATIONS_STORAGE_APPS;
|
|
case LIST_TYPE_GAMES:
|
|
return SettingsEnums.APPLICATIONS_STORAGE_GAMES;
|
|
case LIST_TYPE_USAGE_ACCESS:
|
|
return SettingsEnums.USAGE_ACCESS;
|
|
case LIST_TYPE_HIGH_POWER:
|
|
return SettingsEnums.APPLICATIONS_HIGH_POWER_APPS;
|
|
case LIST_TYPE_OVERLAY:
|
|
return SettingsEnums.SYSTEM_ALERT_WINDOW_APPS;
|
|
case LIST_TYPE_WRITE_SETTINGS:
|
|
return SettingsEnums.SYSTEM_ALERT_WINDOW_APPS;
|
|
case LIST_TYPE_MANAGE_SOURCES:
|
|
return SettingsEnums.MANAGE_EXTERNAL_SOURCES;
|
|
case LIST_TYPE_WIFI_ACCESS:
|
|
return SettingsEnums.CONFIGURE_WIFI;
|
|
case LIST_MANAGE_EXTERNAL_STORAGE:
|
|
return SettingsEnums.MANAGE_EXTERNAL_STORAGE;
|
|
case LIST_TYPE_ALARMS_AND_REMINDERS:
|
|
return SettingsEnums.ALARMS_AND_REMINDERS;
|
|
case LIST_TYPE_MEDIA_MANAGEMENT_APPS:
|
|
return SettingsEnums.MEDIA_MANAGEMENT_APPS;
|
|
case LIST_TYPE_APPS_LOCALE:
|
|
return SettingsEnums.APPS_LOCALE_LIST;
|
|
case LIST_TYPE_BATTERY_OPTIMIZATION:
|
|
return SettingsEnums.BATTERY_OPTIMIZED_APPS_LIST;
|
|
default:
|
|
return SettingsEnums.PAGE_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onStart() {
|
|
super.onStart();
|
|
updateView();
|
|
if (mApplications != null) {
|
|
mApplications.resume(mSortOrder);
|
|
mApplications.updateLoading();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onSaveInstanceState(Bundle outState) {
|
|
super.onSaveInstanceState(outState);
|
|
mResetAppsHelper.onSaveInstanceState(outState);
|
|
outState.putInt(EXTRA_SORT_ORDER, mSortOrder);
|
|
outState.putInt(EXTRA_FILTER_TYPE, mFilter.getFilterType());
|
|
outState.putBoolean(EXTRA_SHOW_SYSTEM, mShowSystem);
|
|
if (mSearchView != null) {
|
|
outState.putBoolean(EXTRA_EXPAND_SEARCH_VIEW, !mSearchView.isIconified());
|
|
}
|
|
if (mApplications != null) {
|
|
outState.putBoolean(EXTRA_HAS_ENTRIES, mApplications.mHasReceivedLoadEntries);
|
|
outState.putBoolean(EXTRA_HAS_BRIDGE, mApplications.mHasReceivedBridgeCallback);
|
|
mApplications.onSaveInstanceState(outState);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onStop() {
|
|
super.onStop();
|
|
if (mApplications != null) {
|
|
mApplications.pause();
|
|
}
|
|
mResetAppsHelper.stop();
|
|
}
|
|
|
|
@Override
|
|
public void onDestroyView() {
|
|
super.onDestroyView();
|
|
|
|
if (mApplications != null) {
|
|
mApplications.release();
|
|
}
|
|
mRootView = null;
|
|
AppIconCacheManager.getInstance().release();
|
|
}
|
|
|
|
@Override
|
|
public void onActivityResult(int requestCode, int resultCode, Intent data) {
|
|
if (requestCode == INSTALLED_APP_DETAILS && mCurrentPkgName != null) {
|
|
if (mListType == LIST_TYPE_NOTIFICATION) {
|
|
mApplications.mExtraInfoBridge.forceUpdate(mCurrentPkgName, mCurrentUid);
|
|
} else if (mListType == LIST_TYPE_HIGH_POWER || mListType == LIST_TYPE_OVERLAY
|
|
|| mListType == LIST_TYPE_WRITE_SETTINGS) {
|
|
mApplications.mExtraInfoBridge.forceUpdate(mCurrentPkgName, mCurrentUid);
|
|
} else {
|
|
mApplicationsState.requestSize(mCurrentPkgName, UserHandle.getUserId(mCurrentUid));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setCompositeFilter() {
|
|
AppFilter compositeFilter = getCompositeFilter(mListType, mStorageType, mVolumeUuid);
|
|
if (compositeFilter == null) {
|
|
compositeFilter = mFilter.getFilter();
|
|
}
|
|
if (mIsWorkOnly) {
|
|
compositeFilter = new CompoundFilter(compositeFilter, ApplicationsState.FILTER_WORK);
|
|
}
|
|
if (mIsPersonalOnly) {
|
|
compositeFilter = new CompoundFilter(compositeFilter,
|
|
ApplicationsState.FILTER_PERSONAL);
|
|
}
|
|
mApplications.setCompositeFilter(compositeFilter);
|
|
}
|
|
|
|
// utility method used to start sub activity
|
|
private void startApplicationDetailsActivity() {
|
|
switch (mListType) {
|
|
case LIST_TYPE_NOTIFICATION:
|
|
startAppInfoFragment(AppNotificationSettings.class, R.string.notifications_title);
|
|
break;
|
|
case LIST_TYPE_USAGE_ACCESS:
|
|
startAppInfoFragment(UsageAccessDetails.class, R.string.usage_access);
|
|
break;
|
|
case LIST_TYPE_STORAGE:
|
|
startAppInfoFragment(AppStorageSettings.class, R.string.storage_settings);
|
|
break;
|
|
case LIST_TYPE_HIGH_POWER:
|
|
HighPowerDetail.show(this, mCurrentUid, mCurrentPkgName, INSTALLED_APP_DETAILS);
|
|
break;
|
|
case LIST_TYPE_OVERLAY:
|
|
startAppInfoFragment(DrawOverlayDetails.class, R.string.overlay_settings);
|
|
break;
|
|
case LIST_TYPE_WRITE_SETTINGS:
|
|
startAppInfoFragment(WriteSettingsDetails.class, R.string.write_system_settings);
|
|
break;
|
|
case LIST_TYPE_MANAGE_SOURCES:
|
|
startAppInfoFragment(ExternalSourcesDetails.class, R.string.install_other_apps);
|
|
break;
|
|
case LIST_TYPE_GAMES:
|
|
startAppInfoFragment(AppStorageSettings.class, R.string.game_storage_settings);
|
|
break;
|
|
case LIST_TYPE_WIFI_ACCESS:
|
|
startAppInfoFragment(ChangeWifiStateDetails.class,
|
|
R.string.change_wifi_state_title);
|
|
break;
|
|
case LIST_MANAGE_EXTERNAL_STORAGE:
|
|
startAppInfoFragment(ManageExternalStorageDetails.class,
|
|
R.string.manage_external_storage_title);
|
|
break;
|
|
case LIST_TYPE_ALARMS_AND_REMINDERS:
|
|
startAppInfoFragment(AlarmsAndRemindersDetails.class,
|
|
R.string.alarms_and_reminders_label);
|
|
break;
|
|
case LIST_TYPE_MEDIA_MANAGEMENT_APPS:
|
|
startAppInfoFragment(MediaManagementAppsDetails.class,
|
|
R.string.media_management_apps_title);
|
|
break;
|
|
case LIST_TYPE_APPS_LOCALE:
|
|
Intent intent = new Intent(getContext(), AppLocalePickerActivity.class);
|
|
intent.setData(Uri.parse("package:" + mCurrentPkgName));
|
|
getContext().startActivityAsUser(intent,
|
|
UserHandle.getUserHandleForUid(mCurrentUid));
|
|
break;
|
|
case LIST_TYPE_BATTERY_OPTIMIZATION:
|
|
AdvancedPowerUsageDetail.startBatteryDetailPage(
|
|
getActivity(), this, mCurrentPkgName,
|
|
UserHandle.getUserHandleForUid(mCurrentUid));
|
|
break;
|
|
// TODO: Figure out if there is a way where we can spin up the profile's settings
|
|
// process ahead of time, to avoid a long load of data when user clicks on a managed
|
|
// app. Maybe when they load the list of apps that contains managed profile apps.
|
|
default:
|
|
startAppInfoFragment(
|
|
AppInfoDashboardFragment.class, R.string.application_info_label);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void startAppInfoFragment(Class<?> fragment, int titleRes) {
|
|
AppInfoBase.startAppInfoFragment(fragment, getString(titleRes), mCurrentPkgName,
|
|
mCurrentUid, this, INSTALLED_APP_DETAILS, getMetricsCategory());
|
|
}
|
|
|
|
@Override
|
|
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
|
|
final Activity activity = getActivity();
|
|
if (activity == null) {
|
|
return;
|
|
}
|
|
mOptionsMenu = menu;
|
|
inflater.inflate(R.menu.manage_apps, menu);
|
|
|
|
final MenuItem searchMenuItem = menu.findItem(R.id.search_app_list_menu);
|
|
if (searchMenuItem != null) {
|
|
searchMenuItem.setOnActionExpandListener(this);
|
|
mSearchView = (SearchView) searchMenuItem.getActionView();
|
|
mSearchView.setQueryHint(getText(R.string.search_settings));
|
|
mSearchView.setOnQueryTextListener(this);
|
|
mSearchView.setMaxWidth(Integer.MAX_VALUE);
|
|
if (mExpandSearch) {
|
|
searchMenuItem.expandActionView();
|
|
}
|
|
}
|
|
|
|
updateOptionsMenu();
|
|
}
|
|
|
|
@Override
|
|
public boolean onMenuItemActionExpand(MenuItem item) {
|
|
// To prevent a large space on tool bar.
|
|
mAppBarLayout.setExpanded(false /*expanded*/, false /*animate*/);
|
|
// To prevent user can expand the collapsing tool bar view.
|
|
ViewCompat.setNestedScrollingEnabled(mRecyclerView, false);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onMenuItemActionCollapse(MenuItem item) {
|
|
// We keep the collapsed status after user cancel the search function.
|
|
mAppBarLayout.setExpanded(false /*expanded*/, false /*animate*/);
|
|
ViewCompat.setNestedScrollingEnabled(mRecyclerView, true);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onPrepareOptionsMenu(Menu menu) {
|
|
updateOptionsMenu();
|
|
}
|
|
|
|
@Override
|
|
public void onDestroyOptionsMenu() {
|
|
mOptionsMenu = null;
|
|
}
|
|
|
|
@StringRes
|
|
int getHelpResource() {
|
|
switch (mListType) {
|
|
case LIST_TYPE_NOTIFICATION:
|
|
return R.string.help_uri_notifications;
|
|
case LIST_TYPE_USAGE_ACCESS:
|
|
return R.string.help_url_usage_access;
|
|
case LIST_TYPE_STORAGE:
|
|
return R.string.help_uri_apps_storage;
|
|
case LIST_TYPE_HIGH_POWER:
|
|
return R.string.help_uri_apps_high_power;
|
|
case LIST_TYPE_OVERLAY:
|
|
return R.string.help_uri_apps_overlay;
|
|
case LIST_TYPE_WRITE_SETTINGS:
|
|
return R.string.help_uri_apps_write_settings;
|
|
case LIST_TYPE_MANAGE_SOURCES:
|
|
return R.string.help_uri_apps_manage_sources;
|
|
case LIST_TYPE_GAMES:
|
|
return R.string.help_uri_apps_overlay;
|
|
case LIST_TYPE_WIFI_ACCESS:
|
|
return R.string.help_uri_apps_wifi_access;
|
|
case LIST_MANAGE_EXTERNAL_STORAGE:
|
|
return R.string.help_uri_manage_external_storage;
|
|
case LIST_TYPE_ALARMS_AND_REMINDERS:
|
|
return R.string.help_uri_alarms_and_reminders;
|
|
case LIST_TYPE_MEDIA_MANAGEMENT_APPS:
|
|
return R.string.help_uri_media_management_apps;
|
|
default:
|
|
case LIST_TYPE_MAIN:
|
|
return R.string.help_uri_apps;
|
|
}
|
|
}
|
|
|
|
void updateOptionsMenu() {
|
|
if (mOptionsMenu == null) {
|
|
return;
|
|
}
|
|
mOptionsMenu.findItem(R.id.advanced).setVisible(false);
|
|
|
|
mOptionsMenu.findItem(R.id.sort_order_alpha).setVisible(mListType == LIST_TYPE_STORAGE
|
|
&& mSortOrder != R.id.sort_order_alpha);
|
|
mOptionsMenu.findItem(R.id.sort_order_size).setVisible(mListType == LIST_TYPE_STORAGE
|
|
&& mSortOrder != R.id.sort_order_size);
|
|
|
|
mOptionsMenu.findItem(R.id.show_system).setVisible(!mShowSystem
|
|
&& mListType != LIST_TYPE_HIGH_POWER && mListType != LIST_TYPE_APPS_LOCALE);
|
|
mOptionsMenu.findItem(R.id.hide_system).setVisible(mShowSystem
|
|
&& mListType != LIST_TYPE_HIGH_POWER && mListType != LIST_TYPE_APPS_LOCALE);
|
|
|
|
mOptionsMenu.findItem(R.id.reset_app_preferences).setVisible(mListType == LIST_TYPE_MAIN);
|
|
|
|
// Hide notification menu items, because sorting happens when filtering
|
|
mOptionsMenu.findItem(R.id.sort_order_recent_notification).setVisible(false);
|
|
mOptionsMenu.findItem(R.id.sort_order_frequent_notification).setVisible(false);
|
|
final MenuItem searchItem = mOptionsMenu.findItem(MENU_SEARCH);
|
|
if (searchItem != null) {
|
|
searchItem.setVisible(false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item) {
|
|
int menuId = item.getItemId();
|
|
int i = item.getItemId();
|
|
if (i == R.id.sort_order_alpha || i == R.id.sort_order_size) {
|
|
if (mApplications != null) {
|
|
mApplications.rebuild(menuId, false);
|
|
}
|
|
} else if (i == R.id.show_system || i == R.id.hide_system) {
|
|
mShowSystem = !mShowSystem;
|
|
mApplications.rebuild();
|
|
} else if (i == R.id.reset_app_preferences) {
|
|
final boolean appsControlDisallowedBySystem =
|
|
RestrictedLockUtilsInternal.hasBaseUserRestriction(getActivity(),
|
|
UserManager.DISALLOW_APPS_CONTROL, UserHandle.myUserId());
|
|
final RestrictedLockUtils.EnforcedAdmin appsControlDisallowedAdmin =
|
|
RestrictedLockUtilsInternal.checkIfRestrictionEnforced(getActivity(),
|
|
UserManager.DISALLOW_APPS_CONTROL, UserHandle.myUserId());
|
|
if (appsControlDisallowedAdmin != null && !appsControlDisallowedBySystem) {
|
|
RestrictedLockUtils.sendShowAdminSupportDetailsIntent(
|
|
getActivity(), appsControlDisallowedAdmin);
|
|
} else {
|
|
mResetAppsHelper.buildResetDialog();
|
|
}
|
|
return true;
|
|
} else if (i == R.id.advanced) {
|
|
if (mListType == LIST_TYPE_NOTIFICATION) {
|
|
new SubSettingLauncher(getContext())
|
|
.setDestination(ConfigureNotificationSettings.class.getName())
|
|
.setTitleRes(R.string.configure_notification_settings)
|
|
.setSourceMetricsCategory(getMetricsCategory())
|
|
.setResultListener(this, ADVANCED_SETTINGS)
|
|
.launch();
|
|
} else {
|
|
Intent intent = new Intent(
|
|
android.provider.Settings.ACTION_MANAGE_DEFAULT_APPS_SETTINGS);
|
|
startActivityForResult(intent, ADVANCED_SETTINGS);
|
|
}
|
|
return true;
|
|
} else {// Handle the home button
|
|
return false;
|
|
}
|
|
updateOptionsMenu();
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onClick(View view) {
|
|
if (mApplications == null) {
|
|
return;
|
|
}
|
|
final int applicationPosition =
|
|
ApplicationsAdapter.getApplicationPosition(
|
|
mListType, mRecyclerView.getChildAdapterPosition(view));
|
|
|
|
if (applicationPosition == RecyclerView.NO_POSITION) {
|
|
Log.w(TAG, "Cannot find position for child, skipping onClick handling");
|
|
return;
|
|
}
|
|
if (mApplications.getApplicationCount() > applicationPosition) {
|
|
ApplicationsState.AppEntry entry = mApplications.getAppEntry(applicationPosition);
|
|
mCurrentPkgName = entry.info.packageName;
|
|
mCurrentUid = entry.info.uid;
|
|
startApplicationDetailsActivity();
|
|
// We disable the scrolling ability in onMenuItemActionCollapse, we should recover it
|
|
// if user selects any app item.
|
|
ViewCompat.setNestedScrollingEnabled(mRecyclerView, true);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
|
|
mFilter = mFilterAdapter.getFilter(position);
|
|
setCompositeFilter();
|
|
mApplications.setFilter(mFilter);
|
|
|
|
if (DEBUG) {
|
|
Log.d(TAG, "Selecting filter " + getContext().getText(mFilter.getTitle()));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onNothingSelected(AdapterView<?> parent) {
|
|
}
|
|
|
|
@Override
|
|
public boolean onQueryTextSubmit(String query) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean onQueryTextChange(String newText) {
|
|
mApplications.filterSearch(newText);
|
|
return false;
|
|
}
|
|
|
|
public void updateView() {
|
|
updateOptionsMenu();
|
|
final Activity host = getActivity();
|
|
if (host != null) {
|
|
host.invalidateOptionsMenu();
|
|
}
|
|
}
|
|
|
|
public void setHasDisabled(boolean hasDisabledApps) {
|
|
if (mListType != LIST_TYPE_MAIN) {
|
|
return;
|
|
}
|
|
mFilterAdapter.setFilterEnabled(FILTER_APPS_ENABLED, hasDisabledApps);
|
|
mFilterAdapter.setFilterEnabled(FILTER_APPS_DISABLED, hasDisabledApps);
|
|
}
|
|
|
|
public void setHasInstant(boolean haveInstantApps) {
|
|
if (LIST_TYPES_WITH_INSTANT.contains(mListType)) {
|
|
mFilterAdapter.setFilterEnabled(FILTER_APPS_INSTANT, haveInstantApps);
|
|
}
|
|
}
|
|
|
|
private void disableToolBarScrollableBehavior() {
|
|
final CoordinatorLayout.LayoutParams params =
|
|
(CoordinatorLayout.LayoutParams) mAppBarLayout.getLayoutParams();
|
|
final AppBarLayout.Behavior behavior = new AppBarLayout.Behavior();
|
|
behavior.setDragCallback(
|
|
new AppBarLayout.Behavior.DragCallback() {
|
|
@Override
|
|
public boolean canDrag(@NonNull AppBarLayout appBarLayout) {
|
|
return false;
|
|
}
|
|
});
|
|
params.setBehavior(behavior);
|
|
}
|
|
|
|
/**
|
|
* Returns a resource ID of title based on what type of app list is
|
|
*
|
|
* @param intent the intent of the activity that might include a specified title
|
|
* @param args the args that includes a class name of app list
|
|
*/
|
|
public static int getTitleResId(@NonNull Intent intent, Bundle args) {
|
|
int screenTitle = intent.getIntExtra(
|
|
SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RESID, R.string.all_apps);
|
|
String className = args != null ? args.getString(EXTRA_CLASSNAME) : null;
|
|
if (className == null) {
|
|
className = intent.getComponent().getClassName();
|
|
}
|
|
if (className.equals(Settings.UsageAccessSettingsActivity.class.getName())) {
|
|
screenTitle = R.string.usage_access;
|
|
} else if (className.equals(Settings.HighPowerApplicationsActivity.class.getName())) {
|
|
screenTitle = R.string.high_power_apps;
|
|
} else if (className.equals(Settings.OverlaySettingsActivity.class.getName())) {
|
|
screenTitle = R.string.system_alert_window_settings;
|
|
} else if (className.equals(Settings.WriteSettingsActivity.class.getName())) {
|
|
screenTitle = R.string.write_settings;
|
|
} else if (className.equals(Settings.ManageExternalSourcesActivity.class.getName())) {
|
|
screenTitle = R.string.install_other_apps;
|
|
} else if (className.equals(Settings.ChangeWifiStateActivity.class.getName())) {
|
|
screenTitle = R.string.change_wifi_state_title;
|
|
} else if (className.equals(Settings.ManageExternalStorageActivity.class.getName())) {
|
|
screenTitle = R.string.manage_external_storage_title;
|
|
} else if (className.equals(Settings.MediaManagementAppsActivity.class.getName())) {
|
|
screenTitle = R.string.media_management_apps_title;
|
|
} else if (className.equals(Settings.AlarmsAndRemindersActivity.class.getName())) {
|
|
screenTitle = R.string.alarms_and_reminders_title;
|
|
} else if (className.equals(Settings.NotificationAppListActivity.class.getName())
|
|
|| className.equals(
|
|
Settings.NotificationReviewPermissionsActivity.class.getName())) {
|
|
screenTitle = R.string.app_notifications_title;
|
|
} else if (className.equals(AppLocaleDetails.class.getName())) {
|
|
screenTitle = R.string.app_locales_picker_menu_title;
|
|
} else if (className.equals(Settings.AppBatteryUsageActivity.class.getName())) {
|
|
screenTitle = R.string.app_battery_usage_title;
|
|
} else {
|
|
if (screenTitle == -1) {
|
|
screenTitle = R.string.all_apps;
|
|
}
|
|
}
|
|
return screenTitle;
|
|
}
|
|
|
|
static class FilterSpinnerAdapter extends SettingsSpinnerAdapter<CharSequence> {
|
|
|
|
private final ManageApplications mManageApplications;
|
|
private final Context mContext;
|
|
|
|
// Use ArrayAdapter for view logic, but have our own list for managing
|
|
// the options available.
|
|
private final ArrayList<AppFilterItem> mFilterOptions = new ArrayList<>();
|
|
|
|
public FilterSpinnerAdapter(ManageApplications manageApplications) {
|
|
super(manageApplications.getContext());
|
|
mContext = manageApplications.getContext();
|
|
mManageApplications = manageApplications;
|
|
}
|
|
|
|
public AppFilterItem getFilter(int position) {
|
|
return mFilterOptions.get(position);
|
|
}
|
|
|
|
public void setFilterEnabled(@AppFilterRegistry.FilterType int filter, boolean enabled) {
|
|
if (enabled) {
|
|
enableFilter(filter);
|
|
} else {
|
|
disableFilter(filter);
|
|
}
|
|
}
|
|
|
|
public void enableFilter(@AppFilterRegistry.FilterType int filterType) {
|
|
final AppFilterItem filter = AppFilterRegistry.getInstance().get(filterType);
|
|
if (mFilterOptions.contains(filter)) {
|
|
return;
|
|
}
|
|
if (DEBUG) {
|
|
Log.d(TAG, "Enabling filter " + mContext.getText(filter.getTitle()));
|
|
}
|
|
mFilterOptions.add(filter);
|
|
Collections.sort(mFilterOptions);
|
|
updateFilterView(mFilterOptions.size() > 1);
|
|
notifyDataSetChanged();
|
|
if (mFilterOptions.size() == 1) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "Auto selecting filter " + filter + " " + mContext.getText(
|
|
filter.getTitle()));
|
|
}
|
|
mManageApplications.mFilterSpinner.setSelection(0);
|
|
mManageApplications.onItemSelected(null, null, 0, 0);
|
|
}
|
|
if (mFilterOptions.size() > 1) {
|
|
final AppFilterItem previousFilter = AppFilterRegistry.getInstance().get(
|
|
mManageApplications.mFilterType);
|
|
final int index = mFilterOptions.indexOf(previousFilter);
|
|
if (index != -1) {
|
|
mManageApplications.mFilterSpinner.setSelection(index);
|
|
mManageApplications.onItemSelected(null, null, index, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void disableFilter(@AppFilterRegistry.FilterType int filterType) {
|
|
final AppFilterItem filter = AppFilterRegistry.getInstance().get(filterType);
|
|
if (!mFilterOptions.remove(filter)) {
|
|
return;
|
|
}
|
|
if (DEBUG) {
|
|
Log.d(TAG, "Disabling filter " + filter + " " + mContext.getText(
|
|
filter.getTitle()));
|
|
}
|
|
Collections.sort(mFilterOptions);
|
|
updateFilterView(mFilterOptions.size() > 1);
|
|
notifyDataSetChanged();
|
|
if (mManageApplications.mFilter == filter) {
|
|
if (mFilterOptions.size() > 0) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "Auto selecting filter " + mFilterOptions.get(0)
|
|
+ mContext.getText(mFilterOptions.get(0).getTitle()));
|
|
}
|
|
mManageApplications.mFilterSpinner.setSelection(0);
|
|
mManageApplications.onItemSelected(null, null, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int getCount() {
|
|
return mFilterOptions.size();
|
|
}
|
|
|
|
@Override
|
|
public CharSequence getItem(int position) {
|
|
return mContext.getText(mFilterOptions.get(position).getTitle());
|
|
}
|
|
|
|
@VisibleForTesting
|
|
void updateFilterView(boolean hasFilter) {
|
|
// If we need to add a floating filter in this screen, we should have an extra top
|
|
// padding for putting floating filter view. Otherwise, the content of list will be
|
|
// overlapped by floating filter.
|
|
if (hasFilter) {
|
|
mManageApplications.mSpinnerHeader.setVisibility(View.VISIBLE);
|
|
} else {
|
|
mManageApplications.mSpinnerHeader.setVisibility(View.GONE);
|
|
}
|
|
}
|
|
}
|
|
|
|
static class ApplicationsAdapter extends RecyclerView.Adapter<ApplicationViewHolder>
|
|
implements ApplicationsState.Callbacks, AppStateBaseBridge.Callback {
|
|
|
|
private static final String STATE_LAST_SCROLL_INDEX = "state_last_scroll_index";
|
|
private static final int VIEW_TYPE_APP = 0;
|
|
private static final int VIEW_TYPE_EXTRA_VIEW = 1;
|
|
private static final int VIEW_TYPE_APP_HEADER = 2;
|
|
|
|
private final ApplicationsState mState;
|
|
private final ApplicationsState.Session mSession;
|
|
private final ManageApplications mManageApplications;
|
|
private final Context mContext;
|
|
private final AppStateBaseBridge mExtraInfoBridge;
|
|
private final LoadingViewController mLoadingViewController;
|
|
private final IconDrawableFactory mIconDrawableFactory;
|
|
|
|
private AppFilterItem mAppFilter;
|
|
private ArrayList<ApplicationsState.AppEntry> mEntries;
|
|
private ArrayList<ApplicationsState.AppEntry> mOriginalEntries;
|
|
private boolean mResumed;
|
|
private int mLastSortMode = -1;
|
|
private int mWhichSize = SIZE_TOTAL;
|
|
private AppFilter mCompositeFilter;
|
|
private boolean mHasReceivedLoadEntries;
|
|
private boolean mHasReceivedBridgeCallback;
|
|
private SearchFilter mSearchFilter;
|
|
private PowerAllowlistBackend mBackend;
|
|
|
|
// This is to remember and restore the last scroll position when this
|
|
// fragment is paused. We need this special handling because app entries are added gradually
|
|
// when we rebuild the list after the user made some changes, like uninstalling an app.
|
|
private int mLastIndex = -1;
|
|
|
|
@VisibleForTesting
|
|
OnScrollListener mOnScrollListener;
|
|
private RecyclerView mRecyclerView;
|
|
|
|
|
|
public ApplicationsAdapter(ApplicationsState state, ManageApplications manageApplications,
|
|
AppFilterItem appFilter, Bundle savedInstanceState) {
|
|
setHasStableIds(true);
|
|
mState = state;
|
|
mSession = state.newSession(this);
|
|
mManageApplications = manageApplications;
|
|
mLoadingViewController = new LoadingViewController(
|
|
mManageApplications.mLoadingContainer,
|
|
mManageApplications.mRecyclerView,
|
|
mManageApplications.mEmptyView
|
|
);
|
|
mContext = manageApplications.getActivity();
|
|
mIconDrawableFactory = IconDrawableFactory.newInstance(mContext);
|
|
mAppFilter = appFilter;
|
|
mBackend = PowerAllowlistBackend.getInstance(mContext);
|
|
if (mManageApplications.mListType == LIST_TYPE_NOTIFICATION) {
|
|
mExtraInfoBridge = new AppStateNotificationBridge(mContext, mState, this,
|
|
manageApplications.mUsageStatsManager,
|
|
manageApplications.mUserManager,
|
|
manageApplications.mNotificationBackend);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_USAGE_ACCESS) {
|
|
mExtraInfoBridge = new AppStateUsageBridge(mContext, mState, this);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_HIGH_POWER) {
|
|
mBackend.refreshList();
|
|
mExtraInfoBridge = new AppStatePowerBridge(mContext, mState, this);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_OVERLAY) {
|
|
mExtraInfoBridge = new AppStateOverlayBridge(mContext, mState, this);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_WRITE_SETTINGS) {
|
|
mExtraInfoBridge = new AppStateWriteSettingsBridge(mContext, mState, this);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_MANAGE_SOURCES) {
|
|
mExtraInfoBridge = new AppStateInstallAppsBridge(mContext, mState, this);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_WIFI_ACCESS) {
|
|
mExtraInfoBridge = new AppStateChangeWifiStateBridge(mContext, mState, this);
|
|
} else if (mManageApplications.mListType == LIST_MANAGE_EXTERNAL_STORAGE) {
|
|
mExtraInfoBridge = new AppStateManageExternalStorageBridge(mContext, mState, this);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_ALARMS_AND_REMINDERS) {
|
|
mExtraInfoBridge = new AppStateAlarmsAndRemindersBridge(mContext, mState, this);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_MEDIA_MANAGEMENT_APPS) {
|
|
mExtraInfoBridge = new AppStateMediaManagementAppsBridge(mContext, mState, this);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_APPS_LOCALE) {
|
|
mExtraInfoBridge = new AppStateLocaleBridge(mContext, mState, this,
|
|
mManageApplications.mUserManager);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_BATTERY_OPTIMIZATION) {
|
|
mExtraInfoBridge = new AppStateAppBatteryUsageBridge(mContext, mState, this);
|
|
} else {
|
|
mExtraInfoBridge = null;
|
|
}
|
|
if (savedInstanceState != null) {
|
|
mLastIndex = savedInstanceState.getInt(STATE_LAST_SCROLL_INDEX);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onAttachedToRecyclerView(@NonNull RecyclerView recyclerView) {
|
|
super.onAttachedToRecyclerView(recyclerView);
|
|
mRecyclerView = recyclerView;
|
|
mOnScrollListener = new OnScrollListener(this);
|
|
mRecyclerView.addOnScrollListener(mOnScrollListener);
|
|
}
|
|
|
|
@Override
|
|
public void onDetachedFromRecyclerView(@NonNull RecyclerView recyclerView) {
|
|
super.onDetachedFromRecyclerView(recyclerView);
|
|
mRecyclerView.removeOnScrollListener(mOnScrollListener);
|
|
mOnScrollListener = null;
|
|
mRecyclerView = null;
|
|
}
|
|
|
|
public void setCompositeFilter(AppFilter compositeFilter) {
|
|
mCompositeFilter = compositeFilter;
|
|
rebuild();
|
|
}
|
|
|
|
public void setFilter(AppFilterItem appFilter) {
|
|
mAppFilter = appFilter;
|
|
final int filterType = appFilter.getFilterType();
|
|
|
|
// Notification filters require resorting the list
|
|
if (mManageApplications.mListType == LIST_TYPE_NOTIFICATION) {
|
|
if (FILTER_APPS_FREQUENT == filterType) {
|
|
rebuild(R.id.sort_order_frequent_notification, false);
|
|
} else if (FILTER_APPS_RECENT == filterType) {
|
|
rebuild(R.id.sort_order_recent_notification, false);
|
|
} else if (FILTER_APPS_BLOCKED == filterType) {
|
|
rebuild(R.id.sort_order_alpha, true);
|
|
} else {
|
|
rebuild(R.id.sort_order_alpha, true);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (mManageApplications.mListType == LIST_TYPE_BATTERY_OPTIMIZATION) {
|
|
logAppBatteryUsage(filterType);
|
|
}
|
|
|
|
rebuild();
|
|
}
|
|
|
|
public void resume(int sort) {
|
|
if (DEBUG) Log.i(TAG, "Resume! mResumed=" + mResumed);
|
|
if (!mResumed) {
|
|
mResumed = true;
|
|
mSession.onResume();
|
|
mLastSortMode = sort;
|
|
if (mExtraInfoBridge != null) {
|
|
mExtraInfoBridge.resume(false /* forceLoadAllApps */);
|
|
}
|
|
rebuild();
|
|
} else {
|
|
rebuild(sort, false);
|
|
}
|
|
}
|
|
|
|
public void pause() {
|
|
if (mResumed) {
|
|
mResumed = false;
|
|
mSession.onPause();
|
|
if (mExtraInfoBridge != null) {
|
|
mExtraInfoBridge.pause();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void onSaveInstanceState(Bundle outState) {
|
|
// Record the current scroll position before pausing.
|
|
final LinearLayoutManager layoutManager =
|
|
(LinearLayoutManager) mManageApplications.mRecyclerView.getLayoutManager();
|
|
outState.putInt(STATE_LAST_SCROLL_INDEX, layoutManager.findFirstVisibleItemPosition());
|
|
}
|
|
|
|
public void release() {
|
|
mSession.onDestroy();
|
|
if (mExtraInfoBridge != null) {
|
|
mExtraInfoBridge.release();
|
|
}
|
|
}
|
|
|
|
public void rebuild(int sort, boolean force) {
|
|
if (sort == mLastSortMode && !force) {
|
|
return;
|
|
}
|
|
mManageApplications.mSortOrder = sort;
|
|
mLastSortMode = sort;
|
|
rebuild();
|
|
}
|
|
|
|
@Override
|
|
public ApplicationViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
|
|
final View view;
|
|
if (mManageApplications.mListType == LIST_TYPE_APPS_LOCALE
|
|
&& viewType == VIEW_TYPE_APP_HEADER) {
|
|
view = ApplicationViewHolder.newHeader(parent,
|
|
R.string.desc_app_locale_selection_supported);
|
|
} else if (mManageApplications.mListType == LIST_TYPE_NOTIFICATION) {
|
|
view = ApplicationViewHolder.newView(parent, true /* twoTarget */);
|
|
} else {
|
|
view = ApplicationViewHolder.newView(parent, false /* twoTarget */);
|
|
}
|
|
return new ApplicationViewHolder(view);
|
|
}
|
|
|
|
@Override
|
|
public int getItemViewType(int position) {
|
|
if (position == 0 && mManageApplications.mListType == LIST_TYPE_APPS_LOCALE) {
|
|
return VIEW_TYPE_APP_HEADER;
|
|
}
|
|
return VIEW_TYPE_APP;
|
|
}
|
|
|
|
public void rebuild() {
|
|
if (!mHasReceivedLoadEntries
|
|
|| (mExtraInfoBridge != null && !mHasReceivedBridgeCallback)) {
|
|
// Don't rebuild the list until all the app entries are loaded.
|
|
if (DEBUG) {
|
|
Log.d(TAG, "Not rebuilding until all the app entries loaded."
|
|
+ " !mHasReceivedLoadEntries=" + !mHasReceivedLoadEntries
|
|
+ " !mExtraInfoBridgeNull=" + (mExtraInfoBridge != null)
|
|
+ " !mHasReceivedBridgeCallback=" + !mHasReceivedBridgeCallback);
|
|
}
|
|
return;
|
|
}
|
|
ApplicationsState.AppFilter filterObj;
|
|
Comparator<AppEntry> comparatorObj;
|
|
boolean emulated = Environment.isExternalStorageEmulated();
|
|
if (emulated) {
|
|
mWhichSize = SIZE_TOTAL;
|
|
} else {
|
|
mWhichSize = SIZE_INTERNAL;
|
|
}
|
|
filterObj = mAppFilter.getFilter();
|
|
if (mCompositeFilter != null) {
|
|
filterObj = new CompoundFilter(filterObj, mCompositeFilter);
|
|
}
|
|
if (!mManageApplications.mShowSystem) {
|
|
if (LIST_TYPES_WITH_INSTANT.contains(mManageApplications.mListType)) {
|
|
filterObj = new CompoundFilter(filterObj,
|
|
ApplicationsState.FILTER_DOWNLOADED_AND_LAUNCHER_AND_INSTANT);
|
|
} else {
|
|
filterObj = new CompoundFilter(filterObj,
|
|
ApplicationsState.FILTER_DOWNLOADED_AND_LAUNCHER);
|
|
}
|
|
}
|
|
if (mLastSortMode == R.id.sort_order_size) {
|
|
switch (mWhichSize) {
|
|
case SIZE_INTERNAL:
|
|
comparatorObj = ApplicationsState.INTERNAL_SIZE_COMPARATOR;
|
|
break;
|
|
case SIZE_EXTERNAL:
|
|
comparatorObj = ApplicationsState.EXTERNAL_SIZE_COMPARATOR;
|
|
break;
|
|
default:
|
|
comparatorObj = ApplicationsState.SIZE_COMPARATOR;
|
|
break;
|
|
}
|
|
} else if (mLastSortMode == R.id.sort_order_recent_notification) {
|
|
comparatorObj = AppStateNotificationBridge.RECENT_NOTIFICATION_COMPARATOR;
|
|
} else if (mLastSortMode == R.id.sort_order_frequent_notification) {
|
|
comparatorObj = AppStateNotificationBridge.FREQUENCY_NOTIFICATION_COMPARATOR;
|
|
} else {
|
|
comparatorObj = ApplicationsState.ALPHA_COMPARATOR;
|
|
}
|
|
|
|
final AppFilter finalFilterObj = new CompoundFilter(filterObj,
|
|
ApplicationsState.FILTER_NOT_HIDE);
|
|
ThreadUtils.postOnBackgroundThread(() -> {
|
|
mSession.rebuild(finalFilterObj, comparatorObj, false);
|
|
});
|
|
}
|
|
|
|
private void logAppBatteryUsage(int filterType) {
|
|
switch (filterType) {
|
|
case FILTER_APPS_BATTERY_UNRESTRICTED:
|
|
logAction(SettingsEnums.ACTION_BATTERY_OPTIMIZED_APPS_FILTER_UNRESTRICTED);
|
|
break;
|
|
case FILTER_APPS_BATTERY_OPTIMIZED:
|
|
logAction(SettingsEnums.ACTION_BATTERY_OPTIMIZED_APPS_FILTER_OPTIMIZED);
|
|
break;
|
|
case FILTER_APPS_BATTERY_RESTRICTED:
|
|
logAction(SettingsEnums.ACTION_BATTERY_OPTIMIZED_APPS_FILTER_RESTRICTED);
|
|
break;
|
|
default:
|
|
logAction(SettingsEnums.ACTION_BATTERY_OPTIMIZED_APPS_FILTER_ALL_APPS);
|
|
}
|
|
}
|
|
|
|
private void logAction(int action) {
|
|
mManageApplications.mMetricsFeatureProvider.action(mContext, action);
|
|
}
|
|
|
|
@VisibleForTesting
|
|
void filterSearch(String query) {
|
|
if (mSearchFilter == null) {
|
|
mSearchFilter = new SearchFilter();
|
|
}
|
|
// If we haven't load apps list completely, don't filter anything.
|
|
if (mOriginalEntries == null) {
|
|
Log.w(TAG, "Apps haven't loaded completely yet, so nothing can be filtered");
|
|
return;
|
|
}
|
|
mSearchFilter.filter(query);
|
|
}
|
|
|
|
private static boolean packageNameEquals(PackageItemInfo info1, PackageItemInfo info2) {
|
|
if (info1 == null || info2 == null) {
|
|
return false;
|
|
}
|
|
if (info1.packageName == null || info2.packageName == null) {
|
|
return false;
|
|
}
|
|
return info1.packageName.equals(info2.packageName);
|
|
}
|
|
|
|
private ArrayList<ApplicationsState.AppEntry> removeDuplicateIgnoringUser(
|
|
ArrayList<ApplicationsState.AppEntry> entries) {
|
|
int size = entries.size();
|
|
// returnList will not have more entries than entries
|
|
ArrayList<ApplicationsState.AppEntry> returnEntries = new ArrayList<>(size);
|
|
|
|
// assume appinfo of same package but different users are grouped together
|
|
PackageItemInfo lastInfo = null;
|
|
for (int i = 0; i < size; i++) {
|
|
AppEntry appEntry = entries.get(i);
|
|
PackageItemInfo info = appEntry.info;
|
|
if (!packageNameEquals(lastInfo, appEntry.info)) {
|
|
returnEntries.add(appEntry);
|
|
}
|
|
lastInfo = info;
|
|
}
|
|
returnEntries.trimToSize();
|
|
return returnEntries;
|
|
}
|
|
|
|
@Override
|
|
public void onRebuildComplete(ArrayList<AppEntry> entries) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "onRebuildComplete size=" + entries.size());
|
|
}
|
|
|
|
// Preload top visible icons of app list.
|
|
AppUtils.preloadTopIcons(mContext, entries,
|
|
mContext.getResources().getInteger(R.integer.config_num_visible_app_icons));
|
|
|
|
final int filterType = mAppFilter.getFilterType();
|
|
if (filterType == FILTER_APPS_POWER_ALLOWLIST
|
|
|| filterType == FILTER_APPS_POWER_ALLOWLIST_ALL) {
|
|
entries = removeDuplicateIgnoringUser(entries);
|
|
}
|
|
mEntries = entries;
|
|
mOriginalEntries = entries;
|
|
notifyDataSetChanged();
|
|
if (getItemCount() == 0) {
|
|
mLoadingViewController.showEmpty(false /* animate */);
|
|
} else {
|
|
mLoadingViewController.showContent(false /* animate */);
|
|
|
|
if (mManageApplications.mSearchView != null
|
|
&& mManageApplications.mSearchView.isVisibleToUser()) {
|
|
final CharSequence query = mManageApplications.mSearchView.getQuery();
|
|
if (!TextUtils.isEmpty(query)) {
|
|
filterSearch(query.toString());
|
|
}
|
|
}
|
|
}
|
|
// Restore the last scroll position if the number of entries added so far is bigger than
|
|
// it.
|
|
if (mLastIndex != -1 && getItemCount() > mLastIndex) {
|
|
mManageApplications.mRecyclerView.getLayoutManager().scrollToPosition(mLastIndex);
|
|
mLastIndex = -1;
|
|
}
|
|
|
|
if (mManageApplications.mListType == LIST_TYPE_USAGE_ACCESS) {
|
|
// No enabled or disabled filters for usage access.
|
|
return;
|
|
}
|
|
|
|
mManageApplications.setHasDisabled(mState.haveDisabledApps());
|
|
mManageApplications.setHasInstant(mState.haveInstantApps());
|
|
}
|
|
|
|
@VisibleForTesting
|
|
void updateLoading() {
|
|
final boolean appLoaded = mHasReceivedLoadEntries && mSession.getAllApps().size() != 0;
|
|
if (appLoaded) {
|
|
mLoadingViewController.showContent(false /* animate */);
|
|
} else {
|
|
mLoadingViewController.showLoadingViewDelayed();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onExtraInfoUpdated() {
|
|
mHasReceivedBridgeCallback = true;
|
|
rebuild();
|
|
}
|
|
|
|
@Override
|
|
public void onRunningStateChanged(boolean running) {
|
|
mManageApplications.getActivity().setProgressBarIndeterminateVisibility(running);
|
|
}
|
|
|
|
@Override
|
|
public void onPackageListChanged() {
|
|
rebuild();
|
|
}
|
|
|
|
@Override
|
|
public void onPackageIconChanged() {
|
|
// We ensure icons are loaded when their item is displayed, so
|
|
// don't care about icons loaded in the background.
|
|
}
|
|
|
|
@Override
|
|
public void onLoadEntriesCompleted() {
|
|
mHasReceivedLoadEntries = true;
|
|
// We may have been skipping rebuilds until this came in, trigger one now.
|
|
rebuild();
|
|
}
|
|
|
|
@Override
|
|
public void onPackageSizeChanged(String packageName) {
|
|
if (mEntries == null) {
|
|
return;
|
|
}
|
|
final int size = mEntries.size();
|
|
for (int i = 0; i < size; i++) {
|
|
final AppEntry entry = mEntries.get(i);
|
|
final ApplicationInfo info = entry.info;
|
|
if (info == null && !TextUtils.equals(packageName, info.packageName)) {
|
|
continue;
|
|
}
|
|
if (TextUtils.equals(mManageApplications.mCurrentPkgName, info.packageName)) {
|
|
// We got the size information for the last app the
|
|
// user viewed, and are sorting by size... they may
|
|
// have cleared data, so we immediately want to resort
|
|
// the list with the new size to reflect it to the user.
|
|
rebuild();
|
|
return;
|
|
} else {
|
|
mOnScrollListener.postNotifyItemChange(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onLauncherInfoChanged() {
|
|
if (!mManageApplications.mShowSystem) {
|
|
rebuild();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onAllSizesComputed() {
|
|
if (mLastSortMode == R.id.sort_order_size) {
|
|
rebuild();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Item count include all items. If UI has a header on the app list, it shall shift 1 to
|
|
* application count for the total item count.
|
|
*/
|
|
@Override
|
|
public int getItemCount() {
|
|
int count = getApplicationCount();
|
|
if (count != 0 && mManageApplications.mListType == LIST_TYPE_APPS_LOCALE) {
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
public int getApplicationCount() {
|
|
return mEntries != null ? mEntries.size() : 0;
|
|
}
|
|
|
|
public AppEntry getAppEntry(int applicationPosition) {
|
|
return mEntries.get(applicationPosition);
|
|
}
|
|
|
|
/**
|
|
* Item Id follows all item on the app list. If UI has a header on the list, it shall
|
|
* shift 1 to the position for correct app entry.
|
|
*/
|
|
@Override
|
|
public long getItemId(int position) {
|
|
int applicationPosition =
|
|
getApplicationPosition(mManageApplications.mListType, position);
|
|
if (applicationPosition == mEntries.size()
|
|
|| applicationPosition == RecyclerView.NO_POSITION) {
|
|
return -1;
|
|
}
|
|
return mEntries.get(applicationPosition).id;
|
|
}
|
|
|
|
/**
|
|
* Check item in the list shall enable or disable.
|
|
*
|
|
* @param position The item position in the list
|
|
*/
|
|
public boolean isEnabled(int position) {
|
|
int itemViewType = getItemViewType(position);
|
|
if (itemViewType == VIEW_TYPE_EXTRA_VIEW || itemViewType == VIEW_TYPE_APP_HEADER
|
|
|| mManageApplications.mListType != LIST_TYPE_HIGH_POWER) {
|
|
return true;
|
|
}
|
|
|
|
int applicationPosition =
|
|
getApplicationPosition(mManageApplications.mListType, position);
|
|
if (applicationPosition == RecyclerView.NO_POSITION) {
|
|
return true;
|
|
}
|
|
ApplicationsState.AppEntry entry = mEntries.get(applicationPosition);
|
|
|
|
return !mBackend.isSysAllowlisted(entry.info.packageName)
|
|
&& !mBackend.isDefaultActiveApp(entry.info.packageName);
|
|
}
|
|
|
|
@Override
|
|
public void onBindViewHolder(ApplicationViewHolder holder, int position) {
|
|
if (getItemViewType(position) == VIEW_TYPE_APP_HEADER) {
|
|
// It does not bind holder here, due to header view.
|
|
return;
|
|
}
|
|
|
|
int applicationPosition =
|
|
getApplicationPosition(mManageApplications.mListType, position);
|
|
if (applicationPosition == RecyclerView.NO_POSITION) {
|
|
return;
|
|
}
|
|
// Bind the data efficiently with the holder
|
|
// If there is a header on the list, the position shall be shifted. Thus, it shall use
|
|
// #getApplicationPosition to get real application position for the app entry.
|
|
final ApplicationsState.AppEntry entry = mEntries.get(applicationPosition);
|
|
|
|
synchronized (entry) {
|
|
mState.ensureLabelDescription(entry);
|
|
holder.setTitle(entry.label, entry.labelDescription);
|
|
updateIcon(holder, entry);
|
|
updateSummary(holder, entry);
|
|
updateSwitch(holder, entry);
|
|
holder.updateDisableView(entry.info);
|
|
}
|
|
holder.setEnabled(isEnabled(position));
|
|
|
|
holder.itemView.setOnClickListener(mManageApplications);
|
|
}
|
|
|
|
private void updateIcon(ApplicationViewHolder holder, AppEntry entry) {
|
|
final Drawable cachedIcon = AppUtils.getIconFromCache(entry);
|
|
if (cachedIcon != null && entry.mounted) {
|
|
holder.setIcon(cachedIcon);
|
|
} else {
|
|
ThreadUtils.postOnBackgroundThread(() -> {
|
|
final Drawable icon = AppUtils.getIcon(mContext, entry);
|
|
if (icon != null) {
|
|
ThreadUtils.postOnMainThread(() -> holder.setIcon(icon));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private void updateSummary(ApplicationViewHolder holder, AppEntry entry) {
|
|
switch (mManageApplications.mListType) {
|
|
case LIST_TYPE_NOTIFICATION:
|
|
if (entry.extraInfo != null
|
|
&& entry.extraInfo instanceof NotificationsSentState) {
|
|
holder.setSummary(AppStateNotificationBridge.getSummary(mContext,
|
|
(NotificationsSentState) entry.extraInfo, mLastSortMode));
|
|
} else {
|
|
holder.setSummary(null);
|
|
}
|
|
break;
|
|
case LIST_TYPE_USAGE_ACCESS:
|
|
if (entry.extraInfo != null) {
|
|
holder.setSummary(
|
|
(new UsageState((PermissionState) entry.extraInfo)).isPermissible()
|
|
? R.string.app_permission_summary_allowed
|
|
: R.string.app_permission_summary_not_allowed);
|
|
} else {
|
|
holder.setSummary(null);
|
|
}
|
|
break;
|
|
case LIST_TYPE_HIGH_POWER:
|
|
holder.setSummary(HighPowerDetail.getSummary(mContext, entry));
|
|
break;
|
|
case LIST_TYPE_OVERLAY:
|
|
holder.setSummary(DrawOverlayDetails.getSummary(mContext, entry));
|
|
break;
|
|
case LIST_TYPE_WRITE_SETTINGS:
|
|
holder.setSummary(WriteSettingsDetails.getSummary(mContext, entry));
|
|
break;
|
|
case LIST_TYPE_MANAGE_SOURCES:
|
|
holder.setSummary(ExternalSourcesDetails.getPreferenceSummary(mContext, entry));
|
|
break;
|
|
case LIST_TYPE_WIFI_ACCESS:
|
|
holder.setSummary(ChangeWifiStateDetails.getSummary(mContext, entry));
|
|
break;
|
|
case LIST_MANAGE_EXTERNAL_STORAGE:
|
|
holder.setSummary(ManageExternalStorageDetails.getSummary(mContext, entry));
|
|
break;
|
|
case LIST_TYPE_ALARMS_AND_REMINDERS:
|
|
holder.setSummary(AlarmsAndRemindersDetails.getSummary(mContext, entry));
|
|
break;
|
|
case LIST_TYPE_MEDIA_MANAGEMENT_APPS:
|
|
holder.setSummary(MediaManagementAppsDetails.getSummary(mContext, entry));
|
|
break;
|
|
case LIST_TYPE_APPS_LOCALE:
|
|
holder.setSummary(AppLocaleDetails.getSummary(mContext, entry));
|
|
break;
|
|
case LIST_TYPE_BATTERY_OPTIMIZATION:
|
|
holder.setSummary(null);
|
|
break;
|
|
default:
|
|
holder.updateSizeText(entry, mManageApplications.mInvalidSizeStr, mWhichSize);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void updateSwitch(ApplicationViewHolder holder, AppEntry entry) {
|
|
switch (mManageApplications.mListType) {
|
|
case LIST_TYPE_NOTIFICATION:
|
|
holder.updateSwitch(((AppStateNotificationBridge) mExtraInfoBridge)
|
|
.getSwitchOnCheckedListener(entry),
|
|
AppStateNotificationBridge.enableSwitch(entry),
|
|
AppStateNotificationBridge.checkSwitch(entry));
|
|
if (entry.extraInfo != null
|
|
&& entry.extraInfo instanceof NotificationsSentState) {
|
|
holder.setSummary(AppStateNotificationBridge.getSummary(mContext,
|
|
(NotificationsSentState) entry.extraInfo, mLastSortMode));
|
|
} else {
|
|
holder.setSummary(null);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adjusts position if this list adds a header.
|
|
* TODO(b/232533002) Add a header view on adapter of RecyclerView may not a good idea since
|
|
* ManageApplication is a generic purpose. In the future, here shall look for
|
|
* a better way to add a header without using recyclerView or any other ways
|
|
* to achieve the goal.
|
|
*/
|
|
public static int getApplicationPosition(int listType, int position) {
|
|
int applicationPosition = position;
|
|
// Adjust position due to header added.
|
|
if (listType == LIST_TYPE_APPS_LOCALE) {
|
|
applicationPosition = position > 0 ? position - 1 : RecyclerView.NO_POSITION;
|
|
}
|
|
return applicationPosition;
|
|
}
|
|
|
|
public static class OnScrollListener extends RecyclerView.OnScrollListener {
|
|
private int mScrollState = SCROLL_STATE_IDLE;
|
|
private boolean mDelayNotifyDataChange;
|
|
private ApplicationsAdapter mAdapter;
|
|
|
|
public OnScrollListener(ApplicationsAdapter adapter) {
|
|
mAdapter = adapter;
|
|
}
|
|
|
|
@Override
|
|
public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
|
|
mScrollState = newState;
|
|
if (mScrollState == SCROLL_STATE_IDLE && mDelayNotifyDataChange) {
|
|
mDelayNotifyDataChange = false;
|
|
mAdapter.notifyDataSetChanged();
|
|
}
|
|
}
|
|
|
|
public void postNotifyItemChange(int index) {
|
|
if (mScrollState == SCROLL_STATE_IDLE) {
|
|
mAdapter.notifyItemChanged(index);
|
|
} else {
|
|
mDelayNotifyDataChange = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* An array filter that constrains the content of the array adapter with a substring.
|
|
* Item that does not contains the specified substring will be removed from the list.</p>
|
|
*/
|
|
private class SearchFilter extends Filter {
|
|
@WorkerThread
|
|
@Override
|
|
protected FilterResults performFiltering(CharSequence query) {
|
|
final ArrayList<ApplicationsState.AppEntry> matchedEntries;
|
|
if (TextUtils.isEmpty(query)) {
|
|
matchedEntries = mOriginalEntries;
|
|
} else {
|
|
matchedEntries = new ArrayList<>();
|
|
for (ApplicationsState.AppEntry entry : mOriginalEntries) {
|
|
if (entry.label.toLowerCase().contains(query.toString().toLowerCase())) {
|
|
matchedEntries.add(entry);
|
|
}
|
|
}
|
|
}
|
|
final FilterResults results = new FilterResults();
|
|
results.values = matchedEntries;
|
|
results.count = matchedEntries.size();
|
|
return results;
|
|
}
|
|
|
|
@Override
|
|
protected void publishResults(CharSequence constraint, FilterResults results) {
|
|
mEntries = (ArrayList<ApplicationsState.AppEntry>) results.values;
|
|
notifyDataSetChanged();
|
|
}
|
|
}
|
|
}
|
|
}
|