Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes from topic "winscope-sysui"

Browse Source 
* changes:
  Add initial SysUI trace support
  Update trace buffer to support SysUI & Launcher
This commit is contained in:
Winson Chung
2020-01-29 05:04:48 +00:00
committed by Android (Google) Code Review
parent 11dbc1bb40 a657ac9ca5
commit 75f5bf33b0
21 changed files with 686 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
core/java/com/android/internal/statusbar/IStatusBar.aidl
View File

@@ -210,4 +210,14 @@ oneway interface IStatusBar
* Cancels toast with token {@code token} in {@code packageName}.
*/
void hideToast(String packageName, IBinder token);
/**
* Notifies SystemUI to start tracing.
*/
void startTracing();
/**
* Notifies SystemUI to stop tracing.
*/
void stopTracing();
}

15
core/java/com/android/internal/statusbar/IStatusBarService.aidl
View File

@@ -124,4 +124,19 @@ interface IStatusBarService
* Dismiss the warning that the device is about to go to sleep due to user inactivity.
*/
void dismissInattentiveSleepWarning(boolean animated);
/**
* Notifies SystemUI to start tracing.
*/
void startTracing();
/**
* Notifies SystemUI to stop tracing.
*/
void stopTracing();
/**
* Returns whether SystemUI tracing is enabled.
*/
boolean isTracing();
}

122
services/core/java/com/android/server/utils/TraceBuffer.java → core/java/com/android/internal/util/TraceBuffer.java
View File

