/* * Copyright (C) 2014 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.widget; import static android.graphics.Paint.ANTI_ALIAS_FLAG; import static android.graphics.Paint.DITHER_FLAG; import static android.graphics.Paint.FILTER_BITMAP_FLAG; import static com.android.launcher3.graphics.PreloadIconDrawable.newPendingIcon; import static com.android.launcher3.model.data.LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY; import static com.android.launcher3.util.Executors.MAIN_EXECUTOR; import android.appwidget.AppWidgetProviderInfo; import android.content.Context; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Matrix; import android.graphics.Paint; import android.graphics.PorterDuff; import android.graphics.Rect; import android.graphics.RectF; import android.graphics.drawable.ColorDrawable; import android.graphics.drawable.Drawable; import android.os.Bundle; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.text.Layout; import android.text.StaticLayout; import android.text.TextPaint; import android.text.TextUtils; import android.util.SizeF; import android.util.TypedValue; import android.view.ContextThemeWrapper; import android.view.View; import android.view.View.OnClickListener; import android.widget.RemoteViews; import androidx.annotation.NonNull; import androidx.annotation.Nullable; import com.android.launcher3.DeviceProfile; import com.android.launcher3.Launcher; import com.android.launcher3.LauncherAppState; import com.android.launcher3.R; import com.android.launcher3.icons.FastBitmapDrawable; import com.android.launcher3.icons.IconCache.ItemInfoUpdateReceiver; import com.android.launcher3.model.data.ItemInfoWithIcon; import com.android.launcher3.model.data.LauncherAppWidgetInfo; import com.android.launcher3.model.data.PackageItemInfo; import com.android.launcher3.util.RunnableList; import com.android.launcher3.util.SafeCloseable; import com.android.launcher3.util.Themes; import com.android.launcher3.widget.ListenableAppWidgetHost.ProviderChangedListener; import java.util.List; public class PendingAppWidgetHostView extends LauncherAppWidgetHostView implements OnClickListener, ItemInfoUpdateReceiver { private static final float SETUP_ICON_SIZE_FACTOR = 2f / 5; private static final float MIN_SATURATION = 0.7f; private static final int FLAG_DRAW_SETTINGS = 1; private static final int FLAG_DRAW_ICON = 2; private static final int FLAG_DRAW_LABEL = 4; private static final int DEFERRED_ALPHA = 0x77; private final Rect mRect = new Rect(); private final Matrix mMatrix = new Matrix(); private final RectF mPreviewBitmapRect = new RectF(); private final RectF mCanvasRect = new RectF(); private final Handler mHandler = new Handler(Looper.getMainLooper()); private final RunnableList mOnDetachCleanup = new RunnableList(); private final LauncherWidgetHolder mWidgetHolder; private final LauncherAppWidgetProviderInfo mAppwidget; private final LauncherAppWidgetInfo mInfo; private final int mStartState; private final boolean mDisabledForSafeMode; private final CharSequence mLabel; private OnClickListener mClickListener; private int mDragFlags; private Drawable mCenterDrawable; private Drawable mSettingIconDrawable; private boolean mDrawableSizeChanged; private boolean mIsDeferredWidget; private final TextPaint mPaint; private final Paint mPreviewPaint; private Layout mSetupTextLayout; @Nullable private Bitmap mPreviewBitmap; public PendingAppWidgetHostView(Context context, LauncherWidgetHolder widgetHolder, LauncherAppWidgetInfo info, @Nullable LauncherAppWidgetProviderInfo appWidget) { this(context, widgetHolder, info, appWidget, null); } public PendingAppWidgetHostView(Context context, LauncherWidgetHolder widgetHolder, LauncherAppWidgetInfo info, @Nullable LauncherAppWidgetProviderInfo appWidget, @Nullable Bitmap previewBitmap) { this(context, widgetHolder, info, appWidget, context.getResources().getText(R.string.gadget_complete_setup_text), previewBitmap); super.updateAppWidget(null); setOnClickListener(mActivityContext.getItemOnClickListener()); if (info.pendingItemInfo == null) { info.pendingItemInfo = new PackageItemInfo(info.providerName.getPackageName(), info.user); LauncherAppState.getInstance(context).getIconCache() .updateIconInBackground(this, info.pendingItemInfo); } else { reapplyItemInfo(info.pendingItemInfo); } } public PendingAppWidgetHostView( Context context, LauncherWidgetHolder widgetHolder, int appWidgetId, @NonNull LauncherAppWidgetProviderInfo appWidget) { this(context, widgetHolder, new LauncherAppWidgetInfo(appWidgetId, appWidget.provider), appWidget, appWidget.label, null); getBackground().mutate().setAlpha(DEFERRED_ALPHA); mCenterDrawable = new ColorDrawable(Color.TRANSPARENT); mDragFlags = FLAG_DRAW_LABEL; mDrawableSizeChanged = true; mIsDeferredWidget = true; } /** * Set {@link Bitmap} of widget preview and update background drawable. When showing preview * bitmap, we shouldn't draw background. */ public void setPreviewBitmapAndUpdateBackground(@Nullable Bitmap previewBitmap) { setBackgroundResource(previewBitmap != null ? 0 : R.drawable.pending_widget_bg); if (this.mPreviewBitmap == previewBitmap) { return; } this.mPreviewBitmap = previewBitmap; invalidate(); } private PendingAppWidgetHostView(Context context, LauncherWidgetHolder widgetHolder, LauncherAppWidgetInfo info, LauncherAppWidgetProviderInfo appwidget, CharSequence label, @Nullable Bitmap previewBitmap) { super(new ContextThemeWrapper(context, R.style.WidgetContainerTheme)); mWidgetHolder = widgetHolder; mAppwidget = appwidget; mInfo = info; mStartState = info.restoreStatus; mDisabledForSafeMode = LauncherAppState.getInstance(context).isSafeModeEnabled(); mLabel = label; mPaint = new TextPaint(); mPaint.setColor(Themes.getAttrColor(getContext(), android.R.attr.textColorPrimary)); mPaint.setTextSize(TypedValue.applyDimension( TypedValue.COMPLEX_UNIT_PX, mActivityContext.getDeviceProfile().iconTextSizePx, getResources().getDisplayMetrics())); mPreviewPaint = new Paint(ANTI_ALIAS_FLAG | DITHER_FLAG | FILTER_BITMAP_FLAG); setWillNotDraw(false); setPreviewBitmapAndUpdateBackground(previewBitmap); } @Override public AppWidgetProviderInfo getAppWidgetInfo() { return mAppwidget; } @Override public int getAppWidgetId() { return mInfo.appWidgetId; } @Override public void updateAppWidget(RemoteViews remoteViews) { checkIfRestored(); } private void checkIfRestored() { WidgetManagerHelper widgetManagerHelper = new WidgetManagerHelper(getContext()); if (widgetManagerHelper.isAppWidgetRestored(mInfo.appWidgetId)) { MAIN_EXECUTOR.getHandler().post(this::reInflate); } } public boolean isDeferredWidget() { return mIsDeferredWidget; } @Override protected void onAttachedToWindow() { super.onAttachedToWindow(); mOnDetachCleanup.executeAllAndClear(); if ((mAppwidget != null) && !mInfo.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID) && mInfo.restoreStatus != LauncherAppWidgetInfo.RESTORE_COMPLETED) { // If the widget is not completely restored, but has a valid ID, then listen of // updates from provider app for potential restore complete. SafeCloseable updateCleanup = mWidgetHolder.addOnUpdateListener( mInfo.appWidgetId, mAppwidget, this::checkIfRestored); mOnDetachCleanup.add(updateCleanup::close); checkIfRestored(); } } @Override protected void onDetachedFromWindow() { super.onDetachedFromWindow(); mOnDetachCleanup.executeAllAndClear(); } /** * Forces the Launcher to reinflate the widget view */ public void reInflate() { if (!isAttachedToWindow()) { return; } LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) getTag(); if (info == null) { // This occurs when LauncherAppWidgetHostView is used to render a preview layout. return; } if (mActivityContext instanceof Launcher launcher) { // Remove and rebind the current widget (which was inflated in the wrong // orientation), but don't delete it from the database launcher.removeItem(this, info, false /* deleteFromDb */, "widget removed because of configuration change"); launcher.bindAppWidget(info); } } @Override public void updateAppWidgetSize(Bundle newOptions, int minWidth, int minHeight, int maxWidth, int maxHeight) { // No-op } @Override public void updateAppWidgetSize(Bundle newOptions, List sizes) { // No-op } @Override protected View getDefaultView() { View defaultView = mInflater.inflate(R.layout.appwidget_not_ready, this, false); defaultView.setOnClickListener(this); applyState(); invalidate(); return defaultView; } @Override public void setOnClickListener(OnClickListener l) { mClickListener = l; } public boolean isReinflateIfNeeded() { return mStartState != mInfo.restoreStatus; } @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { super.onSizeChanged(w, h, oldw, oldh); mDrawableSizeChanged = true; } @Override public void reapplyItemInfo(ItemInfoWithIcon info) { if (mCenterDrawable != null) { mCenterDrawable.setCallback(null); mCenterDrawable = null; } mDragFlags = FLAG_DRAW_ICON; // The view displays three modes, // 1) App icon in the center // 2) Preload icon in the center // 3) App icon in the center with a setup icon on the top left corner. if (mDisabledForSafeMode) { FastBitmapDrawable disabledIcon = info.newIcon(getContext()); disabledIcon.setIsDisabled(true); mCenterDrawable = disabledIcon; mSettingIconDrawable = null; } else if (isReadyForClickSetup()) { mCenterDrawable = info.newIcon(getContext()); mSettingIconDrawable = getResources().getDrawable(R.drawable.ic_setting).mutate(); updateSettingColor(info.bitmap.color); mDragFlags |= FLAG_DRAW_SETTINGS | FLAG_DRAW_LABEL; } else { mCenterDrawable = newPendingIcon(getContext(), info); mSettingIconDrawable = null; applyState(); } mCenterDrawable.setCallback(this); mDrawableSizeChanged = true; invalidate(); } private void updateSettingColor(int dominantColor) { // Make the dominant color bright. float[] hsv = new float[3]; Color.colorToHSV(dominantColor, hsv); hsv[1] = Math.min(hsv[1], MIN_SATURATION); hsv[2] = 1; mSettingIconDrawable.setColorFilter(Color.HSVToColor(hsv), PorterDuff.Mode.SRC_IN); } @Override protected boolean verifyDrawable(Drawable who) { return (who == mCenterDrawable) || super.verifyDrawable(who); } public void applyState() { if (mCenterDrawable instanceof FastBitmapDrawable fb && mInfo.pendingItemInfo != null && !fb.isSameInfo(mInfo.pendingItemInfo.bitmap)) { reapplyItemInfo(mInfo.pendingItemInfo); } if (mCenterDrawable != null) { mCenterDrawable.setLevel(Math.max(mInfo.installProgress, 0)); } } @Override public void onClick(View v) { // AppWidgetHostView blocks all click events on the root view. Instead handle click events // on the content and pass it along. if (mClickListener != null) { mClickListener.onClick(this); } } /** * A pending widget is ready for setup after the provider is installed and * 1) Widget id is not valid: the widget id is not yet bound to the provider, probably * because the launcher doesn't have appropriate permissions. * Note that we would still have an allocated id as that does not * require any permissions and can be done during view inflation. * 2) UI is not ready: the id is valid and the bound. But the widget has a configure activity * which needs to be called once. */ public boolean isReadyForClickSetup() { return !mInfo.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY) && (mInfo.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_UI_NOT_READY) || mInfo.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)); } private void updateDrawableBounds() { DeviceProfile grid = mActivityContext.getDeviceProfile(); int paddingTop = getPaddingTop(); int paddingBottom = getPaddingBottom(); int paddingLeft = getPaddingLeft(); int paddingRight = getPaddingRight(); int minPadding = getResources() .getDimensionPixelSize(R.dimen.pending_widget_min_padding); int availableWidth = getWidth() - paddingLeft - paddingRight - 2 * minPadding; int availableHeight = getHeight() - paddingTop - paddingBottom - 2 * minPadding; float iconSize = ((mDragFlags & FLAG_DRAW_ICON) == 0) ? 0 : Math.max(0, Math.min(availableWidth, availableHeight)); // Use twice the setting size factor, as the setting is drawn at a corner and the // icon is drawn in the center. float settingIconScaleFactor = ((mDragFlags & FLAG_DRAW_SETTINGS) == 0) ? 0 : 1 + SETUP_ICON_SIZE_FACTOR * 2; int maxSize = Math.max(availableWidth, availableHeight); if (iconSize * settingIconScaleFactor > maxSize) { // There is an overlap iconSize = maxSize / settingIconScaleFactor; } int actualIconSize = (int) Math.min(iconSize, grid.iconSizePx); // Icon top when we do not draw the text int iconTop = (getHeight() - actualIconSize) / 2; mSetupTextLayout = null; if (availableWidth > 0 && !TextUtils.isEmpty(mLabel) && ((mDragFlags & FLAG_DRAW_LABEL) != 0)) { // Recreate the setup text. mSetupTextLayout = new StaticLayout( mLabel, mPaint, availableWidth, Layout.Alignment.ALIGN_CENTER, 1, 0, true); int textHeight = mSetupTextLayout.getHeight(); // Extra icon size due to the setting icon float minHeightWithText = textHeight + actualIconSize * settingIconScaleFactor + grid.iconDrawablePaddingPx; if (minHeightWithText < availableHeight) { // We can draw the text as well iconTop = (getHeight() - textHeight - grid.iconDrawablePaddingPx - actualIconSize) / 2; } else { // We can't draw the text. Let the iconTop be same as before. mSetupTextLayout = null; } } mRect.set(0, 0, actualIconSize, actualIconSize); mRect.offset((getWidth() - actualIconSize) / 2, iconTop); mCenterDrawable.setBounds(mRect); if (mSettingIconDrawable != null) { mRect.left = paddingLeft + minPadding; mRect.right = mRect.left + (int) (SETUP_ICON_SIZE_FACTOR * actualIconSize); mRect.top = paddingTop + minPadding; mRect.bottom = mRect.top + (int) (SETUP_ICON_SIZE_FACTOR * actualIconSize); mSettingIconDrawable.setBounds(mRect); } if (mSetupTextLayout != null) { // Set up position for dragging the text mRect.left = paddingLeft + minPadding; mRect.top = mCenterDrawable.getBounds().bottom + grid.iconDrawablePaddingPx; } } @Override protected void onDraw(Canvas canvas) { if (mPreviewBitmap != null && (mInfo.restoreStatus & LauncherAppWidgetInfo.FLAG_UI_NOT_READY) != 0) { mPreviewBitmapRect.set(0, 0, mPreviewBitmap.getWidth(), mPreviewBitmap.getHeight()); mCanvasRect.set(0, 0, getWidth(), getHeight()); mMatrix.setRectToRect(mPreviewBitmapRect, mCanvasRect, Matrix.ScaleToFit.CENTER); canvas.drawBitmap(mPreviewBitmap, mMatrix, mPreviewPaint); return; } if (mCenterDrawable == null) { // Nothing to draw return; } if (mDrawableSizeChanged) { updateDrawableBounds(); mDrawableSizeChanged = false; } mCenterDrawable.draw(canvas); if (mSettingIconDrawable != null) { mSettingIconDrawable.draw(canvas); } if (mSetupTextLayout != null) { canvas.save(); canvas.translate(mRect.left, mRect.top); mSetupTextLayout.draw(canvas); canvas.restore(); } } /** * Creates a runnable runnable which tries to refresh the widget if it is restored */ public void postProviderAvailabilityCheck() { if (!mInfo.hasRestoreFlag(FLAG_PROVIDER_NOT_READY) && getAppWidgetInfo() == null) { // If the info state suggests that the provider is ready, but there is no // provider info attached on this pending view, recreate when the provider is available DeferredWidgetRefresh restoreRunnable = new DeferredWidgetRefresh(); mOnDetachCleanup.add(restoreRunnable::cleanup); mHandler.post(restoreRunnable::notifyWidgetProvidersChanged); } } /** * Used as a workaround to ensure that the AppWidgetService receives the * PACKAGE_ADDED broadcast before updating widgets. * * This class will periodically check for the availability of the WidgetProvider as a result * of providerChanged callback from the host. When the provider is available or a timeout of * 10-sec is reached, it reinflates the pending-widget which in-turn goes through the process * of re-evaluating the pending state of the widget, */ private class DeferredWidgetRefresh implements Runnable, ProviderChangedListener { private boolean mRefreshPending = true; DeferredWidgetRefresh() { mWidgetHolder.addProviderChangeListener(this); // Force refresh after 10 seconds, if we don't get the provider changed event. // This could happen when the provider is no longer available in the app. Message msg = Message.obtain(getHandler(), this); msg.obj = DeferredWidgetRefresh.class; mHandler.sendMessageDelayed(msg, 10000); } /** * Reinflate the widget if it is still attached. */ @Override public void run() { cleanup(); if (mRefreshPending) { reInflate(); mRefreshPending = false; } } @Override public void notifyWidgetProvidersChanged() { final AppWidgetProviderInfo widgetInfo; WidgetManagerHelper widgetHelper = new WidgetManagerHelper(getContext()); if (mInfo.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) { widgetInfo = widgetHelper.findProvider(mInfo.providerName, mInfo.user); } else { widgetInfo = widgetHelper.getLauncherAppWidgetInfo(mInfo.appWidgetId, mInfo.getTargetComponent()); } if (widgetInfo != null) { run(); } } /** * Removes any scheduled callbacks and change listeners, no-op if nothing is scheduled */ public void cleanup() { mWidgetHolder.removeProviderChangeListener(this); mHandler.removeCallbacks(this); } } }