void onPipMinimize();
/**
- * Called when the PIP requested to be expanded.
+ * Called when the PIP requested to be dismissed.
*/
void onPipDismiss();
}
import android.view.MotionEvent;
import android.view.ViewConfiguration;
+import com.android.internal.logging.MetricsLogger;
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.internal.os.BackgroundThread;
import com.android.internal.policy.PipMotionHelper;
import com.android.internal.policy.PipSnapAlgorithm;
private static final String TAG = "PipTouchHandler";
private static final boolean DEBUG_ALLOW_OUT_OF_BOUNDS_STACK = false;
+ // These values are used for metrics and should never change
+ private static final int METRIC_VALUE_DISMISSED_BY_TAP = 0;
+ private static final int METRIC_VALUE_DISMISSED_BY_DRAG = 1;
+
private static final String TUNER_KEY_DRAG_TO_DISMISS = "pip_drag_to_dismiss";
private static final String TUNER_KEY_ALLOW_MINIMIZE = "pip_allow_minimize";
} else {
unregisterInputConsumer();
}
+ MetricsLogger.visibility(mContext, MetricsEvent.ACTION_PICTURE_IN_PICTURE_MENU,
+ visible);
}
@Override
@Override
public void onPipDismiss() {
BackgroundThread.getHandler().post(PipTouchHandler.this::dismissPinnedStack);
+ MetricsLogger.action(mContext, MetricsEvent.ACTION_PICTURE_IN_PICTURE_DISMISSED,
+ METRIC_VALUE_DISMISSED_BY_TAP);
}
}
}
public void onMinimizedStateChanged(boolean isMinimized) {
+ if (mIsMinimized != isMinimized) {
+ MetricsLogger.action(mContext, MetricsEvent.ACTION_PICTURE_IN_PICTURE_MINIMIZED,
+ isMinimized);
+ }
mIsMinimized = isMinimized;
mSnapAlgorithm.setMinimized(isMinimized);
}
/**
* Flings the PIP to the closest snap target.
*/
- private void flingToSnapTarget(float velocity, float velocityX, float velocityY) {
+ private Rect flingToSnapTarget(float velocity, float velocityX, float velocityY) {
Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(mBoundedPinnedStackBounds,
mPinnedStackBounds, velocityX, velocityY);
if (!mPinnedStackBounds.equals(toBounds)) {
velocity);
mPinnedStackBoundsAnimator.start();
}
+ return toBounds;
}
/**
* Animates the PIP to the closest snap target.
*/
- private void animateToClosestSnapTarget() {
+ private Rect animateToClosestSnapTarget() {
Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(mBoundedPinnedStackBounds,
mPinnedStackBounds);
if (!mPinnedStackBounds.equals(toBounds)) {
toBounds, SNAP_STACK_DURATION, FAST_OUT_SLOW_IN, mUpdatePinnedStackBoundsListener);
mPinnedStackBoundsAnimator.start();
}
+ return toBounds;
}
/**
PointF lastTouch = touchState.getLastTouchPosition();
if (dismissBounds.contains((int) lastTouch.x, (int) lastTouch.y)) {
animateDismissPinnedStack(dismissBounds);
+ MetricsLogger.action(mContext,
+ MetricsEvent.ACTION_PICTURE_IN_PICTURE_DISMISSED,
+ METRIC_VALUE_DISMISSED_BY_DRAG);
return true;
}
}
// OS: O
BACKUP_SETTINGS = 818;
+ // ACTION: Picture-in-picture was explicitly entered for an activity
+ // VALUE: true if it was entered while hiding as a result of moving to another task, false otherwise
+ ACTION_PICTURE_IN_PICTURE_ENTERED = 819;
+
+ // ACTION: The activity currently in picture-in-picture was expanded back to fullscreen
+ // PACKAGE: The package name of the activity that was expanded back to fullscreen
+ ACTION_PICTURE_IN_PICTURE_EXPANDED_TO_FULLSCREEN = 820;
+
+ // ACTION: The activity currently in picture-in-picture was minimized
+ // VALUE: True if the PiP was minimized, false otherwise
+ ACTION_PICTURE_IN_PICTURE_MINIMIZED = 821;
+
+ // ACTION: Picture-in-picture was dismissed via the dismiss button
+ // VALUE: 0 if dismissed by tap, 1 if dismissed by drag
+ ACTION_PICTURE_IN_PICTURE_DISMISSED = 822;
+
+ // ACTION: The visibility of the picture-in-picture meny
+ // VALUE: Whether or not the menu is visible
+ ACTION_PICTURE_IN_PICTURE_MENU = 823;
+
+ // Enclosing category for group of PICTURE_IN_PICTURE_ASPECT_RATIO_FOO events,
+ // logged when the aspect ratio changes
+ ACTION_PICTURE_IN_PICTURE_ASPECT_RATIO_CHANGED = 824;
+
+ // The current aspect ratio of the PiP, logged when it changes.
+ PICTURE_IN_PICTURE_ASPECT_RATIO = 825;
+
// ---- End O Constants, all O constants go above this line ----
// Add new aosp constants above this line.
import android.graphics.Point;
import android.graphics.Rect;
import android.location.LocationManager;
+import android.metrics.LogMaker;
import android.net.Proxy;
import android.net.ProxyInfo;
import android.net.Uri;
import com.google.android.collect.Lists;
import com.google.android.collect.Maps;
+
import com.android.internal.R;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.app.AssistUtils;
import com.android.internal.app.ProcessMap;
import com.android.internal.app.SystemUserHomeActivity;
import com.android.internal.app.procstats.ProcessStats;
+import com.android.internal.logging.MetricsLogger;
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.internal.os.BackgroundThread;
import com.android.internal.os.BatteryStatsImpl;
import com.android.internal.os.IResultReceiver;
mStackSupervisor.moveActivityToPinnedStackLocked(r, "enterPictureInPictureMode",
bounds, true /* moveHomeStackToFront */);
mStackSupervisor.getStack(PINNED_STACK_ID).setPictureInPictureActions(actions);
+
+ MetricsLogger.action(mContext, MetricsEvent.ACTION_PICTURE_IN_PICTURE_ENTERED,
+ r.supportsPictureInPictureWhilePausing);
+ logPictureInPictureArgs(args);
};
if (isKeyguardLocked()) {
stack.setPictureInPictureAspectRatio(r.pictureInPictureArgs.getAspectRatio());
stack.setPictureInPictureActions(r.pictureInPictureArgs.getActions());
}
+ logPictureInPictureArgs(args);
}
} finally {
Binder.restoreCallingIdentity(origId);
}
}
+ private void logPictureInPictureArgs(PictureInPictureArgs args) {
+ if (args.hasSetActions()) {
+ MetricsLogger.histogram(mContext, "tron_varz_picture_in_picture_actions_count",
+ args.getActions().size());
+ }
+ if (args.hasSetAspectRatio()) {
+ LogMaker lm = new LogMaker(MetricsEvent.ACTION_PICTURE_IN_PICTURE_ASPECT_RATIO_CHANGED);
+ lm.addTaggedData(MetricsEvent.PICTURE_IN_PICTURE_ASPECT_RATIO, args.getAspectRatio());
+ MetricsLogger.action(lm);
+ }
+ }
+
private boolean isValidPictureInPictureAspectRatio(float aspectRatio) {
return mMinPipAspectRatio <= aspectRatio && aspectRatio <= mMaxPipAspectRatio;
}
import android.view.Surface;
import com.android.internal.content.ReferrerIntent;
+import com.android.internal.logging.MetricsLogger;
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.internal.os.TransferPipe;
import com.android.internal.statusbar.IStatusBarService;
import com.android.internal.util.ArrayUtils;
// pinned stack is recreated. See moveActivityToPinnedStackLocked().
task.setTaskToReturnTo(isFullscreenStackVisible && onTop ?
APPLICATION_ACTIVITY_TYPE : HOME_ACTIVITY_TYPE);
+ MetricsLogger.action(mService.mContext,
+ MetricsEvent.ACTION_PICTURE_IN_PICTURE_EXPANDED_TO_FULLSCREEN);
}
moveTaskToStackLocked(tasks.get(i).taskId,
FULLSCREEN_WORKSPACE_STACK_ID, onTop, onTop /*forceFocus*/,