Merge "Add developer tiles for layer and window trace"

src/com/android/settings/development/qstile/DevelopmentTiles.java

@@ -16,20 +16,27 @@
 
 package com.android.settings.development.qstile;
 
+import android.os.IBinder;
+import android.os.Parcel;
 import android.os.RemoteException;
+import android.os.ServiceManager;
 import android.os.SystemProperties;
 import android.provider.Settings;
 import android.service.quicksettings.Tile;
 import android.service.quicksettings.TileService;
+import android.support.annotation.VisibleForTesting;
+import android.util.Log;
 import android.view.IWindowManager;
 import android.view.ThreadedRenderer;
 import android.view.View;
 import android.view.WindowManagerGlobal;
 
 import com.android.internal.app.LocalePicker;
+import com.android.settings.wrapper.IWindowManagerWrapper;
 import com.android.settingslib.development.SystemPropPoker;
 
 public abstract class DevelopmentTiles extends TileService {
+    private static final String TAG = "DevelopmentTiles";
 
     protected abstract boolean isEnabled();
 
@@ -131,4 +138,106 @@ public abstract class DevelopmentTiles extends TileService {
             } catch (RemoteException e) { }
         }
     }
+
+    /**
+     * Tile to toggle Window Trace.
+     */
+    public static class WindowTrace extends DevelopmentTiles {
+        @VisibleForTesting
+        IWindowManagerWrapper mWindowManager;
+
+        @Override
+        public void onCreate() {
+            super.onCreate();
+            mWindowManager = new IWindowManagerWrapper(WindowManagerGlobal
+                    .getWindowManagerService());
+        }
+
+        @Override
+        protected boolean isEnabled() {
+            try {
+                return mWindowManager.isWindowTraceEnabled();
+            } catch (RemoteException e) {
+                Log.e(TAG,
+                        "Could not get window trace status, defaulting to false." + e.toString());
+            }
+            return false;
+        }
+
+        @Override
+        protected void setIsEnabled(boolean isEnabled) {
+            try {
+                if (isEnabled) {
+                    mWindowManager.startWindowTrace();
+                } else {
+                    mWindowManager.stopWindowTrace();
+                }
+            } catch (RemoteException e) {
+                Log.e(TAG, "Could not set window trace status." + e.toString());
+            }
+        }
+    }
+
+    /**
+     * Tile to toggle Layer Trace.
+     */
+    public static class LayerTrace extends DevelopmentTiles {
+        @VisibleForTesting
+        static final int SURFACE_FLINGER_LAYER_TRACE_CONTROL_CODE = 1025;
+        @VisibleForTesting
+        static final int SURFACE_FLINGER_LAYER_TRACE_STATUS_CODE = 1026;
+        @VisibleForTesting
+        IBinder mSurfaceFlinger;
+
+        @Override
+        public void onCreate() {
+            super.onCreate();
+            mSurfaceFlinger = ServiceManager.getService("SurfaceFlinger");
+        }
+
+        @Override
+        protected boolean isEnabled() {
+            boolean surfaceTraceEnabled = false;
+            Parcel reply = null;
+            Parcel data = null;
+            try {
+                if (mSurfaceFlinger != null) {
+                    reply = Parcel.obtain();
+                    data = Parcel.obtain();
+                    data.writeInterfaceToken("android.ui.ISurfaceComposer");
+                    mSurfaceFlinger.transact(SURFACE_FLINGER_LAYER_TRACE_STATUS_CODE,
+                            data, reply, 0 /* flags */ );
+                    surfaceTraceEnabled = reply.readBoolean();
+                }
+            } catch (RemoteException e) {
+                Log.e(TAG, "Could not get layer trace status, defaulting to false." + e.toString());
+            } finally {
+                if (data != null) {
+                    data.recycle();
+                    reply.recycle();
+                }
+            }
+            return surfaceTraceEnabled;
+        }
+
+        @Override
+        protected void setIsEnabled(boolean isEnabled) {
+            Parcel data = null;
+            try {
+                if (mSurfaceFlinger != null) {
+                    data = Parcel.obtain();
+                    data.writeInterfaceToken("android.ui.ISurfaceComposer");
+                    data.writeInt(isEnabled ? 1 : 0);
+                    mSurfaceFlinger.transact(SURFACE_FLINGER_LAYER_TRACE_CONTROL_CODE,
+                            data, null, 0 /* flags */);
+                }
+            } catch (RemoteException e) {
+                Log.e(TAG, "Could not set layer tracing." + e.toString());
+            } finally {
+                if (data != null) {
+                    data.recycle();
+                }
+            }
+        }
+    }
 }

src/com/android/settings/wrapper/IWindowManagerWrapper.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2018 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.settings.wrapper;
+
+import android.os.RemoteException;
+import android.view.IWindowManager;
+
+/**
+ * This class replicates a subset of the android.view.IWindowManager. The class
+ * exists so that we can use a thin wrapper around the IWindowManager in production code
+ * and a mock in tests.
+ */
+public class IWindowManagerWrapper {
+
+    private final IWindowManager mWindowManager;
+
+    public IWindowManagerWrapper(IWindowManager wm) {
+        mWindowManager = wm;
+    }
+
+    /**
+     * Returns true if window trace is enabled.
+     */
+    public boolean isWindowTraceEnabled() throws RemoteException {
+        return mWindowManager.isWindowTraceEnabled();
+    }
+
+    /**
+     * Starts a window trace.
+     */
+    public void startWindowTrace() throws RemoteException {
+        mWindowManager.startWindowTrace();
+    }
+
+    /**
+     * Stops a window trace.
+     */
+    public void stopWindowTrace() throws RemoteException {
+        mWindowManager.stopWindowTrace();
+    }
+}