com/android/systemui/SizeCompatModeActivityController.java - platform/prebuilts/fullsdk/sources/android-30 - Git at Google

 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.systemui;

 import android.app.ActivityTaskManager;
 import android.content.Context;
 import android.content.res.ColorStateList;
 import android.graphics.Color;
 import android.graphics.PixelFormat;
 import android.graphics.drawable.Drawable;
 import android.graphics.drawable.GradientDrawable;
 import android.graphics.drawable.RippleDrawable;
 import android.hardware.display.DisplayManager;
 import android.inputmethodservice.InputMethodService;
 import android.os.IBinder;
 import android.os.RemoteException;
 import android.util.Log;
 import android.util.SparseArray;
 import android.view.Display;
 import android.view.Gravity;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.WindowManager;
 import android.widget.Button;
 import android.widget.ImageButton;
 import android.widget.LinearLayout;
 import android.widget.PopupWindow;

 import com.android.internal.annotations.VisibleForTesting;
 import com.android.systemui.shared.system.ActivityManagerWrapper;
 import com.android.systemui.shared.system.TaskStackChangeListener;
 import com.android.systemui.statusbar.CommandQueue;

 import java.lang.ref.WeakReference;

 import javax.inject.Inject;
 import javax.inject.Singleton;

 /** Shows a restart-activity button when the foreground activity is in size compatibility mode. */
 @Singleton
 public class SizeCompatModeActivityController extends SystemUI implements CommandQueue.Callbacks {
     private static final String TAG = "SizeCompatMode";

     /** The showing buttons by display id. */
     private final SparseArray<RestartActivityButton> mActiveButtons = new SparseArray<>(1);
     /** Avoid creating display context frequently for non-default display. */
     private final SparseArray<WeakReference<Context>> mDisplayContextCache = new SparseArray<>(0);
     private final CommandQueue mCommandQueue;

     /** Only show once automatically in the process life. */
     private boolean mHasShownHint;

     @VisibleForTesting
     @Inject
     SizeCompatModeActivityController(Context context, ActivityManagerWrapper am,
             CommandQueue commandQueue) {
         super(context);
         mCommandQueue = commandQueue;
         am.registerTaskStackListener(new TaskStackChangeListener() {
             @Override
             public void onSizeCompatModeActivityChanged(int displayId, IBinder activityToken) {
                 // Note the callback already runs on main thread.
                 updateRestartButton(displayId, activityToken);
             }
         });
     }

     @Override
     public void start() {
         mCommandQueue.addCallback(this);
     }

     @Override
     public void setImeWindowStatus(int displayId, IBinder token, int vis, int backDisposition,
             boolean showImeSwitcher) {
         RestartActivityButton button = mActiveButtons.get(displayId);
         if (button == null) {
             return;
         }
         boolean imeShown = (vis & InputMethodService.IME_VISIBLE) != 0;
         int newVisibility = imeShown ? View.GONE : View.VISIBLE;
         // Hide the button when input method is showing.
         if (button.getVisibility() != newVisibility) {
             button.setVisibility(newVisibility);
         }
     }

     @Override
     public void onDisplayRemoved(int displayId) {
         mDisplayContextCache.remove(displayId);
         removeRestartButton(displayId);
     }

     private void removeRestartButton(int displayId) {
         RestartActivityButton button = mActiveButtons.get(displayId);
         if (button != null) {
             button.remove();
             mActiveButtons.remove(displayId);
         }
     }

     private void updateRestartButton(int displayId, IBinder activityToken) {
         if (activityToken == null) {
             // Null token means the current foreground activity is not in size compatibility mode.
             removeRestartButton(displayId);
             return;
         }

         RestartActivityButton restartButton = mActiveButtons.get(displayId);
         if (restartButton != null) {
             restartButton.updateLastTargetActivity(activityToken);
             return;
         }

         Context context = getOrCreateDisplayContext(displayId);
         if (context == null) {
             Log.i(TAG, "Cannot get context for display " + displayId);
             return;
         }

         restartButton = createRestartButton(context);
         restartButton.updateLastTargetActivity(activityToken);
         if (restartButton.show()) {
             mActiveButtons.append(displayId, restartButton);
         } else {
             onDisplayRemoved(displayId);
         }
     }

     @VisibleForTesting
     RestartActivityButton createRestartButton(Context context) {
         RestartActivityButton button = new RestartActivityButton(context, mHasShownHint);
         mHasShownHint = true;
         return button;
     }

     private Context getOrCreateDisplayContext(int displayId) {
         if (displayId == Display.DEFAULT_DISPLAY) {
             return mContext;
         }
         Context context = null;
         WeakReference<Context> ref = mDisplayContextCache.get(displayId);
         if (ref != null) {
             context = ref.get();
         }
         if (context == null) {
             Display display = mContext.getSystemService(DisplayManager.class).getDisplay(displayId);
             if (display != null) {
                 context = mContext.createDisplayContext(display);
                 mDisplayContextCache.put(displayId, new WeakReference<Context>(context));
             }
         }
         return context;
     }

     @VisibleForTesting
     static class RestartActivityButton extends ImageButton implements View.OnClickListener,
             View.OnLongClickListener {

         final WindowManager.LayoutParams mWinParams;
         final boolean mShouldShowHint;
         IBinder mLastActivityToken;

         final int mPopupOffsetX;
         final int mPopupOffsetY;
         PopupWindow mShowingHint;

         RestartActivityButton(Context context, boolean hasShownHint) {
             super(context);
             mShouldShowHint = !hasShownHint;
             Drawable drawable = context.getDrawable(R.drawable.btn_restart);
             setImageDrawable(drawable);
             setContentDescription(context.getString(R.string.restart_button_description));

             int drawableW = drawable.getIntrinsicWidth();
             int drawableH = drawable.getIntrinsicHeight();
             mPopupOffsetX = drawableW / 2;
             mPopupOffsetY = drawableH * 2;

             ColorStateList color = ColorStateList.valueOf(Color.LTGRAY);
             GradientDrawable mask = new GradientDrawable();
             mask.setShape(GradientDrawable.OVAL);
             mask.setColor(color);
             setBackground(new RippleDrawable(color, null /* content */, mask));
             setOnClickListener(this);
             setOnLongClickListener(this);

             mWinParams = new WindowManager.LayoutParams();
             mWinParams.gravity = getGravity(getResources().getConfiguration().getLayoutDirection());
             mWinParams.width = drawableW * 2;
             mWinParams.height = drawableH * 2;
             mWinParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
             mWinParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                     | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
             mWinParams.format = PixelFormat.TRANSLUCENT;
             mWinParams.privateFlags |= WindowManager.LayoutParams.SYSTEM_FLAG_SHOW_FOR_ALL_USERS;
             mWinParams.setTitle(SizeCompatModeActivityController.class.getSimpleName()
                     + context.getDisplayId());
         }

         void updateLastTargetActivity(IBinder activityToken) {
             mLastActivityToken = activityToken;
         }

         /** @return {@code false} if the target display is invalid. */
         boolean show() {
             try {
                 getContext().getSystemService(WindowManager.class).addView(this, mWinParams);
             } catch (WindowManager.InvalidDisplayException e) {
                 // The target display may have been removed when the callback has just arrived.
                 Log.w(TAG, "Cannot show on display " + getContext().getDisplayId(), e);
                 return false;
             }
             return true;
         }

         void remove() {
             if (mShowingHint != null) {
                 mShowingHint.dismiss();
             }
             getContext().getSystemService(WindowManager.class).removeViewImmediate(this);
         }

         @Override
         public void onClick(View v) {
             try {
                 ActivityTaskManager.getService().restartActivityProcessIfVisible(
                         mLastActivityToken);
             } catch (RemoteException e) {
                 Log.w(TAG, "Unable to restart activity", e);
             }
         }

         @Override
         public boolean onLongClick(View v) {
             showHint();
             return true;
         }

         @Override
         protected void onAttachedToWindow() {
             super.onAttachedToWindow();
             if (mShouldShowHint) {
                 showHint();
             }
         }

         @Override
         public void setLayoutDirection(int layoutDirection) {
             int gravity = getGravity(layoutDirection);
             if (mWinParams.gravity != gravity) {
                 mWinParams.gravity = gravity;
                 if (mShowingHint != null) {
                     mShowingHint.dismiss();
                     showHint();
                 }
                 getContext().getSystemService(WindowManager.class).updateViewLayout(this,
                         mWinParams);
             }
             super.setLayoutDirection(layoutDirection);
         }

         void showHint() {
             if (mShowingHint != null) {
                 return;
             }

             View popupView = LayoutInflater.from(getContext()).inflate(
                     R.layout.size_compat_mode_hint, null /* root */);
             PopupWindow popupWindow = new PopupWindow(popupView,
                     LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
             popupWindow.setWindowLayoutType(mWinParams.type);
             popupWindow.setElevation(getResources().getDimension(R.dimen.bubble_elevation));
             popupWindow.setAnimationStyle(android.R.style.Animation_InputMethod);
             popupWindow.setClippingEnabled(false);
             popupWindow.setOnDismissListener(() -> mShowingHint = null);
             mShowingHint = popupWindow;

             Button gotItButton = popupView.findViewById(R.id.got_it);
             gotItButton.setBackground(new RippleDrawable(ColorStateList.valueOf(Color.LTGRAY),
                     null /* content */, null /* mask */));
             gotItButton.setOnClickListener(view -> popupWindow.dismiss());
             popupWindow.showAtLocation(this, mWinParams.gravity, mPopupOffsetX, mPopupOffsetY);
         }

         private static int getGravity(int layoutDirection) {
             return Gravity.BOTTOM
                     | (layoutDirection == View.LAYOUT_DIRECTION_RTL ? Gravity.START : Gravity.END);
         }
     }
 }
	/*
	* Copyright (C) 2019 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.systemui;

	import android.app.ActivityTaskManager;
	import android.content.Context;
	import android.content.res.ColorStateList;
	import android.graphics.Color;
	import android.graphics.PixelFormat;
	import android.graphics.drawable.Drawable;
	import android.graphics.drawable.GradientDrawable;
	import android.graphics.drawable.RippleDrawable;
	import android.hardware.display.DisplayManager;
	import android.inputmethodservice.InputMethodService;
	import android.os.IBinder;
	import android.os.RemoteException;
	import android.util.Log;
	import android.util.SparseArray;
	import android.view.Display;
	import android.view.Gravity;
	import android.view.LayoutInflater;
	import android.view.View;
	import android.view.WindowManager;
	import android.widget.Button;
	import android.widget.ImageButton;
	import android.widget.LinearLayout;
	import android.widget.PopupWindow;

	import com.android.internal.annotations.VisibleForTesting;
	import com.android.systemui.shared.system.ActivityManagerWrapper;
	import com.android.systemui.shared.system.TaskStackChangeListener;
	import com.android.systemui.statusbar.CommandQueue;

	import java.lang.ref.WeakReference;

	import javax.inject.Inject;
	import javax.inject.Singleton;

	/** Shows a restart-activity button when the foreground activity is in size compatibility mode. */
	@Singleton
	public class SizeCompatModeActivityController extends SystemUI implements CommandQueue.Callbacks {
	private static final String TAG = "SizeCompatMode";

	/** The showing buttons by display id. */
	private final SparseArray<RestartActivityButton> mActiveButtons = new SparseArray<>(1);
	/** Avoid creating display context frequently for non-default display. */
	private final SparseArray<WeakReference<Context>> mDisplayContextCache = new SparseArray<>(0);
	private final CommandQueue mCommandQueue;

	/** Only show once automatically in the process life. */
	private boolean mHasShownHint;

	@VisibleForTesting
	@Inject
	SizeCompatModeActivityController(Context context, ActivityManagerWrapper am,
	CommandQueue commandQueue) {
	super(context);
	mCommandQueue = commandQueue;
	am.registerTaskStackListener(new TaskStackChangeListener() {
	@Override
	public void onSizeCompatModeActivityChanged(int displayId, IBinder activityToken) {
	// Note the callback already runs on main thread.
	updateRestartButton(displayId, activityToken);
	}
	});
	}

	@Override
	public void start() {
	mCommandQueue.addCallback(this);
	}

	@Override
	public void setImeWindowStatus(int displayId, IBinder token, int vis, int backDisposition,
	boolean showImeSwitcher) {
	RestartActivityButton button = mActiveButtons.get(displayId);
	if (button == null) {
	return;
	}
	boolean imeShown = (vis & InputMethodService.IME_VISIBLE) != 0;
	int newVisibility = imeShown ? View.GONE : View.VISIBLE;
	// Hide the button when input method is showing.
	if (button.getVisibility() != newVisibility) {
	button.setVisibility(newVisibility);
	}
	}

	@Override
	public void onDisplayRemoved(int displayId) {
	mDisplayContextCache.remove(displayId);
	removeRestartButton(displayId);
	}

	private void removeRestartButton(int displayId) {
	RestartActivityButton button = mActiveButtons.get(displayId);
	if (button != null) {
	button.remove();
	mActiveButtons.remove(displayId);
	}
	}

	private void updateRestartButton(int displayId, IBinder activityToken) {
	if (activityToken == null) {
	// Null token means the current foreground activity is not in size compatibility mode.
	removeRestartButton(displayId);
	return;
	}

	RestartActivityButton restartButton = mActiveButtons.get(displayId);
	if (restartButton != null) {
	restartButton.updateLastTargetActivity(activityToken);
	return;
	}

	Context context = getOrCreateDisplayContext(displayId);
	if (context == null) {
	Log.i(TAG, "Cannot get context for display " + displayId);
	return;
	}

	restartButton = createRestartButton(context);
	restartButton.updateLastTargetActivity(activityToken);
	if (restartButton.show()) {
	mActiveButtons.append(displayId, restartButton);
	} else {
	onDisplayRemoved(displayId);
	}
	}

	@VisibleForTesting
	RestartActivityButton createRestartButton(Context context) {
	RestartActivityButton button = new RestartActivityButton(context, mHasShownHint);
	mHasShownHint = true;
	return button;
	}

	private Context getOrCreateDisplayContext(int displayId) {
	if (displayId == Display.DEFAULT_DISPLAY) {
	return mContext;
	}
	Context context = null;
	WeakReference<Context> ref = mDisplayContextCache.get(displayId);
	if (ref != null) {
	context = ref.get();
	}
	if (context == null) {
	Display display = mContext.getSystemService(DisplayManager.class).getDisplay(displayId);
	if (display != null) {
	context = mContext.createDisplayContext(display);
	mDisplayContextCache.put(displayId, new WeakReference<Context>(context));
	}
	}
	return context;
	}

	@VisibleForTesting
	static class RestartActivityButton extends ImageButton implements View.OnClickListener,
	View.OnLongClickListener {

	final WindowManager.LayoutParams mWinParams;
	final boolean mShouldShowHint;
	IBinder mLastActivityToken;

	final int mPopupOffsetX;
	final int mPopupOffsetY;
	PopupWindow mShowingHint;

	RestartActivityButton(Context context, boolean hasShownHint) {
	super(context);
	mShouldShowHint = !hasShownHint;
	Drawable drawable = context.getDrawable(R.drawable.btn_restart);
	setImageDrawable(drawable);
	setContentDescription(context.getString(R.string.restart_button_description));

	int drawableW = drawable.getIntrinsicWidth();
	int drawableH = drawable.getIntrinsicHeight();
	mPopupOffsetX = drawableW / 2;
	mPopupOffsetY = drawableH * 2;

	ColorStateList color = ColorStateList.valueOf(Color.LTGRAY);
	GradientDrawable mask = new GradientDrawable();
	mask.setShape(GradientDrawable.OVAL);
	mask.setColor(color);
	setBackground(new RippleDrawable(color, null /* content */, mask));
	setOnClickListener(this);
	setOnLongClickListener(this);

	mWinParams = new WindowManager.LayoutParams();
	mWinParams.gravity = getGravity(getResources().getConfiguration().getLayoutDirection());
	mWinParams.width = drawableW * 2;
	mWinParams.height = drawableH * 2;
	mWinParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
	mWinParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
	\| WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
	mWinParams.format = PixelFormat.TRANSLUCENT;
	mWinParams.privateFlags \|= WindowManager.LayoutParams.SYSTEM_FLAG_SHOW_FOR_ALL_USERS;
	mWinParams.setTitle(SizeCompatModeActivityController.class.getSimpleName()
	+ context.getDisplayId());
	}

	void updateLastTargetActivity(IBinder activityToken) {
	mLastActivityToken = activityToken;
	}

	/** @return {@code false} if the target display is invalid. */
	boolean show() {
	try {
	getContext().getSystemService(WindowManager.class).addView(this, mWinParams);
	} catch (WindowManager.InvalidDisplayException e) {
	// The target display may have been removed when the callback has just arrived.
	Log.w(TAG, "Cannot show on display " + getContext().getDisplayId(), e);
	return false;
	}
	return true;
	}

	void remove() {
	if (mShowingHint != null) {
	mShowingHint.dismiss();
	}
	getContext().getSystemService(WindowManager.class).removeViewImmediate(this);
	}

	@Override
	public void onClick(View v) {
	try {
	ActivityTaskManager.getService().restartActivityProcessIfVisible(
	mLastActivityToken);
	} catch (RemoteException e) {
	Log.w(TAG, "Unable to restart activity", e);
	}
	}

	@Override
	public boolean onLongClick(View v) {
	showHint();
	return true;
	}

	@Override
	protected void onAttachedToWindow() {
	super.onAttachedToWindow();
	if (mShouldShowHint) {
	showHint();
	}
	}

	@Override
	public void setLayoutDirection(int layoutDirection) {
	int gravity = getGravity(layoutDirection);
	if (mWinParams.gravity != gravity) {
	mWinParams.gravity = gravity;
	if (mShowingHint != null) {
	mShowingHint.dismiss();
	showHint();
	}
	getContext().getSystemService(WindowManager.class).updateViewLayout(this,
	mWinParams);
	}
	super.setLayoutDirection(layoutDirection);
	}

	void showHint() {
	if (mShowingHint != null) {
	return;
	}

	View popupView = LayoutInflater.from(getContext()).inflate(
	R.layout.size_compat_mode_hint, null /* root */);
	PopupWindow popupWindow = new PopupWindow(popupView,
	LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
	popupWindow.setWindowLayoutType(mWinParams.type);
	popupWindow.setElevation(getResources().getDimension(R.dimen.bubble_elevation));
	popupWindow.setAnimationStyle(android.R.style.Animation_InputMethod);
	popupWindow.setClippingEnabled(false);
	popupWindow.setOnDismissListener(() -> mShowingHint = null);
	mShowingHint = popupWindow;

	Button gotItButton = popupView.findViewById(R.id.got_it);
	gotItButton.setBackground(new RippleDrawable(ColorStateList.valueOf(Color.LTGRAY),
	null /* content /, null / mask */));
	gotItButton.setOnClickListener(view -> popupWindow.dismiss());
	popupWindow.showAtLocation(this, mWinParams.gravity, mPopupOffsetX, mPopupOffsetY);
	}

	private static int getGravity(int layoutDirection) {
	return Gravity.BOTTOM
	\| (layoutDirection == View.LAYOUT_DIRECTION_RTL ? Gravity.START : Gravity.END);
	}
	}
	}