Using java_style enum generation for proto

This makes it easier to track various method parameters and simplifies
debug logging

Change-Id: Ib7c3d52590d0c36b2c8460c889ee3bead3454569

2 files changed, 100 insertions, 170 deletions

diff --git a/src/com/android/launcher3/logging/LoggerUtils.java b/src/com/android/launcher3/logging/LoggerUtils.java
index f1a12ff22..c13e8b336 100644
--- a/src/com/android/launcher3/logging/LoggerUtils.java
+++ b/src/com/android/launcher3/logging/LoggerUtils.java
@@ -1,5 +1,7 @@
 package com.android.launcher3.logging;
 
+import android.util.ArrayMap;
+import android.util.SparseArray;
 import android.view.View;
 
 import com.android.launcher3.ButtonDropTarget;
@@ -8,81 +10,73 @@ import com.android.launcher3.InfoDropTarget;
 import com.android.launcher3.ItemInfo;
 import com.android.launcher3.LauncherSettings;
 import com.android.launcher3.UninstallDropTarget;
-import com.android.launcher3.userevent.nano.LauncherLogProto;
 import com.android.launcher3.userevent.nano.LauncherLogProto.Action;
+import com.android.launcher3.userevent.nano.LauncherLogProto.ContainerType;
+import com.android.launcher3.userevent.nano.LauncherLogProto.ControlType;
+import com.android.launcher3.userevent.nano.LauncherLogProto.ItemType;
 import com.android.launcher3.userevent.nano.LauncherLogProto.LauncherEvent;
 import com.android.launcher3.userevent.nano.LauncherLogProto.Target;
 
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
 /**
- * Debugging helper methods.
- * toString() cannot be overriden inside auto generated {@link LauncherLogProto}.
- * Note: switch statement cannot be replaced with reflection as proguard strips the constants
+ * Helper methods for logging.
  */
 public class LoggerUtils {
-    private static final String TAG = "LoggerUtils";
-
-    private static String getCommandStr(Action action) {
-        switch (action.command) {
-            case Action.HOME_INTENT: return "HOME_INTENT";
-            case Action.BACK: return "BACK";
-            default: return "UNKNOWN";
-        }
-    }
-
-    private static String getTouchStr(Action action) {
-        switch (action.touch) {
-            case Action.TAP: return "TAP";
-            case Action.LONGPRESS: return "LONGPRESS";
-            case Action.DRAGDROP: return "DRAGDROP";
-            case Action.PINCH: return "PINCH";
-            case Action.SWIPE: return "SWIPE";
-            case Action.FLING: return "FLING";
-            default: return "UNKNOWN";
-        }
-    }
-
-    public static String getActionStr(LauncherLogProto.Action action) {
+    private static final ArrayMap<Class, SparseArray<String>> sNameCache = new ArrayMap<>();
+    private static final String UNKNOWN = "UNKNOWN";
+
+    private static String getFieldName(int value, Class c) {
+        SparseArray<String> cache;
+        synchronized (sNameCache) {
+            cache = sNameCache.get(c);
+            if (cache == null) {
+                cache = new SparseArray<>();
+                for (Field f : c.getDeclaredFields()) {
+                    if (f.getType() == int.class && Modifier.isStatic(f.getModifiers())) {
+                        try {
+                            f.setAccessible(true);
+                            cache.put(f.getInt(null), f.getName());
+                        } catch (IllegalAccessException e) {
+                            // Ignore
+                        }
+                    }
+                }
+                sNameCache.put(c, cache);
+            }
+        }
+        String result = cache.get(value);
+        return result != null ? result : UNKNOWN;
+    }
+
+    public static String getActionStr(Action action) {
         switch (action.type) {
-            case Action.TOUCH: return getTouchStr(action);
-            case Action.COMMAND: return getCommandStr(action);
-            default: return "UNKNOWN";
+            case Action.Type.TOUCH: return getFieldName(action.touch, Action.Touch.class);
+            case Action.Type.COMMAND: return getFieldName(action.command, Action.Command.class);
+            default: return UNKNOWN;
         }
     }
 
     public static String getTargetStr(Target t) {
-        String typeStr = "";
         if (t == null){
-            return typeStr;
+            return "";
         }
         switch (t.type) {
-            case Target.ITEM:
+            case Target.Type.ITEM:
                 return getItemStr(t);
-            case Target.CONTROL:
-                return getControlStr(t);
-            case Target.CONTAINER:
-                return getContainerStr(t);
+            case Target.Type.CONTROL:
+                return getFieldName(t.controlType, ControlType.class);
+            case Target.Type.CONTAINER:
+                return getFieldName(t.containerType, ContainerType.class)
+                        + " id=" + t.pageIndex;
             default:
                 return "UNKNOWN TARGET TYPE";
         }
     }
 
     private static String getItemStr(Target t) {
-        String typeStr = "";
-        if (t == null){
-            return typeStr;
-        }
-        switch(t.itemType){
-            case LauncherLogProto.APP_ICON: typeStr = "APPICON"; break;
-            case LauncherLogProto.SHORTCUT: typeStr = "SHORTCUT"; break;
-            case LauncherLogProto.WIDGET: typeStr = "WIDGET"; break;
-            case LauncherLogProto.DEEPSHORTCUT: typeStr = "DEEPSHORTCUT"; break;
-            case LauncherLogProto.FOLDER_ICON: typeStr = "FOLDERICON"; break;
-            case LauncherLogProto.SEARCHBOX: typeStr = "SEARCHBOX"; break;
-            case LauncherLogProto.EDITTEXT: typeStr = "EDITTEXT"; break;
-
-            default: typeStr = "UNKNOWN";
-        }
-
+        String typeStr = getFieldName(t.itemType, ItemType.class);
         if (t.packageNameHash != 0) {
             typeStr += ", packageHash=" + t.packageNameHash;
         }
@@ -95,88 +89,32 @@ public class LoggerUtils {
         if (t.spanX != 0) {
             typeStr += ", spanX=" + t.spanX;
         }
-        return typeStr += ", grid=(" + t.gridX + "," + t.gridY + "), id=" + t.pageIndex;
-    }
-
-    private static String getControlStr(Target t) {
-        if (t == null){
-            return "";
-        }
-        switch(t.controlType) {
-            case LauncherLogProto.ALL_APPS_BUTTON: return "ALL_APPS_BUTTON";
-            case LauncherLogProto.WIDGETS_BUTTON: return "WIDGETS_BUTTON";
-            case LauncherLogProto.WALLPAPER_BUTTON: return "WALLPAPER_BUTTON";
-            case LauncherLogProto.SETTINGS_BUTTON: return "SETTINGS_BUTTON";
-            case LauncherLogProto.REMOVE_TARGET: return "REMOVE_TARGET";
-            case LauncherLogProto.UNINSTALL_TARGET: return "UNINSTALL_TARGET";
-            case LauncherLogProto.APPINFO_TARGET: return "APPINFO_TARGET";
-            case LauncherLogProto.RESIZE_HANDLE: return "RESIZE_HANDLE";
-            default: return "UNKNOWN";
-        }
-    }
-
-    private static String getContainerStr(LauncherLogProto.Target t) {
-        String str = "";
-        if (t == null) {
-            return str;
-        }
-        switch (t.containerType) {
-            case LauncherLogProto.WORKSPACE:
-                str = "WORKSPACE";
-                break;
-            case LauncherLogProto.HOTSEAT:
-                str = "HOTSEAT";
-                break;
-            case LauncherLogProto.FOLDER:
-                str = "FOLDER";
-                break;
-            case LauncherLogProto.ALLAPPS:
-                str = "ALLAPPS";
-                break;
-            case LauncherLogProto.WIDGETS:
-                str = "WIDGETS";
-                break;
-            case LauncherLogProto.OVERVIEW:
-                str = "OVERVIEW";
-                break;
-            case LauncherLogProto.PREDICTION:
-                str = "PREDICTION";
-                break;
-            case LauncherLogProto.SEARCHRESULT:
-                str = "SEARCHRESULT";
-                break;
-            case LauncherLogProto.DEEPSHORTCUTS:
-                str = "DEEPSHORTCUTS";
-                break;
-            default:
-                str = "UNKNOWN";
-        }
-        return str + " id=" + t.pageIndex;
+        return typeStr + ", grid=(" + t.gridX + "," + t.gridY + "), id=" + t.pageIndex;
     }
 
     public static Target newItemTarget(View v) {
         return (v.getTag() instanceof ItemInfo)
                 ? newItemTarget((ItemInfo) v.getTag())
-                : newTarget(Target.ITEM);
+                : newTarget(Target.Type.ITEM);
     }
 
     public static Target newItemTarget(ItemInfo info) {
-        Target t = newTarget(Target.ITEM);
+        Target t = newTarget(Target.Type.ITEM);
         switch (info.itemType) {
             case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
-                t.itemType = LauncherLogProto.APP_ICON;
+                t.itemType = ItemType.APP_ICON;
                 break;
             case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
-                t.itemType = LauncherLogProto.SHORTCUT;
+                t.itemType = ItemType.SHORTCUT;
                 break;
             case LauncherSettings.Favorites.ITEM_TYPE_FOLDER:
-                t.itemType = LauncherLogProto.FOLDER_ICON;
+                t.itemType = ItemType.FOLDER_ICON;
                 break;
             case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
-                t.itemType = LauncherLogProto.WIDGET;
+                t.itemType = ItemType.WIDGET;
                 break;
             case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT:
-                t.itemType = LauncherLogProto.DEEPSHORTCUT;
+                t.itemType = ItemType.DEEPSHORTCUT;
                 break;
         }
         return t;
@@ -184,26 +122,26 @@ public class LoggerUtils {
 
     public static Target newDropTarget(View v) {
         if (!(v instanceof ButtonDropTarget)) {
-            return newTarget(Target.CONTAINER);
+            return newTarget(Target.Type.CONTAINER);
         }
-        Target t = newTarget(Target.CONTROL);
+        Target t = newTarget(Target.Type.CONTROL);
         if (v instanceof InfoDropTarget) {
-            t.controlType = LauncherLogProto.APPINFO_TARGET;
+            t.controlType = ControlType.APPINFO_TARGET;
         } else if (v instanceof UninstallDropTarget) {
-            t.controlType = LauncherLogProto.UNINSTALL_TARGET;
+            t.controlType = ControlType.UNINSTALL_TARGET;
         } else if (v instanceof DeleteDropTarget) {
-            t.controlType = LauncherLogProto.REMOVE_TARGET;
+            t.controlType = ControlType.REMOVE_TARGET;
         }
         return t;
     }
 
     public static Target newTarget(int targetType) {
-        Target t = new LauncherLogProto.Target();
+        Target t = new Target();
         t.type = targetType;
         return t;
     }
     public static Target newContainerTarget(int containerType) {
-        Target t = newTarget(Target.CONTAINER);
+        Target t = newTarget(Target.Type.CONTAINER);
         t.containerType = containerType;
         return t;
     }
@@ -214,18 +152,18 @@ public class LoggerUtils {
         return a;
     }
     public static Action newCommandAction(int command) {
-        Action a = newAction(Action.COMMAND);
+        Action a = newAction(Action.Type.COMMAND);
         a.command = command;
         return a;
     }
     public static Action newTouchAction(int touch) {
-        Action a = newAction(Action.TOUCH);
+        Action a = newAction(Action.Type.TOUCH);
         a.touch = touch;
         return a;
     }
 
     public static LauncherEvent newLauncherEvent(Action action, Target... srcTargets) {
-        LauncherLogProto.LauncherEvent event = new LauncherLogProto.LauncherEvent();
+        LauncherEvent event = new LauncherEvent();
         event.srcTarget = srcTargets;
         event.action = action;
         return event;
diff --git a/src/com/android/launcher3/logging/UserEventDispatcher.java b/src/com/android/launcher3/logging/UserEventDispatcher.java
index 4bc581938..8ded6b8f6 100644
--- a/src/com/android/launcher3/logging/UserEventDispatcher.java
+++ b/src/com/android/launcher3/logging/UserEventDispatcher.java
@@ -27,8 +27,8 @@ import com.android.launcher3.DropTarget;
 import com.android.launcher3.ItemInfo;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.config.ProviderConfig;
-import com.android.launcher3.userevent.nano.LauncherLogProto;
 import com.android.launcher3.userevent.nano.LauncherLogProto.Action;
+import com.android.launcher3.userevent.nano.LauncherLogProto.ContainerType;
 import com.android.launcher3.userevent.nano.LauncherLogProto.LauncherEvent;
 import com.android.launcher3.userevent.nano.LauncherLogProto.Target;
 import com.android.launcher3.util.ComponentKey;
@@ -54,7 +54,9 @@ public class UserEventDispatcher {
 
     private final static int MAXIMUM_VIEW_HIERARCHY_LEVEL = 5;
 
-    private final boolean mIsVerbose;
+    private static final String TAG = "UserEvent";
+    private static final boolean IS_VERBOSE =
+            ProviderConfig.IS_DOGFOOD_BUILD && Utilities.isPropertyEnabled(TAG);
 
     /**
      * Implemented by containers to provide a container source for a given child.
@@ -76,8 +78,7 @@ public class UserEventDispatcher {
      * Recursively finds the parent of the given child which implements IconLogInfoProvider
      */
     public static LogContainerProvider getLaunchProviderRecursive(View v) {
-        ViewParent parent = null;
-
+        ViewParent parent;
         if (v != null) {
             parent = v.getParent();
         } else {
@@ -96,8 +97,6 @@ public class UserEventDispatcher {
         return null;
     }
 
-    private String TAG = "UserEvent";
-
     private long mElapsedContainerMillis;
     private long mElapsedSessionMillis;
     private long mActionDurationMillis;
@@ -105,14 +104,6 @@ public class UserEventDispatcher {
     // Used for filling in predictedRank on {@link Target}s.
     private List<ComponentKey> mPredictedApps;
 
-    public UserEventDispatcher() {
-        if (ProviderConfig.IS_DOGFOOD_BUILD) {
-            mIsVerbose = Utilities.isPropertyEnabled(TAG);
-        } else {
-            mIsVerbose = false;
-        }
-    }
-
     //                      APP_ICON    SHORTCUT    WIDGET
     // --------------------------------------------------------------
     // packageNameHash      required    optional    required
@@ -121,8 +112,8 @@ public class UserEventDispatcher {
     // --------------------------------------------------------------
 
     protected LauncherEvent createLauncherEvent(View v, Intent intent) {
-        LauncherEvent event = newLauncherEvent(newTouchAction(Action.TAP),
-                newItemTarget(v), newTarget(Target.CONTAINER));
+        LauncherEvent event = newLauncherEvent(newTouchAction(Action.Touch.TAP),
+                newItemTarget(v), newTarget(Target.Type.CONTAINER));
 
         // TODO: make idx percolate up the view hierarchy if needed.
         int idx = 0;
@@ -176,20 +167,21 @@ public class UserEventDispatcher {
      * TODO: Make this function work when a container view is passed as the 2nd param.
      */
     public void logActionCommand(int command, View itemView, int containerType) {
-        LauncherEvent event = newLauncherEvent(
-                newCommandAction(command), newItemTarget(itemView), newTarget(Target.CONTAINER));
+        LauncherEvent event = newLauncherEvent(newCommandAction(command),
+                newItemTarget(itemView), newTarget(Target.Type.CONTAINER));
 
         if (fillInLogContainerData(event, itemView)) {
             // TODO: Remove the following two lines once fillInLogContainerData can take in a
             // container view.
-            event.srcTarget[0].type = Target.CONTAINER;
+            event.srcTarget[0].type = Target.Type.CONTAINER;
             event.srcTarget[0].containerType = containerType;
         }
         dispatchUserEvent(event, null);
     }
 
     public void logActionOnControl(int action, int controlType) {
-        LauncherEvent event = newLauncherEvent(newTouchAction(action), newTarget(Target.CONTROL));
+        LauncherEvent event = newLauncherEvent(
+                newTouchAction(action), newTarget(Target.Type.CONTROL));
         event.srcTarget[0].controlType = controlType;
         dispatchUserEvent(event, null);
     }
@@ -212,8 +204,8 @@ public class UserEventDispatcher {
             return;
         }
         ItemInfo info = (ItemInfo) icon.getTag();
-        LauncherEvent event = newLauncherEvent(
-                newTouchAction(Action.LONGPRESS), newItemTarget(info), newTarget(Target.CONTAINER));
+        LauncherEvent event = newLauncherEvent(newTouchAction(Action.Touch.LONGPRESS),
+                newItemTarget(info), newTarget(Target.Type.CONTAINER));
         provider.fillInLogContainerData(icon, info, event.srcTarget[0], event.srcTarget[1]);
         dispatchUserEvent(event, null);
 
@@ -227,16 +219,16 @@ public class UserEventDispatcher {
     /* Currently we are only interested in whether this event happens or not and don't
     * care about which screen moves to where. */
     public void logOverviewReorder() {
-        LauncherEvent event = newLauncherEvent(newTouchAction(Action.DRAGDROP),
-                newContainerTarget(LauncherLogProto.WORKSPACE),
-                newContainerTarget(LauncherLogProto.OVERVIEW));
+        LauncherEvent event = newLauncherEvent(newTouchAction(Action.Touch.DRAGDROP),
+                newContainerTarget(ContainerType.WORKSPACE),
+                newContainerTarget(ContainerType.OVERVIEW));
         dispatchUserEvent(event, null);
     }
 
     public void logDragNDrop(DropTarget.DragObject dragObj, View dropTargetAsView) {
-        LauncherEvent event = newLauncherEvent(newTouchAction(Action.DRAGDROP),
-                newItemTarget(dragObj.originalDragInfo), newTarget(Target.CONTAINER));
-        event.destTarget = new LauncherLogProto.Target[] {
+        LauncherEvent event = newLauncherEvent(newTouchAction(Action.Touch.DRAGDROP),
+                newItemTarget(dragObj.originalDragInfo), newTarget(Target.Type.CONTAINER));
+        event.destTarget = new Target[] {
                 newItemTarget(dragObj.originalDragInfo), newDropTarget(dropTargetAsView)
         };
 
@@ -272,26 +264,26 @@ public class UserEventDispatcher {
         ev.elapsedContainerMillis = SystemClock.uptimeMillis() - mElapsedContainerMillis;
         ev.elapsedSessionMillis = SystemClock.uptimeMillis() - mElapsedSessionMillis;
 
-        if (!mIsVerbose) {
+        if (!IS_VERBOSE) {
             return;
         }
-        Log.d(TAG, String.format(Locale.US,
-                "\naction:%s\n Source child:%s\tparent:%s",
-                LoggerUtils.getActionStr(ev.action),
-                LoggerUtils.getTargetStr(ev.srcTarget != null ? ev.srcTarget[0] : null),
-                LoggerUtils.getTargetStr(ev.srcTarget != null && ev.srcTarget.length > 1 ?
-                        ev.srcTarget[1] : null)));
+        String log = "action:" + LoggerUtils.getActionStr(ev.action);
+        if (ev.srcTarget != null && ev.srcTarget.length > 0) {
+            log += "\n Source " + getTargetsStr(ev.srcTarget);
+        }
         if (ev.destTarget != null && ev.destTarget.length > 0) {
-            Log.d(TAG, String.format(Locale.US,
-                    " Destination child:%s\tparent:%s",
-                    LoggerUtils.getTargetStr(ev.destTarget != null ? ev.destTarget[0] : null),
-                    LoggerUtils.getTargetStr(ev.destTarget != null && ev.destTarget.length > 1 ?
-                            ev.destTarget[1] : null)));
+            log += "\n Destination " + getTargetsStr(ev.destTarget);
         }
-        Log.d(TAG, String.format(Locale.US,
-                " Elapsed container %d ms session %d ms action %d ms",
+        log += String.format(Locale.US,
+                "\n Elapsed container %d ms session %d ms action %d ms",
                 ev.elapsedContainerMillis,
                 ev.elapsedSessionMillis,
-                ev.actionDurationMillis));
+                ev.actionDurationMillis);
+        Log.d(TAG, log);
+    }
+
+    private static String getTargetsStr(Target[] targets) {
+        return "child:" + LoggerUtils.getTargetStr(targets[0]) +
+                (targets.length > 1 ? "\tparent:" + LoggerUtils.getTargetStr(targets[1]) : "");
     }
 }