Merge "Revert "Revert "Add ability to trace shell transitions""" into tm-qpr-dev am: 9fd0212e95 (ddffd55d) · Commits · e / os / android_frameworks_base

core/java/android/view/IWindowManager.aidl

+15 −0

Original line number	Diff line number	Diff line
		@@ -542,6 +542,21 @@ interface IWindowManager
		*/
		boolean isWindowTraceEnabled();

		/**
		* Starts a transition trace.
		*/
		void startTransitionTrace();

		/**
		* Stops a transition trace.
		*/
		void stopTransitionTrace();

		/**
		* Returns true if transition trace is enabled.
		*/
		boolean isTransitionTraceEnabled();

		/**
		* Gets the windowing mode of the display.
		*

core/proto/android/server/windowmanagertransitiontrace.proto

0 → 100644

+68 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.
		*/

		syntax = "proto3";

		package com.android.server.wm.shell;

		import "frameworks/base/core/proto/android/server/windowmanagerservice.proto";

		option java_multiple_files = true;

		/* Represents a file full of transition entries.
		Encoded, it should start with 0x9 0x57 0x49 0x4e 0x54 0x52 0x41 0x43 0x45 (.TRNTRACE), such
		that it can be easily identified. */
		message TransitionTraceProto {

		/* constant; MAGIC_NUMBER = (long) MAGIC_NUMBER_H << 32 \| MagicNumber.MAGIC_NUMBER_L
		(this is needed because enums have to be 32 bits and there's no nice way to put 64bit
		constants into .proto files. */
		enum MagicNumber {
		INVALID = 0;
		MAGIC_NUMBER_L = 0x544e5254; /* TRNT (little-endian ASCII) */
		MAGIC_NUMBER_H = 0x45434152; /* RACE (little-endian ASCII) */
		}

		fixed64 magic_number = 1; /* Must be the first field, set to value in MagicNumber */
		int64 timestamp = 2; /* The timestamp of when the trace was started. */
		repeated Transition transition = 3;
		}

		message Transition {

		enum State {
		COLLECTING = 0;
		PENDING = -1;
		STARTED = 1;
		PLAYING = 2;
		ABORT = 3;
		FINISHED = 4;
		}

		int32 id = 1;
		int32 transition_type = 2;
		int64 timestamp = 3;
		State state = 5;
		int32 flags = 6;
		repeated ChangeInfo change = 7;
		}

		message ChangeInfo {
		com.android.server.wm.IdentifierProto window_identifier = 1;
		int32 transit_mode = 2;
		bool has_changed = 3;
		int32 change_flags = 4;
		}

services/core/java/com/android/server/wm/Transition.java

+31 −1