@@ -14,7 +14,7 @@
* limitations under the License.
*/
package com.android.server.utils;
package com.android.internal.util;
import android.util.proto.ProtoOutputStream;
@@ -27,19 +27,87 @@ import java.io.OutputStream;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Queue;
import java.util.function.Consumer;
/**
* Buffer used for tracing and logging.
*
* @param <P> The class type of the proto provider
* @param <S> The proto class type of the encapsulating proto
* @param <T> The proto class type of the individual entry protos in the buffer
*
* {@hide}
*/
public class TraceBuffer {
public class TraceBuffer<P, S extends P, T extends P> {
private final Object mBufferLock = new Object();
private final Queue<ProtoOutputStream> mBuffer = new ArrayDeque<>();
private final ProtoProvider<P, S, T> mProtoProvider;
private final Queue<T> mBuffer = new ArrayDeque<>();
private final Consumer mProtoDequeuedCallback;
private int mBufferUsedSize;
private int mBufferCapacity;
/**
* An interface to get protos from different sources (ie. fw-proto/proto-lite/nano-proto) for
* the trace buffer.
*
* @param <P> The class type of the proto provider
* @param <S> The proto class type of the encapsulating proto
* @param <T> The proto class type of the individual protos in the buffer
*/
public interface ProtoProvider<P, S extends P, T extends P> {
/**
* @return The size of the given proto.
*/
int getItemSize(P proto);
/**
* @return The bytes of the given proto.
*/
byte[] getBytes(P proto);
/**
* Writes the given encapsulating proto and buffer of protos to the given output
* stream.
*/
void write(S encapsulatingProto, Queue<T> buffer, OutputStream os) throws IOException;
}
/**
* An implementation of the ProtoProvider that uses only the framework ProtoOutputStream.
*/
private static class ProtoOutputStreamProvider implements
ProtoProvider<ProtoOutputStream, ProtoOutputStream, ProtoOutputStream> {
@Override
public int getItemSize(ProtoOutputStream proto) {
return proto.getRawSize();
}
@Override
public byte[] getBytes(ProtoOutputStream proto) {
return proto.getBytes();
}
@Override
public void write(ProtoOutputStream encapsulatingProto, Queue<ProtoOutputStream> buffer,
OutputStream os) throws IOException {
os.write(encapsulatingProto.getBytes());
for (ProtoOutputStream protoOutputStream : buffer) {
byte[] protoBytes = protoOutputStream.getBytes();
os.write(protoBytes);
}
}
}
public TraceBuffer(int bufferCapacity) {
this(bufferCapacity, new ProtoOutputStreamProvider(), null);
}
public TraceBuffer(int bufferCapacity, ProtoProvider protoProvider,
Consumer<T> protoDequeuedCallback) {
mBufferCapacity = bufferCapacity;
mProtoProvider = protoProvider;
mProtoDequeuedCallback = protoDequeuedCallback;
resetBuffer();
}
@@ -65,8 +133,8 @@ public class TraceBuffer {
* @throws IllegalStateException if the element cannot be added because it is larger
* than the buffer size.
*/
public void add(ProtoOutputStream proto) {
int protoLength = proto.getRawSize();
public void add(T proto) {
int protoLength = mProtoProvider.getItemSize(proto);
if (protoLength > mBufferCapacity) {
throw new IllegalStateException("Trace object too large for the buffer. Buffer size:"
+ mBufferCapacity + " Object size: " + protoLength);
@@ -79,26 +147,22 @@ public class TraceBuffer {
}
}
boolean contains(byte[] other) {
@VisibleForTesting
public boolean contains(byte[] other) {
return mBuffer.stream()
.anyMatch(p -> Arrays.equals(p.getBytes(), other));
.anyMatch(p -> Arrays.equals(mProtoProvider.getBytes(p), other));
}
/**
* Writes the trace buffer to disk inside the encapsulatingProto..
* Writes the trace buffer to disk inside the encapsulatingProto.
*/
public void writeTraceToFile(File traceFile, ProtoOutputStream encapsulatingProto)
public void writeTraceToFile(File traceFile, S encapsulatingProto)
throws IOException {
synchronized (mBufferLock) {
traceFile.delete();
try (OutputStream os = new FileOutputStream(traceFile)) {
traceFile.setReadable(true /* readable */, false /* ownerOnly */);
os.write(encapsulatingProto.getBytes());
for (ProtoOutputStream protoOutputStream : mBuffer) {
encapsulatingProto = protoOutputStream;
byte[] protoBytes = encapsulatingProto.getBytes();
os.write(protoBytes);
}
mProtoProvider.write(encapsulatingProto, mBuffer, os);
os.flush();
}
}
@@ -115,12 +179,16 @@ public class TraceBuffer {
while (availableSpace < protoLength) {
ProtoOutputStream item = mBuffer.poll();
P item = mBuffer.poll();
if (item == null) {
throw new IllegalStateException("No element to discard from buffer");
}
mBufferUsedSize -= item.getRawSize();
mBufferUsedSize -= mProtoProvider.getItemSize(item);
availableSpace = getAvailableSpace();
if (mProtoDequeuedCallback != null) {
mProtoDequeuedCallback.accept(item);
}
}
}
@@ -129,13 +197,18 @@ public class TraceBuffer {
*/
public void resetBuffer() {
synchronized (mBufferLock) {
if (mProtoDequeuedCallback != null) {
for (T item : mBuffer) {
mProtoDequeuedCallback.accept(item);
}
}
mBuffer.clear();
mBufferUsedSize = 0;
}
}
@VisibleForTesting
int getBufferSize() {
public int getBufferSize() {
return mBufferUsedSize;
}
@@ -144,16 +217,9 @@ public class TraceBuffer {
*/
public String getStatus() {
synchronized (mBufferLock) {
return "Buffer size: "
+ mBufferCapacity
+ " bytes"
+ "\n"
+ "Buffer usage: "
+ mBufferUsedSize
+ " bytes"
+ "\n"
+ "Elements in the buffer: "
+ mBuffer.size();
return "Buffer size: " + mBufferCapacity + " bytes" + "\n"
+ "Buffer usage: " + mBufferUsedSize + " bytes" + "\n"
+ "Elements in the buffer: " + mBuffer.size();
}
}
}

1
packages/SystemUI/shared/src/com/android/systemui/shared/recents/IOverviewProxy.aidl
View File

@@ -27,7 +27,6 @@ oneway interface IOverviewProxy {
void onInitialize(in Bundle params) = 12;
/**
* @deprecated
*/

6
packages/SystemUI/shared/src/com/android/systemui/shared/system/QuickStepContract.java
View File

@@ -85,6 +85,8 @@ public class QuickStepContract {
// The notification panel is expanded and interactive (either locked or unlocked), and the
// quick settings is not expanded
public static final int SYSUI_STATE_QUICK_SETTINGS_EXPANDED = 1 << 11;
// Winscope tracing is enabled
public static final int SYSUI_STATE_TRACING_ENABLED = 1 << 12;
@Retention(RetentionPolicy.SOURCE)
@IntDef({SYSUI_STATE_SCREEN_PINNING,
@@ -98,7 +100,8 @@ public class QuickStepContract {
SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED,
SYSUI_STATE_OVERVIEW_DISABLED,
SYSUI_STATE_HOME_DISABLED,
SYSUI_STATE_SEARCH_DISABLED
SYSUI_STATE_SEARCH_DISABLED,
SYSUI_STATE_TRACING_ENABLED
})
public @interface SystemUiStateFlags {}
@@ -117,6 +120,7 @@ public class QuickStepContract {
str.add((flags & SYSUI_STATE_BOUNCER_SHOWING) != 0 ? "bouncer_visible" : "");
str.add((flags & SYSUI_STATE_A11Y_BUTTON_CLICKABLE) != 0 ? "a11y_click" : "");
str.add((flags & SYSUI_STATE_A11Y_BUTTON_LONG_CLICKABLE) != 0 ? "a11y_long_click" : "");
str.add((flags & SYSUI_STATE_TRACING_ENABLED) != 0 ? "tracing" : "");
return str.toString();
}

186
packages/SystemUI/shared/src/com/android/systemui/shared/tracing/FrameProtoTracer.java Normal file
View File

@@ -0,0 +1,186 @@
/*
* 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.shared.tracing;
import android.os.Trace;
import android.util.Log;
import android.view.Choreographer;
import com.android.internal.util.TraceBuffer;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.function.Consumer;
/**
* A proto tracer implementation that can be updated directly (upon state change), or on the next
* scheduled frame.
*
* @param <P> The class type of the proto provider
* @param <S> The proto class type of the encapsulating proto
* @param <T> The proto class type of the individual proto entries in the buffer
* @param <R> The proto class type of the entry root proto in the buffer
*/
public class FrameProtoTracer<P, S extends P, T extends P, R>
implements TraceBuffer.ProtoProvider<P, S, T>, Choreographer.FrameCallback {
private static final String TAG = "FrameProtoTracer";
private static final int BUFFER_CAPACITY = 1024 * 1024;
private final Object mLock = new Object();
private final TraceBuffer<P, S, T> mBuffer;
private final File mTraceFile;
private final ProtoTraceParams<P, S, T, R> mParams;
private final Choreographer mChoreographer;
private final Queue<T> mPool = new LinkedList<>();
private final ArrayList<ProtoTraceable<R>> mTraceables = new ArrayList<>();
private final ArrayList<ProtoTraceable<R>> mTmpTraceables = new ArrayList<>();
private volatile boolean mEnabled;
private boolean mFrameScheduled;
public interface ProtoTraceParams<P, S, T, R> {
File getTraceFile();
S getEncapsulatingTraceProto();
T updateBufferProto(T reuseObj, ArrayList<ProtoTraceable<R>> traceables);
byte[] serializeEncapsulatingProto(S encapsulatingProto, Queue<T> buffer);
byte[] getProtoBytes(P proto);
int getProtoSize(P proto);
}
public FrameProtoTracer(ProtoTraceParams<P, S, T, R> params) {
mParams = params;
mBuffer = new TraceBuffer<>(BUFFER_CAPACITY, this, new Consumer<T>() {
@Override
public void accept(T t) {
onProtoDequeued(t);
}
});
mTraceFile = params.getTraceFile();
mChoreographer = Choreographer.getMainThreadInstance();
}
@Override
public int getItemSize(P proto) {
return mParams.getProtoSize(proto);
}
@Override
public byte[] getBytes(P proto) {
return mParams.getProtoBytes(proto);
}
@Override
public void write(S encapsulatingProto, Queue<T> buffer, OutputStream os) throws IOException {
os.write(mParams.serializeEncapsulatingProto(encapsulatingProto, buffer));
}
public void start() {
synchronized (mLock) {
if (mEnabled) {
return;
}
mBuffer.resetBuffer();
mEnabled = true;
}
logState();
}
public void stop() {
synchronized (mLock) {
if (!mEnabled) {
return;
}
mEnabled = false;
}
writeToFile();
}
public boolean isEnabled() {
return mEnabled;
}
public void add(ProtoTraceable<R> traceable) {
synchronized (mLock) {
mTraceables.add(traceable);
}
}
public void remove(ProtoTraceable<R> traceable) {
synchronized (mLock) {
mTraceables.remove(traceable);
}
}
public void scheduleFrameUpdate() {
if (!mEnabled || mFrameScheduled) {
return;
}
// Schedule an update on the next frame
mChoreographer.postFrameCallback(this);
mFrameScheduled = true;
}
public void update() {
if (!mEnabled) {
return;
}
logState();
}
public float getBufferUsagePct() {
return (float) mBuffer.getBufferSize() / BUFFER_CAPACITY;
}
@Override
public void doFrame(long frameTimeNanos) {
logState();
}
private void onProtoDequeued(T proto) {
mPool.add(proto);
}
private void logState() {
synchronized (mLock) {
mTmpTraceables.addAll(mTraceables);
}
mBuffer.add(mParams.updateBufferProto(mPool.poll(), mTmpTraceables));
mTmpTraceables.clear();
mFrameScheduled = false;
}
private void writeToFile() {
try {
Trace.beginSection("ProtoTracer.writeToFile");
mBuffer.writeTraceToFile(mTraceFile, mParams.getEncapsulatingTraceProto());
} catch (IOException e) {
Log.e(TAG, "Unable to write buffer to file", e);
} finally {
Trace.endSection();
}
}
}

26
packages/SystemUI/shared/src/com/android/systemui/shared/tracing/ProtoTraceable.java Normal file
View File

@@ -0,0 +1,26 @@
/*
* Copyright (C) 2017 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.shared.tracing;
/**
* @see FrameProtoTracer
*/
public interface ProtoTraceable<T> {
/**
* NOTE: Implementations should update all fields in this proto.
*/
void writeToProto(T proto);
}

3
packages/SystemUI/src/com/android/systemui/Dependency.java
View File

@@ -117,6 +117,7 @@ import com.android.systemui.statusbar.policy.SmartReplyConstants;
import com.android.systemui.statusbar.policy.UserInfoController;
import com.android.systemui.statusbar.policy.UserSwitcherController;
import com.android.systemui.statusbar.policy.ZenModeController;
import com.android.systemui.tracing.ProtoTracer;
import com.android.systemui.tuner.TunablePadding.TunablePaddingService;
import com.android.systemui.tuner.TunerService;
import com.android.systemui.util.leak.GarbageMonitor;
@@ -327,6 +328,7 @@ public class Dependency {
@Inject Lazy<SystemWindows> mSystemWindows;
@Inject Lazy<DisplayImeController> mDisplayImeController;
@Inject Lazy<RecordingController> mRecordingController;
@Inject Lazy<ProtoTracer> mProtoTracer;
@Inject
public Dependency() {
@@ -519,6 +521,7 @@ public class Dependency {
mProviders.put(DisplayWindowController.class, mDisplayWindowController::get);
mProviders.put(SystemWindows.class, mSystemWindows::get);
mProviders.put(DisplayImeController.class, mDisplayImeController::get);
mProviders.put(ProtoTracer.class, mProtoTracer::get);
// TODO(b/118592525): to support multi-display , we start to add something which is
// per-display, while others may be global. I think it's time to add

22
packages/SystemUI/src/com/android/systemui/recents/OverviewProxyService.java
View File

@@ -29,6 +29,7 @@ import static com.android.systemui.shared.system.QuickStepContract.KEY_EXTRA_WIN
import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_BOUNCER_SHOWING;
import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING;
import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED;
import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_TRACING_ENABLED;
import android.annotation.FloatRange;
import android.app.ActivityTaskManager;
@@ -67,6 +68,7 @@ import com.android.systemui.shared.recents.ISystemUiProxy;
import com.android.systemui.shared.system.ActivityManagerWrapper;
import com.android.systemui.shared.system.QuickStepContract;
import com.android.systemui.stackdivider.Divider;
import com.android.systemui.statusbar.CommandQueue;
import com.android.systemui.statusbar.NavigationBarController;
import com.android.systemui.statusbar.phone.NavigationBarFragment;
import com.android.systemui.statusbar.phone.NavigationBarView;
@@ -485,7 +487,8 @@ public class OverviewProxyService implements CallbackController<OverviewProxyLis
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
@Inject
public OverviewProxyService(Context context, DeviceProvisionedController provisionController,
public OverviewProxyService(Context context, CommandQueue commandQueue,
DeviceProvisionedController provisionController,
NavigationBarController navBarController, NavigationModeController navModeController,
NotificationShadeWindowController statusBarWinController, SysUiState sysUiState,
PipUI pipUI, Optional<Divider> dividerOptional,
@@ -530,6 +533,15 @@ public class OverviewProxyService implements CallbackController<OverviewProxyLis
// Listen for status bar state changes
statusBarWinController.registerCallback(mStatusBarWindowCallback);
mScreenshotHelper = new ScreenshotHelper(context);
// Listen for tracing state changes
commandQueue.addCallback(new CommandQueue.Callbacks() {
@Override
public void onTracingStateChanged(boolean enabled) {
mSysUiState.setFlag(SYSUI_STATE_TRACING_ENABLED, enabled)
.commitUpdate(mContext.getDisplayId());
}
});
}
public void notifyBackAction(boolean completed, int downX, int downY, boolean isButton,
@@ -573,14 +585,12 @@ public class OverviewProxyService implements CallbackController<OverviewProxyLis
private void onStatusBarStateChanged(boolean keyguardShowing, boolean keyguardOccluded,
boolean bouncerShowing) {
int displayId = mContext.getDisplayId();
mSysUiState.setFlag(SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING,
keyguardShowing && !keyguardOccluded)
.setFlag(SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED,
keyguardShowing && keyguardOccluded)
.setFlag(SYSUI_STATE_BOUNCER_SHOWING, bouncerShowing)
.commitUpdate(displayId);
.commitUpdate(mContext.getDisplayId());
}
/**
@@ -601,10 +611,6 @@ public class OverviewProxyService implements CallbackController<OverviewProxyLis
}
}
public float getBackButtonAlpha() {
return mNavBarButtonAlpha;
}
public void cleanupAfterDeath() {
if (mInputFocusTransferStarted) {
mHandler.post(()-> {

38
packages/SystemUI/src/com/android/systemui/statusbar/CommandQueue.java
View File

@@ -53,6 +53,7 @@ import com.android.internal.statusbar.StatusBarIcon;
import com.android.internal.view.AppearanceRegion;
import com.android.systemui.statusbar.CommandQueue.Callbacks;
import com.android.systemui.statusbar.policy.CallbackController;
import com.android.systemui.tracing.ProtoTracer;
import java.util.ArrayList;
@@ -123,6 +124,7 @@ public class CommandQueue extends IStatusBar.Stub implements CallbackController<
private static final int MSG_DISMISS_INATTENTIVE_SLEEP_WARNING = 52 << MSG_SHIFT;
private static final int MSG_SHOW_TOAST = 53 << MSG_SHIFT;
private static final int MSG_HIDE_TOAST = 54 << MSG_SHIFT;
private static final int MSG_TRACING_STATE_CHANGED = 55 << MSG_SHIFT;
public static final int FLAG_EXCLUDE_NONE = 0;
public static final int FLAG_EXCLUDE_SEARCH_PANEL = 1 << 0;
@@ -143,6 +145,7 @@ public class CommandQueue extends IStatusBar.Stub implements CallbackController<
* event.
*/
private int mLastUpdatedImeDisplayId = INVALID_DISPLAY;
private ProtoTracer mProtoTracer;
/**
* These methods are called back on the main thread.
@@ -325,9 +328,19 @@ public class CommandQueue extends IStatusBar.Stub implements CallbackController<
* @see IStatusBar#hideToast(String, IBinder) (String, IBinder)
*/
default void hideToast(String packageName, IBinder token) { }
/**
* @param enabled
*/
default void onTracingStateChanged(boolean enabled) { }
}
public CommandQueue(Context context) {
this(context, null);
}
public CommandQueue(Context context, ProtoTracer protoTracer) {
mProtoTracer = protoTracer;
context.getSystemService(DisplayManager.class).registerDisplayListener(this, mHandler);
// We always have default display.
setDisabled(DEFAULT_DISPLAY, DISABLE_NONE, DISABLE2_NONE);
@@ -917,6 +930,26 @@ public class CommandQueue extends IStatusBar.Stub implements CallbackController<
}
}
@Override
public void startTracing() {
synchronized (mLock) {
if (mProtoTracer != null) {
mProtoTracer.start();
}
mHandler.obtainMessage(MSG_TRACING_STATE_CHANGED, true).sendToTarget();
}
}
@Override
public void stopTracing() {
synchronized (mLock) {
if (mProtoTracer != null) {
mProtoTracer.stop();
}
mHandler.obtainMessage(MSG_TRACING_STATE_CHANGED, false).sendToTarget();
}
}
private final class H extends Handler {
private H(Looper l) {
super(l);
@@ -1244,6 +1277,11 @@ public class CommandQueue extends IStatusBar.Stub implements CallbackController<
}
break;
}
case MSG_TRACING_STATE_CHANGED:
for (int i = 0; i < mCallbacks.size(); i++) {
mCallbacks.get(i).onTracingStateChanged((Boolean) msg.obj);
}
break;
}
}
}

6
packages/SystemUI/src/com/android/systemui/statusbar/StatusBarDependenciesModule.java
View File

@@ -19,6 +19,8 @@ package com.android.systemui.statusbar;
import android.content.Context;
import com.android.systemui.statusbar.notification.row.NotificationRowModule;
import com.android.systemui.recents.OverviewProxyService;
import com.android.systemui.tracing.ProtoTracer;
import javax.inject.Singleton;
@@ -35,8 +37,8 @@ public class StatusBarDependenciesModule {
*/
@Provides
@Singleton
public CommandQueue provideCommandQueue(Context context) {
return new CommandQueue(context);
public CommandQueue provideCommandQueue(Context context, ProtoTracer protoTracer) {
return new CommandQueue(context, protoTracer);
}
}

17
packages/SystemUI/src/com/android/systemui/statusbar/phone/EdgeBackGestureHandler.java
View File

@@ -54,6 +54,10 @@ import com.android.systemui.recents.OverviewProxyService;
import com.android.systemui.shared.plugins.PluginManager;
import com.android.systemui.shared.system.QuickStepContract;
import com.android.systemui.shared.system.SysUiStatsLog;
import com.android.systemui.shared.tracing.ProtoTraceable;
import com.android.systemui.tracing.ProtoTracer;
import com.android.systemui.tracing.nano.EdgeBackGestureHandlerProto;
import com.android.systemui.tracing.nano.SystemUiTraceProto;
import java.io.PrintWriter;
import java.util.concurrent.Executor;
@@ -62,7 +66,7 @@ import java.util.concurrent.Executor;
* Utility class to handle edge swipes for back gesture
*/
public class EdgeBackGestureHandler implements DisplayListener,
PluginListener<NavigationEdgeBackPlugin> {
PluginListener<NavigationEdgeBackPlugin>, ProtoTraceable<SystemUiTraceProto> {
private static final String TAG = "EdgeBackGestureHandler";
private static final int MAX_LONG_PRESS_TIMEOUT = SystemProperties.getInt(
@@ -161,6 +165,7 @@ public class EdgeBackGestureHandler implements DisplayListener,
mMainExecutor = context.getMainExecutor();
mOverviewProxyService = overviewProxyService;
mPluginManager = pluginManager;
Dependency.get(ProtoTracer.class).add(this);
// Reduce the default touch slop to ensure that we can intercept the gesture
// before the app starts to react to it.
@@ -399,6 +404,8 @@ public class EdgeBackGestureHandler implements DisplayListener,
// forward touch
mEdgeBackPlugin.onMotionEvent(ev);
}
Dependency.get(ProtoTracer.class).update();
}
@Override
@@ -458,6 +465,14 @@ public class EdgeBackGestureHandler implements DisplayListener,
pw.println(" mEdgeWidth=" + mEdgeWidth);
}
@Override
public void writeToProto(SystemUiTraceProto proto) {
if (proto.edgeBackGestureHandler == null) {
proto.edgeBackGestureHandler = new EdgeBackGestureHandlerProto();
}
proto.edgeBackGestureHandler.allowGesture = mAllowGesture;
}
class SysUiInputEventReceiver extends InputEventReceiver {
SysUiInputEventReceiver(InputChannel channel, Looper looper) {
super(channel, looper);

145
packages/SystemUI/src/com/android/systemui/tracing/ProtoTracer.java Normal file
View File

@@ -0,0 +1,145 @@
/*
* 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.tracing;
import static com.android.systemui.tracing.nano.SystemUiTraceFileProto.MAGIC_NUMBER_H;
import static com.android.systemui.tracing.nano.SystemUiTraceFileProto.MAGIC_NUMBER_L;
import android.content.Context;
import android.os.SystemClock;
import androidx.annotation.NonNull;
import com.android.systemui.DumpController;
import com.android.systemui.Dumpable;
import com.android.systemui.shared.tracing.FrameProtoTracer;
import com.android.systemui.shared.tracing.FrameProtoTracer.ProtoTraceParams;
import com.android.systemui.shared.tracing.ProtoTraceable;
import com.android.systemui.tracing.nano.SystemUiTraceProto;
import com.android.systemui.tracing.nano.SystemUiTraceEntryProto;
import com.android.systemui.tracing.nano.SystemUiTraceFileProto;
import com.google.protobuf.nano.MessageNano;
import java.io.File;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Queue;
import javax.inject.Inject;
import javax.inject.Singleton;
/**
* Controller for coordinating winscope proto tracing.
*/
@Singleton
public class ProtoTracer implements Dumpable, ProtoTraceParams<MessageNano, SystemUiTraceFileProto,
SystemUiTraceEntryProto, SystemUiTraceProto> {
private static final String TAG = "ProtoTracer";
private static final long MAGIC_NUMBER_VALUE = ((long) MAGIC_NUMBER_H << 32) | MAGIC_NUMBER_L;
private final Context mContext;
private final FrameProtoTracer<MessageNano, SystemUiTraceFileProto, SystemUiTraceEntryProto,
SystemUiTraceProto> mProtoTracer;
@Inject
public ProtoTracer(Context context, DumpController dumpController) {
mContext = context;
mProtoTracer = new FrameProtoTracer<>(this);
dumpController.registerDumpable(this);
}
@Override
public File getTraceFile() {
return new File(mContext.getFilesDir(), "sysui_trace.pb");
}
@Override
public SystemUiTraceFileProto getEncapsulatingTraceProto() {
return new SystemUiTraceFileProto();
}
@Override
public SystemUiTraceEntryProto updateBufferProto(SystemUiTraceEntryProto reuseObj,
ArrayList<ProtoTraceable<SystemUiTraceProto>> traceables) {
SystemUiTraceEntryProto proto = reuseObj != null
? reuseObj
: new SystemUiTraceEntryProto();
proto.elapsedRealtimeNanos = SystemClock.elapsedRealtimeNanos();
proto.systemUi = proto.systemUi != null ? proto.systemUi : new SystemUiTraceProto();
for (ProtoTraceable t : traceables) {
t.writeToProto(proto.systemUi);
}
return proto;
}
@Override
public byte[] serializeEncapsulatingProto(SystemUiTraceFileProto encapsulatingProto,
Queue<SystemUiTraceEntryProto> buffer) {
encapsulatingProto.magicNumber = MAGIC_NUMBER_VALUE;
encapsulatingProto.entry = buffer.toArray(new SystemUiTraceEntryProto[0]);
return MessageNano.toByteArray(encapsulatingProto);
}
@Override
public byte[] getProtoBytes(MessageNano proto) {
return MessageNano.toByteArray(proto);
}
@Override
public int getProtoSize(MessageNano proto) {
return proto.getCachedSize();
}
public void start() {
mProtoTracer.start();
}
public void stop() {
mProtoTracer.stop();
}
public boolean isEnabled() {
return mProtoTracer.isEnabled();
}
public void add(ProtoTraceable<SystemUiTraceProto> traceable) {
mProtoTracer.add(traceable);
}
public void remove(ProtoTraceable<SystemUiTraceProto> traceable) {
mProtoTracer.remove(traceable);
}
public void scheduleFrameUpdate() {
mProtoTracer.scheduleFrameUpdate();
}
public void update() {
mProtoTracer.update();
}
@Override
public void dump(@NonNull FileDescriptor fd, @NonNull PrintWriter pw, @NonNull String[] args) {
pw.println("ProtoTracer:");
pw.print(" "); pw.println("enabled: " + mProtoTracer.isEnabled());
pw.print(" "); pw.println("usagePct: " + mProtoTracer.getBufferUsagePct());
pw.print(" "); pw.println("file: " + getTraceFile());
}
}

31
packages/SystemUI/src/com/android/systemui/tracing/sysui_trace.proto Normal file
View File

@@ -0,0 +1,31 @@
/*
* 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.
*/
syntax = "proto2";
package com.android.systemui.tracing;
option java_multiple_files = true;
message SystemUiTraceProto {
optional EdgeBackGestureHandlerProto edge_back_gesture_handler = 1;
}
message EdgeBackGestureHandlerProto {
optional bool allow_gesture = 1;
}

49
packages/SystemUI/src/com/android/systemui/tracing/sysui_trace_file.proto Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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.
*/
syntax = "proto2";
import "frameworks/base/packages/SystemUI/src/com/android/systemui/tracing/sysui_trace.proto";
package com.android.systemui.tracing;
option java_multiple_files = true;
/* represents a file full of system ui trace entries.
Encoded, it should start with 0x9 0x53 0x59 0x53 0x55 0x49 0x54 0x52 0x43 (.SYSUITRC), such
that they can be easily identified. */
message SystemUiTraceFileProto {
/* 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 = 0x55535953; /* SYSU (little-endian ASCII) */
MAGIC_NUMBER_H = 0x43525449; /* ITRC (little-endian ASCII) */
}
optional fixed64 magic_number = 1; /* Must be the first field, set to value in MagicNumber */
repeated SystemUiTraceEntryProto entry = 2;
}
/* one system ui trace entry. */
message SystemUiTraceEntryProto {
/* required: elapsed realtime in nanos since boot of when this entry was logged */
optional fixed64 elapsed_realtime_nanos = 1;
optional SystemUiTraceProto system_ui = 3;
}

2
services/core/java/com/android/server/protolog/ProtoLogImpl.java
View File

@@ -38,7 +38,7 @@ import android.util.proto.ProtoOutputStream;
import com.android.internal.annotations.VisibleForTesting;
import com.android.server.protolog.common.IProtoLogGroup;
import com.android.server.protolog.common.LogDataType;
import com.android.server.utils.TraceBuffer;
import com.android.internal.util.TraceBuffer;
import com.android.server.wm.ProtoLogGroup;
import java.io.File;

32
services/core/java/com/android/server/statusbar/StatusBarManagerService.java
View File

@@ -79,7 +79,6 @@ public class StatusBarManagerService extends IStatusBarService.Stub implements D
private final Context mContext;
private final WindowManagerService mWindowManager;
private Handler mHandler = new Handler();
private NotificationDelegate mNotificationDelegate;
private volatile IStatusBar mBar;
@@ -93,6 +92,7 @@ public class StatusBarManagerService extends IStatusBarService.Stub implements D
private final Object mLock = new Object();
private final DeathRecipient mDeathRecipient = new DeathRecipient();
private int mCurrentUserId;
private boolean mTracingEnabled;
private SparseArray<UiState> mDisplayUiState = new SparseArray<>();
@@ -176,11 +176,10 @@ public class StatusBarManagerService extends IStatusBarService.Stub implements D
}
/**
* Construct the service, add the status bar view to the window manager
* Construct the service
*/
public StatusBarManagerService(Context context, WindowManagerService windowManager) {
public StatusBarManagerService(Context context) {
mContext = context;
mWindowManager = windowManager;
LocalServices.addService(StatusBarManagerInternal.class, mInternalService);
LocalServices.addService(GlobalActionsProvider.class, mGlobalActionsProvider);
@@ -720,6 +719,31 @@ public class StatusBarManagerService extends IStatusBarService.Stub implements D
}
}
@Override
public void startTracing() {
if (mBar != null) {
try {
mBar.startTracing();
mTracingEnabled = true;
} catch (RemoteException ex) {}
}
}
@Override
public void stopTracing() {
if (mBar != null) {
try {
mTracingEnabled = false;
mBar.stopTracing();
} catch (RemoteException ex) {}
}
}
@Override
public boolean isTracing() {
return mTracingEnabled;
}
// TODO(b/117478341): make it aware of multi-display if needed.
@Override
public void disable(int what, IBinder token, String pkg) {

17
services/core/java/com/android/server/statusbar/StatusBarShellCommand.java
View File

@@ -72,6 +72,8 @@ public class StatusBarShellCommand extends ShellCommand {
return runDisableForSetup();
case "send-disable-flag":
return runSendDisableFlag();
case "tracing":
return runTracing();
default:
return handleDefaultCommands(cmd);
}
@@ -185,6 +187,18 @@ public class StatusBarShellCommand extends ShellCommand {
return 0;
}
private int runTracing() {
switch (getNextArg()) {
case "start":
mInterface.startTracing();
break;
case "stop":
mInterface.stopTracing();
break;
}
return 0;
}
@Override
public void onHelp() {
final PrintWriter pw = getOutPrintWriter();
@@ -233,6 +247,9 @@ public class StatusBarShellCommand extends ShellCommand {
pw.println(" clock - disable clock appearing in status bar");
pw.println(" notification-icons - disable notification icons from status bar");
pw.println("");
pw.println(" tracing (start | stop)");
pw.println(" Start or stop SystemUI tracing");
pw.println("");
}
/**

4
services/core/java/com/android/server/wm/WindowTracing.java
View File

@@ -35,7 +35,7 @@ import android.util.proto.ProtoOutputStream;
import android.view.Choreographer;
import com.android.server.protolog.ProtoLogImpl;
import com.android.server.utils.TraceBuffer;
import com.android.internal.util.TraceBuffer;
import java.io.File;
import java.io.IOException;
@@ -64,7 +64,7 @@ class WindowTracing {
private final Object mEnabledLock = new Object();
private final File mTraceFile;
private final com.android.server.utils.TraceBuffer mBuffer;
private final TraceBuffer mBuffer;
private final Choreographer.FrameCallback mFrameCallback = (frameTimeNanos) ->
log("onFrame" /* where */);

2
services/java/com/android/server/SystemServer.java
View File

@@ -1327,7 +1327,7 @@ public final class SystemServer {
if (!isWatch) {
t.traceBegin("StartStatusBarManagerService");
try {
statusBar = new StatusBarManagerService(context, wm);
statusBar = new StatusBarManagerService(context);
ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);
} catch (Throwable e) {
reportWtf("starting StatusBarManagerService", e);

1
services/tests/servicestests/src/com/android/server/utils/TraceBufferTest.java
View File

@@ -30,6 +30,7 @@ import android.util.proto.ProtoOutputStream;
import androidx.test.filters.SmallTest;
import com.android.internal.util.Preconditions;
import com.android.internal.util.TraceBuffer;
import org.junit.After;
import org.junit.Before;