/*
|
* Copyright (C) 2013 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.launcher3;
|
|
import static com.android.launcher3.InvariantDeviceProfile.CHANGE_FLAG_ICON_PARAMS;
|
import static com.android.launcher3.util.SecureSettingsObserver.newNotificationSettingsObserver;
|
|
import android.app.KeyguardManager;
|
import android.content.ComponentName;
|
import android.content.ContentProviderClient;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.content.IntentFilter;
|
import android.os.Handler;
|
import android.os.Process;
|
import android.util.Log;
|
|
import com.android.launcher3.compat.LauncherAppsCompat;
|
import com.android.launcher3.compat.PackageInstallerCompat;
|
import com.android.launcher3.compat.UserManagerCompat;
|
import com.android.launcher3.config.FeatureFlags;
|
import com.android.launcher3.icons.IconCache;
|
import com.android.launcher3.icons.LauncherIcons;
|
import com.android.launcher3.notification.NotificationListener;
|
import com.android.launcher3.util.MainThreadInitializedObject;
|
import com.android.launcher3.util.Preconditions;
|
import com.android.launcher3.util.SecureSettingsObserver;
|
|
public class LauncherAppState {
|
|
public static final String ACTION_FORCE_ROLOAD = "force-reload-launcher";
|
|
// We do not need any synchronization for this variable as its only written on UI thread.
|
private static final MainThreadInitializedObject<LauncherAppState> INSTANCE =
|
new MainThreadInitializedObject<>((c) -> new LauncherAppState(c));
|
|
private final Context mContext;
|
private final LauncherModel mModel;
|
private final IconCache mIconCache;
|
private final WidgetPreviewLoader mWidgetCache;
|
private final InvariantDeviceProfile mInvariantDeviceProfile;
|
private final SecureSettingsObserver mNotificationDotsObserver;
|
|
public static LauncherAppState getInstance(final Context context) {
|
return INSTANCE.get(context);
|
}
|
|
public static LauncherAppState getInstanceNoCreate() {
|
return INSTANCE.getNoCreate();
|
}
|
|
public Context getContext() {
|
return mContext;
|
}
|
|
private LauncherAppState(Context context) {
|
if (getLocalProvider(context) == null) {
|
throw new RuntimeException(
|
"Initializing LauncherAppState in the absence of LauncherProvider");
|
}
|
Log.v(Launcher.TAG, "LauncherAppState initiated");
|
Preconditions.assertUIThread();
|
mContext = context;
|
|
mInvariantDeviceProfile = InvariantDeviceProfile.INSTANCE.get(mContext);
|
mIconCache = new IconCache(mContext, mInvariantDeviceProfile);
|
mWidgetCache = new WidgetPreviewLoader(mContext, mIconCache);
|
mModel = new LauncherModel(this, mIconCache, AppFilter.newInstance(mContext));
|
|
LauncherAppsCompat.getInstance(mContext).addOnAppsChangedCallback(mModel);
|
|
// Register intent receivers
|
IntentFilter filter = new IntentFilter();
|
filter.addAction(Intent.ACTION_LOCALE_CHANGED);
|
// For handling managed profiles
|
filter.addAction(Intent.ACTION_MANAGED_PROFILE_ADDED);
|
filter.addAction(Intent.ACTION_MANAGED_PROFILE_REMOVED);
|
filter.addAction(Intent.ACTION_MANAGED_PROFILE_AVAILABLE);
|
filter.addAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE);
|
filter.addAction(Intent.ACTION_MANAGED_PROFILE_UNLOCKED);
|
|
if (FeatureFlags.IS_DOGFOOD_BUILD) {
|
filter.addAction(ACTION_FORCE_ROLOAD);
|
}
|
|
mContext.registerReceiver(mModel, filter);
|
UserManagerCompat.getInstance(mContext).enableAndResetCache();
|
mInvariantDeviceProfile.addOnChangeListener(this::onIdpChanged);
|
new Handler().post( () -> mInvariantDeviceProfile.verifyConfigChangedInBackground(context));
|
|
if (!mContext.getResources().getBoolean(R.bool.notification_dots_enabled)) {
|
mNotificationDotsObserver = null;
|
} else {
|
// Register an observer to rebind the notification listener when dots are re-enabled.
|
mNotificationDotsObserver =
|
newNotificationSettingsObserver(mContext, this::onNotificationSettingsChanged);
|
mNotificationDotsObserver.register();
|
mNotificationDotsObserver.dispatchOnChange();
|
}
|
}
|
|
protected void onNotificationSettingsChanged(boolean areNotificationDotsEnabled) {
|
if (areNotificationDotsEnabled) {
|
NotificationListener.requestRebind(new ComponentName(
|
mContext, NotificationListener.class));
|
}
|
}
|
|
private void onIdpChanged(int changeFlags, InvariantDeviceProfile idp) {
|
if (changeFlags == 0) {
|
return;
|
}
|
|
if ((changeFlags & CHANGE_FLAG_ICON_PARAMS) != 0) {
|
LauncherIcons.clearPool();
|
mIconCache.updateIconParams(idp.fillResIconDpi, idp.iconBitmapSize);
|
mWidgetCache.refresh();
|
}
|
|
mModel.forceReload();
|
}
|
|
/**
|
* Call from Application.onTerminate(), which is not guaranteed to ever be called.
|
*/
|
public void onTerminate() {
|
mContext.unregisterReceiver(mModel);
|
final LauncherAppsCompat launcherApps = LauncherAppsCompat.getInstance(mContext);
|
launcherApps.removeOnAppsChangedCallback(mModel);
|
PackageInstallerCompat.getInstance(mContext).onStop();
|
if (mNotificationDotsObserver != null) {
|
mNotificationDotsObserver.unregister();
|
}
|
}
|
|
LauncherModel setLauncher(Launcher launcher) {
|
getLocalProvider(mContext).setLauncherProviderChangeListener(launcher);
|
mModel.initialize(launcher);
|
return mModel;
|
}
|
|
public IconCache getIconCache() {
|
return mIconCache;
|
}
|
|
public LauncherModel getModel() {
|
return mModel;
|
}
|
|
public WidgetPreviewLoader getWidgetCache() {
|
return mWidgetCache;
|
}
|
|
public InvariantDeviceProfile getInvariantDeviceProfile() {
|
return mInvariantDeviceProfile;
|
}
|
|
/**
|
* Shorthand for {@link #getInvariantDeviceProfile()}
|
*/
|
public static InvariantDeviceProfile getIDP(Context context) {
|
return InvariantDeviceProfile.INSTANCE.get(context);
|
}
|
|
private static LauncherProvider getLocalProvider(Context context) {
|
try (ContentProviderClient cl = context.getContentResolver()
|
.acquireContentProviderClient(LauncherProvider.AUTHORITY)) {
|
return (LauncherProvider) cl.getLocalContentProvider();
|
}
|
}
|
|
public boolean isDisableAllApps() {
|
return mContext.getResources().getBoolean(R.bool.disable_allapp);
|
}
|
|
}
|
