8deb159e35
- App usage page only use package name to launch the page, it can not identify the different userId between normal app and work profile app, add extra userId info into launch args - Remove no battery usage state/string if usage time is empty Bug: 251471047 Test: make SettingsRoboTests Change-Id: Id06ebb0f0fcd863e423acd7839f89bc0ae2444c1 Merged-In: Id06ebb0f0fcd863e423acd7839f89bc0ae2444c1
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));
|
|
intent.putExtra(AppInfoBase.ARG_PACKAGE_UID, mCurrentUid);
|
|
startActivity(intent);
|
|
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();
|
|
}
|
|
}
|
|
}
|
|
}
|