Original line number	Diff line number	Diff line
		@@ -95,6 +95,7 @@ import java.lang.annotation.Retention;
		import java.lang.annotation.RetentionPolicy;
		import java.util.ArrayList;
		import java.util.List;
		import java.util.Objects;
		import java.util.function.Predicate;

		/**
		@@ -131,18 +132,27 @@ class Transition extends Binder implements BLASTSyncEngine.TransactionReadyListe
		*/
		private static final int STATE_ABORT = 3;

		/**
		* This transition has finished playing successfully.
		*/
		private static final int STATE_FINISHED = 4;

		@IntDef(prefix = { "STATE_" }, value = {
		STATE_PENDING,
		STATE_COLLECTING,
		STATE_STARTED,
		STATE_PLAYING,
		STATE_ABORT
		STATE_ABORT,
		STATE_FINISHED
		})
		@Retention(RetentionPolicy.SOURCE)
		@interface TransitionState {}

		final @TransitionType int mType;
		private int mSyncId = -1;
		// Used for tracking a Transition throughout a lifecycle (i.e. from STATE_COLLECTING to
		// STATE_FINISHED or STATE_ABORT), and should only be used for testing and debugging.
		private int mDebugId = -1;
		private @TransitionFlags int mFlags;
		private final TransitionController mController;
		private final BLASTSyncEngine mSyncEngine;
		@@ -202,6 +212,8 @@ class Transition extends Binder implements BLASTSyncEngine.TransactionReadyListe
		mFlags = flags;
		mController = controller;
		mSyncEngine = syncEngine;

		controller.mTransitionTracer.logState(this);
		}

		void addFlag(int flag) {
		@@ -272,11 +284,21 @@ class Transition extends Binder implements BLASTSyncEngine.TransactionReadyListe
		}
		}

		@TransitionState
		int getState() {
		return mState;
		}

		@VisibleForTesting
		int getSyncId() {
		return mSyncId;
		}

		@VisibleForTesting
		int getDebugId() {
		return mDebugId;
		}

		@TransitionFlags
		int getFlags() {
		return mFlags;
		@@ -289,6 +311,9 @@ class Transition extends Binder implements BLASTSyncEngine.TransactionReadyListe
		}
		mState = STATE_COLLECTING;
		mSyncId = mSyncEngine.startSyncSet(this, timeoutMs, TAG);
		mDebugId = mSyncId;

		mController.mTransitionTracer.logState(this);
		}

		/**
		@@ -306,6 +331,8 @@ class Transition extends Binder implements BLASTSyncEngine.TransactionReadyListe
		ProtoLog.v(ProtoLogGroup.WM_DEBUG_WINDOW_TRANSITIONS, "Starting Transition %d",
		mSyncId);
		applyReady();

		mController.mTransitionTracer.logState(this);
		}

		/**
		@@ -674,6 +701,9 @@ class Transition extends Binder implements BLASTSyncEngine.TransactionReadyListe
		dc.removeImeSurfaceImmediately();
		dc.handleCompleteDeferredRemoval();
		}

		mState = STATE_FINISHED;
		mController.mTransitionTracer.logState(this);
		}

		void abort() {

services/core/java/com/android/server/wm/TransitionController.java

+6 −1

Original line number	Diff line number	Diff line
		@@ -75,6 +75,7 @@ class TransitionController {

		private ITransitionPlayer mTransitionPlayer;
		final TransitionMetricsReporter mTransitionMetricsReporter = new TransitionMetricsReporter();
		final TransitionTracer mTransitionTracer;

		private IApplicationThread mTransitionPlayerThread;
		final ActivityTaskManagerService mAtm;
		@@ -100,10 +101,12 @@ class TransitionController {
		final StatusBarManagerInternal mStatusBar;

		TransitionController(ActivityTaskManagerService atm,
		TaskSnapshotController taskSnapshotController) {
		TaskSnapshotController taskSnapshotController,
		TransitionTracer transitionTracer) {
		mAtm = atm;
		mStatusBar = LocalServices.getService(StatusBarManagerInternal.class);
		mTaskSnapshotController = taskSnapshotController;
		mTransitionTracer = transitionTracer;
		mTransitionPlayerDeath = () -> {
		synchronized (mAtm.mGlobalLock) {
		// Clean-up/finish any playing transitions.
		@@ -524,6 +527,7 @@ class TransitionController {
		setAnimationRunning(true /* running */);
		}
		mPlayingTransitions.add(transition);
		mTransitionTracer.logState(transition);
		}

		private void setAnimationRunning(boolean running) {
		@@ -542,6 +546,7 @@ class TransitionController {
		}
		transition.abort();
		mCollectingTransition = null;
		mTransitionTracer.logState(transition);
		}

		/**

services/core/java/com/android/server/wm/TransitionTracer.java

0 → 100644

+234 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.server.wm;

		import static android.os.Build.IS_USER;

		import static com.android.server.wm.shell.ChangeInfo.CHANGE_FLAGS;
		import static com.android.server.wm.shell.ChangeInfo.HAS_CHANGED;
		import static com.android.server.wm.shell.ChangeInfo.TRANSIT_MODE;
		import static com.android.server.wm.shell.ChangeInfo.WINDOW_IDENTIFIER;
		import static com.android.server.wm.shell.Transition.CHANGE;
		import static com.android.server.wm.shell.Transition.FLAGS;
		import static com.android.server.wm.shell.Transition.ID;
		import static com.android.server.wm.shell.Transition.STATE;
		import static com.android.server.wm.shell.Transition.TIMESTAMP;
		import static com.android.server.wm.shell.Transition.TRANSITION_TYPE;
		import static com.android.server.wm.shell.TransitionTraceProto.MAGIC_NUMBER;
		import static com.android.server.wm.shell.TransitionTraceProto.MAGIC_NUMBER_H;
		import static com.android.server.wm.shell.TransitionTraceProto.MAGIC_NUMBER_L;
		import static com.android.server.wm.shell.TransitionTraceProto.TRANSITION;

		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.os.SystemClock;
		import android.os.Trace;
		import android.util.Log;
		import android.util.proto.ProtoOutputStream;

		import com.android.internal.util.TraceBuffer;
		import com.android.server.wm.Transition.ChangeInfo;
		import com.android.server.wm.shell.TransitionTraceProto;

		import java.io.File;
		import java.io.IOException;
		import java.io.PrintWriter;

		/**
		* Helper class to collect and dump transition traces.
		*/
		public class TransitionTracer {

		private static final String LOG_TAG = "TransitionTracer";

		/**
		* Maximum buffer size, currently defined as 5 MB
		*/
		private static final int BUFFER_CAPACITY = 5120 * 1024; // 5 MB
		static final String WINSCOPE_EXT = ".winscope";
		private static final String TRACE_FILE = "/data/misc/wmtrace/transition_trace" + WINSCOPE_EXT;
		private static final long MAGIC_NUMBER_VALUE = ((long) MAGIC_NUMBER_H << 32) \| MAGIC_NUMBER_L;

		private final TransitionTraceBuffer mTraceBuffer = new TransitionTraceBuffer();

		private final Object mEnabledLock = new Object();
		private volatile boolean mEnabled = false;

		private long mTraceStartTimestamp;

		private class TransitionTraceBuffer {
		private final TraceBuffer mBuffer = new TraceBuffer(BUFFER_CAPACITY);

		private void pushTransitionState(Transition transition) {
		final ProtoOutputStream outputStream = new ProtoOutputStream();
		final long transitionEntryToken = outputStream.start(TRANSITION);

		outputStream.write(ID, transition.getDebugId());
		outputStream.write(TIMESTAMP, SystemClock.elapsedRealtimeNanos());
		outputStream.write(TRANSITION_TYPE, transition.mType);
		outputStream.write(STATE, transition.getState());
		outputStream.write(FLAGS, transition.getFlags());

		for (int i = 0; i < transition.mChanges.size(); ++i) {
		final WindowContainer window = transition.mChanges.keyAt(i);
		final ChangeInfo changeInfo = transition.mChanges.valueAt(i);
		writeChange(outputStream, window, changeInfo);
		}

		outputStream.end(transitionEntryToken);

		mBuffer.add(outputStream);
		}

		private void writeChange(ProtoOutputStream outputStream, WindowContainer window,
		ChangeInfo changeInfo) {
		Trace.beginSection("TransitionProto#addChange");
		final long changeEntryToken = outputStream.start(CHANGE);

		final int transitMode = changeInfo.getTransitMode(window);
		final boolean hasChanged = changeInfo.hasChanged(window);
		final int changeFlags = changeInfo.getChangeFlags(window);

		outputStream.write(TRANSIT_MODE, transitMode);
		outputStream.write(HAS_CHANGED, hasChanged);
		outputStream.write(CHANGE_FLAGS, changeFlags);
		window.writeIdentifierToProto(outputStream, WINDOW_IDENTIFIER);

		outputStream.end(changeEntryToken);
		Trace.endSection();
		}

		public void writeToFile(File file, ProtoOutputStream proto) throws IOException {
		mBuffer.writeTraceToFile(file, proto);
		}

		public void reset() {
		mBuffer.resetBuffer();
		}
		}

		/**
		* Records the current state of a transition in the transition trace (if it is running).
		* @param transition the transition that we want to record the state of.
		*/
		public void logState(com.android.server.wm.Transition transition) {
		if (!mEnabled) {
		return;
		}

		Log.d(LOG_TAG, "Logging state of transition " + transition);
		mTraceBuffer.pushTransitionState(transition);
		}

		/**
		* Starts collecting transitions for the trace.
		* If called while a trace is already running, this will reset the trace.
		*/
		public void startTrace(@Nullable PrintWriter pw) {
		if (IS_USER) {
		LogAndPrintln.e(pw, "Tracing is not supported on user builds.");
		return;
		}
		Trace.beginSection("TransitionTracer#startTrace");
		LogAndPrintln.i(pw, "Starting shell transition trace.");
		synchronized (mEnabledLock) {
		mTraceStartTimestamp = SystemClock.elapsedRealtime();
		mEnabled = true;
		mTraceBuffer.reset();
		}
		Trace.endSection();
		}

		/**
		* Stops collecting the transition trace and dump to trace to file.
		*
		* Dumps the trace to @link{TRACE_FILE}.
		*/
		public void stopTrace(@Nullable PrintWriter pw) {
		stopTrace(pw, new File(TRACE_FILE));
		}

		/**
		* Stops collecting the transition trace and dump to trace to file.
		* @param outputFile The file to dump the transition trace to.
		*/
		public void stopTrace(@Nullable PrintWriter pw, File outputFile) {
		if (IS_USER) {
		LogAndPrintln.e(pw, "Tracing is not supported on user builds.");
		return;
		}
		Trace.beginSection("TransitionTracer#stopTrace");
		LogAndPrintln.i(pw, "Stopping shell transition trace.");
		synchronized (mEnabledLock) {
		if (!mEnabled) {
		LogAndPrintln.e(pw,
		"Error: Tracing can't be stopped because it hasn't been started.");
		return;
		}

		mEnabled = false;
		writeTraceToFileLocked(pw, outputFile);
		}
		Trace.endSection();
		}

		boolean isEnabled() {
		return mEnabled;
		}

		private void writeTraceToFileLocked(@Nullable PrintWriter pw, File file) {
		Trace.beginSection("TransitionTracer#writeTraceToFileLocked");
		try {
		ProtoOutputStream proto = new ProtoOutputStream();
		proto.write(MAGIC_NUMBER, MAGIC_NUMBER_VALUE);
		proto.write(TransitionTraceProto.TIMESTAMP, mTraceStartTimestamp);
		int pid = android.os.Process.myPid();
		LogAndPrintln.i(pw, "Writing file to " + file.getAbsolutePath()
		+ " from process " + pid);
		mTraceBuffer.writeToFile(file, proto);
		} catch (IOException e) {
		LogAndPrintln.e(pw, "Unable to write buffer to file", e);
		}
		Trace.endSection();
		}

		private static class LogAndPrintln {
		private static void i(@Nullable PrintWriter pw, String msg) {
		Log.i(LOG_TAG, msg);
		if (pw != null) {
		pw.println(msg);
		pw.flush();
		}
		}

		private static void e(@Nullable PrintWriter pw, String msg) {
		Log.e(LOG_TAG, msg);
		if (pw != null) {
		pw.println("ERROR: " + msg);
		pw.flush();
		}
		}

		private static void e(@Nullable PrintWriter pw, String msg, @NonNull Exception e) {
		Log.e(LOG_TAG, msg, e);
		if (pw != null) {
		pw.println("ERROR: " + msg + " ::\n " + e);
		pw.flush();
		}
		}
		}
		}