Revert Cls stopping now-master running on googlefood

This reverts commits 01453e855fa87ee19f61223b2b1a6965071ee95a.
and 242bbe1b72e4978dde8a662d164cd186305e14a7.
"Add content description to bagded icons."
"Remove reflection now we are building against L"

Bug: 15833449
Change-Id: I81a5316f5619a9cd3b6ab9fd03b2ba96657b7f68

10 files changed, 385 insertions, 128 deletions

diff --git a/src/com/android/launcher3/compat/LauncherActivityInfoCompat.java b/src/com/android/launcher3/compat/LauncherActivityInfoCompat.java
index 90a4d1a1f..3ba93ea91 100644
--- a/src/com/android/launcher3/compat/LauncherActivityInfoCompat.java
+++ b/src/com/android/launcher3/compat/LauncherActivityInfoCompat.java
@@ -17,7 +17,6 @@
 package com.android.launcher3.compat;
 
 import android.content.ComponentName;
-import android.content.pm.ApplicationInfo;
 import android.graphics.drawable.Drawable;
 
 public abstract class LauncherActivityInfoCompat {
@@ -29,7 +28,7 @@ public abstract class LauncherActivityInfoCompat {
     public abstract UserHandleCompat getUser();
     public abstract CharSequence getLabel();
     public abstract Drawable getIcon(int density);
-    public abstract ApplicationInfo getApplicationInfo();
+    public abstract int getApplicationFlags();
     public abstract long getFirstInstallTime();
     public abstract Drawable getBadgedIcon(int density);
 }
diff --git a/src/com/android/launcher3/compat/LauncherActivityInfoCompatV16.java b/src/com/android/launcher3/compat/LauncherActivityInfoCompatV16.java
index 1d41a6ff6..052d4343e 100644
--- a/src/com/android/launcher3/compat/LauncherActivityInfoCompatV16.java
+++ b/src/com/android/launcher3/compat/LauncherActivityInfoCompatV16.java
@@ -18,7 +18,6 @@ package com.android.launcher3.compat;
 
 import android.content.ComponentName;
 import android.content.Context;
-import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.pm.ActivityInfo;
 import android.content.pm.PackageManager;
@@ -76,8 +75,8 @@ public class LauncherActivityInfoCompatV16 extends LauncherActivityInfoCompat {
         return d;
     }
 
-    public ApplicationInfo getApplicationInfo() {
-        return mActivityInfo.applicationInfo;
+    public int getApplicationFlags() {
+        return mActivityInfo.applicationInfo.flags;
     }
 
     public long getFirstInstallTime() {
diff --git a/src/com/android/launcher3/compat/LauncherActivityInfoCompatVL.java b/src/com/android/launcher3/compat/LauncherActivityInfoCompatVL.java
index b52cf1de2..76125bd6a 100644
--- a/src/com/android/launcher3/compat/LauncherActivityInfoCompatVL.java
+++ b/src/com/android/launcher3/compat/LauncherActivityInfoCompatVL.java
@@ -17,44 +17,66 @@
 package com.android.launcher3.compat;
 
 import android.content.ComponentName;
-import android.content.pm.ApplicationInfo;
-import android.content.pm.LauncherActivityInfo;
 import android.graphics.drawable.Drawable;
 import android.os.UserHandle;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
 public class LauncherActivityInfoCompatVL extends LauncherActivityInfoCompat {
-    private LauncherActivityInfo mLauncherActivityInfo;
+    private Object mLauncherActivityInfo;
+    private Class mLauncherActivityInfoClass;
+    private Method mGetComponentName;
+    private Method mGetUser;
+    private Method mGetLabel;
+    private Method mGetIcon;
+    private Method mGetApplicationFlags;
+    private Method mGetFirstInstallTime;
+    private Method mGetBadgedIcon;
 
-    LauncherActivityInfoCompatVL(LauncherActivityInfo launcherActivityInfo) {
+    LauncherActivityInfoCompatVL(Object launcherActivityInfo) {
         super();
         mLauncherActivityInfo = launcherActivityInfo;
+        mLauncherActivityInfoClass = ReflectUtils.getClassForName(
+                "android.content.pm.LauncherActivityInfo");
+        mGetComponentName = ReflectUtils.getMethod(mLauncherActivityInfoClass, "getComponentName");
+        mGetUser = ReflectUtils.getMethod(mLauncherActivityInfoClass, "getUser");
+        mGetLabel = ReflectUtils.getMethod(mLauncherActivityInfoClass, "getLabel");
+        mGetIcon = ReflectUtils.getMethod(mLauncherActivityInfoClass, "getIcon", int.class);
+        mGetApplicationFlags = ReflectUtils.getMethod(mLauncherActivityInfoClass,
+                "getApplicationFlags");
+        mGetFirstInstallTime = ReflectUtils.getMethod(mLauncherActivityInfoClass,
+                "getFirstInstallTime");
+        mGetBadgedIcon = ReflectUtils.getMethod(mLauncherActivityInfoClass, "getBadgedIcon",
+                int.class);
     }
 
     public ComponentName getComponentName() {
-        return mLauncherActivityInfo.getComponentName();
+        return (ComponentName) ReflectUtils.invokeMethod(mLauncherActivityInfo, mGetComponentName);
     }
 
     public UserHandleCompat getUser() {
-        return UserHandleCompat.fromUser(mLauncherActivityInfo.getUser());
+        return UserHandleCompat.fromUser((UserHandle) ReflectUtils.invokeMethod(
+                        mLauncherActivityInfo, mGetUser));
     }
 
     public CharSequence getLabel() {
-        return mLauncherActivityInfo.getLabel();
+        return (CharSequence) ReflectUtils.invokeMethod(mLauncherActivityInfo, mGetLabel);
     }
 
     public Drawable getIcon(int density) {
-        return mLauncherActivityInfo.getIcon(density);
+        return (Drawable) ReflectUtils.invokeMethod(mLauncherActivityInfo, mGetIcon, density);
     }
 
-    public ApplicationInfo getApplicationInfo() {
-        return mLauncherActivityInfo.getApplicationInfo();
+    public int getApplicationFlags() {
+        return (Integer) ReflectUtils.invokeMethod(mLauncherActivityInfo, mGetApplicationFlags);
     }
 
     public long getFirstInstallTime() {
-        return mLauncherActivityInfo.getFirstInstallTime();
+        return (Long) ReflectUtils.invokeMethod(mLauncherActivityInfo, mGetFirstInstallTime);
     }
 
     public Drawable getBadgedIcon(int density) {
-        return mLauncherActivityInfo.getBadgedIcon(density);
+        return (Drawable) ReflectUtils.invokeMethod(mLauncherActivityInfo, mGetBadgedIcon, density);
     }
 }
diff --git a/src/com/android/launcher3/compat/LauncherAppsCompat.java b/src/com/android/launcher3/compat/LauncherAppsCompat.java
index 8d978d4a3..069e3dea7 100644
--- a/src/com/android/launcher3/compat/LauncherAppsCompat.java
+++ b/src/com/android/launcher3/compat/LauncherAppsCompat.java
@@ -39,42 +39,40 @@ public abstract class LauncherAppsCompat {
     public static final String ACTION_MANAGED_PROFILE_REMOVED =
             "android.intent.action.MANAGED_PROFILE_REMOVED";
 
-    public interface OnAppsChangedCallbackCompat {
-        void onPackageRemoved(String packageName, UserHandleCompat user);
-        void onPackageAdded(String packageName, UserHandleCompat user);
-        void onPackageChanged(String packageName, UserHandleCompat user);
-        void onPackagesAvailable(String[] packageNames, UserHandleCompat user, boolean replacing);
-        void onPackagesUnavailable(String[] packageNames, UserHandleCompat user, boolean replacing);
+    public interface OnAppsChangedListenerCompat {
+        void onPackageRemoved(UserHandleCompat user, String packageName);
+        void onPackageAdded(UserHandleCompat user, String packageName);
+        void onPackageChanged(UserHandleCompat user, String packageName);
+        void onPackagesAvailable(UserHandleCompat user, String[] packageNames, boolean replacing);
+        void onPackagesUnavailable(UserHandleCompat user, String[] packageNames, boolean replacing);
     }
 
     protected LauncherAppsCompat() {
     }
 
-    private static LauncherAppsCompat sInstance;
-    private static Object sInstanceLock = new Object();
-
     public static LauncherAppsCompat getInstance(Context context) {
-        synchronized (sInstanceLock) {
-            // TODO change this to use api version once L gets an API number.
-            if (sInstance == null) {
-                if ("L".equals(Build.VERSION.CODENAME)) {
-                    sInstance = new LauncherAppsCompatVL(context);
-                } else {
-                    sInstance = new LauncherAppsCompatV16(context);
+        // TODO change this to use api version once L gets an API number.
+        if ("L".equals(Build.VERSION.CODENAME)) {
+            Object launcherApps = context.getSystemService("launcherapps");
+            if (launcherApps != null) {
+                LauncherAppsCompatVL compat = LauncherAppsCompatVL.build(context, launcherApps);
+                if (compat != null) {
+                    return compat;
                 }
             }
-            return sInstance;
         }
+        // Pre L or lunacher apps service not running, or reflection failed to find something.
+        return new LauncherAppsCompatV16(context);
     }
 
     public abstract List<LauncherActivityInfoCompat> getActivityList(String packageName,
             UserHandleCompat user);
     public abstract LauncherActivityInfoCompat resolveActivity(Intent intent,
             UserHandleCompat user);
-    public abstract void startActivityForProfile(ComponentName component, UserHandleCompat user,
-            Rect sourceBounds, Bundle opts);
-    public abstract void addOnAppsChangedCallback(OnAppsChangedCallbackCompat listener);
-    public abstract void removeOnAppsChangedCallback(OnAppsChangedCallbackCompat listener);
+    public abstract void startActivityForProfile(ComponentName component, Rect sourceBounds,
+            Bundle opts, UserHandleCompat user);
+    public abstract void addOnAppsChangedListener(OnAppsChangedListenerCompat listener);
+    public abstract void removeOnAppsChangedListener(OnAppsChangedListenerCompat listener);
     public abstract boolean isPackageEnabledForProfile(String packageName, UserHandleCompat user);
     public abstract boolean isActivityEnabledForProfile(ComponentName component,
             UserHandleCompat user);
diff --git a/src/com/android/launcher3/compat/LauncherAppsCompatV16.java b/src/com/android/launcher3/compat/LauncherAppsCompatV16.java
index f30c28b82..c739eb9d2 100644
--- a/src/com/android/launcher3/compat/LauncherAppsCompatV16.java
+++ b/src/com/android/launcher3/compat/LauncherAppsCompatV16.java
@@ -39,8 +39,8 @@ public class LauncherAppsCompatV16 extends LauncherAppsCompat {
 
     private PackageManager mPm;
     private Context mContext;
-    private List<OnAppsChangedCallbackCompat> mCallbacks
-            = new ArrayList<OnAppsChangedCallbackCompat>();
+    private List<OnAppsChangedListenerCompat> mListeners
+            = new ArrayList<OnAppsChangedListenerCompat>();
     private PackageMonitor mPackageMonitor;
 
     LauncherAppsCompatV16(Context context) {
@@ -71,8 +71,8 @@ public class LauncherAppsCompatV16 extends LauncherAppsCompat {
         return null;
     }
 
-    public void startActivityForProfile(ComponentName component, UserHandleCompat user,
-            Rect sourceBounds, Bundle opts) {
+    public void startActivityForProfile(ComponentName component, Rect sourceBounds,
+            Bundle opts, UserHandleCompat user) {
         Intent launchIntent = new Intent(Intent.ACTION_MAIN);
         launchIntent.addCategory(Intent.CATEGORY_LAUNCHER);
         launchIntent.setComponent(component);
@@ -81,18 +81,18 @@ public class LauncherAppsCompatV16 extends LauncherAppsCompat {
         mContext.startActivity(launchIntent, opts);
     }
 
-    public synchronized void addOnAppsChangedCallback(OnAppsChangedCallbackCompat callback) {
-        if (callback != null && !mCallbacks.contains(callback)) {
-            mCallbacks.add(callback);
-            if (mCallbacks.size() == 1) {
+    public synchronized void addOnAppsChangedListener(OnAppsChangedListenerCompat listener) {
+        if (listener != null && !mListeners.contains(listener)) {
+            mListeners.add(listener);
+            if (mListeners.size() == 1) {
                 registerForPackageIntents();
             }
         }
     }
 
-    public synchronized void removeOnAppsChangedCallback(OnAppsChangedCallbackCompat callback) {
-        mCallbacks.remove(callback);
-        if (mCallbacks.size() == 0) {
+    public synchronized void removeOnAppsChangedListener(OnAppsChangedListenerCompat listener) {
+        mListeners.remove(listener);
+        if (mListeners.size() == 0) {
             unregisterForPackageIntents();
         }
     }
@@ -131,8 +131,8 @@ public class LauncherAppsCompatV16 extends LauncherAppsCompat {
         mContext.registerReceiver(mPackageMonitor, filter);
     }
 
-    private synchronized List<OnAppsChangedCallbackCompat> getCallbacks() {
-        return new ArrayList<OnAppsChangedCallbackCompat>(mCallbacks);
+    private synchronized List<OnAppsChangedListenerCompat> getListeners() {
+        return new ArrayList<OnAppsChangedListenerCompat>(mListeners);
     }
 
     private class PackageMonitor extends BroadcastReceiver {
@@ -151,39 +151,39 @@ public class LauncherAppsCompatV16 extends LauncherAppsCompat {
                     return;
                 }
                 if (Intent.ACTION_PACKAGE_CHANGED.equals(action)) {
-                    for (OnAppsChangedCallbackCompat callback : getCallbacks()) {
-                        callback.onPackageChanged(packageName, user);
+                    for (OnAppsChangedListenerCompat listener : getListeners()) {
+                        listener.onPackageChanged(user, packageName);
                     }
                 } else if (Intent.ACTION_PACKAGE_REMOVED.equals(action)) {
                     if (!replacing) {
-                        for (OnAppsChangedCallbackCompat callback : getCallbacks()) {
-                            callback.onPackageRemoved(packageName, user);
+                        for (OnAppsChangedListenerCompat listener : getListeners()) {
+                            listener.onPackageRemoved(user, packageName);
                         }
                     }
                     // else, we are replacing the package, so a PACKAGE_ADDED will be sent
                     // later, we will update the package at this time
                 } else if (Intent.ACTION_PACKAGE_ADDED.equals(action)) {
                     if (!replacing) {
-                        for (OnAppsChangedCallbackCompat callback : getCallbacks()) {
-                            callback.onPackageAdded(packageName, user);
+                        for (OnAppsChangedListenerCompat listener : getListeners()) {
+                            listener.onPackageAdded(user, packageName);
                         }
                     } else {
-                        for (OnAppsChangedCallbackCompat callback : getCallbacks()) {
-                            callback.onPackageChanged(packageName, user);
+                        for (OnAppsChangedListenerCompat listener : getListeners()) {
+                            listener.onPackageChanged(user, packageName);
                         }
                     }
                 }
             } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(action)) {
                 final boolean replacing = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false);
                 String[] packages = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
-                for (OnAppsChangedCallbackCompat callback : getCallbacks()) {
-                    callback.onPackagesAvailable(packages, user, replacing);
+                for (OnAppsChangedListenerCompat listener : getListeners()) {
+                    listener.onPackagesAvailable(user, packages, replacing);
                 }
             } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(action)) {
                 final boolean replacing = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false);
                 String[] packages = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
-                for (OnAppsChangedCallbackCompat callback : getCallbacks()) {
-                    callback.onPackagesUnavailable(packages, user, replacing);
+                for (OnAppsChangedListenerCompat listener : getListeners()) {
+                    listener.onPackagesUnavailable(user, packages, replacing);
                 }
             }
         }
diff --git a/src/com/android/launcher3/compat/LauncherAppsCompatVL.java b/src/com/android/launcher3/compat/LauncherAppsCompatVL.java
index ca9b67146..21f2659ba 100644
--- a/src/com/android/launcher3/compat/LauncherAppsCompatVL.java
+++ b/src/com/android/launcher3/compat/LauncherAppsCompatVL.java
@@ -19,48 +19,99 @@ package com.android.launcher3.compat;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
-import android.content.pm.LauncherActivityInfo;
-import android.content.pm.LauncherApps;
 import android.graphics.Rect;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.UserHandle;
 
+import java.lang.reflect.InvocationHandler;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-public class LauncherAppsCompatVL extends LauncherAppsCompat {
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Method;
 
-    private LauncherApps mLauncherApps;
+public class LauncherAppsCompatVL extends LauncherAppsCompat {
 
-    private Map<OnAppsChangedCallbackCompat, WrappedCallback> mCallbacks
-            = new HashMap<OnAppsChangedCallbackCompat, WrappedCallback>();
+    private Object mLauncherApps;
+    private Class mLauncherAppsClass;
+    private Class mListenerClass;
+    private Method mGetActivityList;
+    private Method mResolveActivity;
+    private Method mStartActivityForProfile;
+    private Method mAddOnAppsChangedListener;
+    private Method mRemoveOnAppsChangedListener;
+    private Method mIsPackageEnabledForProfile;
+    private Method mIsActivityEnabledForProfile;
+
+    private Map<OnAppsChangedListenerCompat, Object> mListeners
+            = new HashMap<OnAppsChangedListenerCompat, Object>();
+
+    static LauncherAppsCompatVL build(Context context, Object launcherApps) {
+        LauncherAppsCompatVL compat = new LauncherAppsCompatVL(context, launcherApps);
+
+        compat.mListenerClass = ReflectUtils.getClassForName(
+                "android.content.pm.LauncherApps$OnAppsChangedListener");
+        compat.mLauncherAppsClass = ReflectUtils.getClassForName("android.content.pm.LauncherApps");
+
+        compat.mGetActivityList = ReflectUtils.getMethod(compat.mLauncherAppsClass,
+                "getActivityList",
+                String.class, UserHandle.class);
+        compat.mResolveActivity = ReflectUtils.getMethod(compat.mLauncherAppsClass,
+                "resolveActivity",
+                Intent.class, UserHandle.class);
+        compat.mStartActivityForProfile = ReflectUtils.getMethod(compat.mLauncherAppsClass,
+                "startActivityForProfile",
+                ComponentName.class, Rect.class, Bundle.class, UserHandle.class);
+        compat.mAddOnAppsChangedListener = ReflectUtils.getMethod(compat.mLauncherAppsClass,
+                "addOnAppsChangedListener", compat.mListenerClass);
+        compat.mRemoveOnAppsChangedListener = ReflectUtils.getMethod(compat.mLauncherAppsClass,
+                "removeOnAppsChangedListener", compat.mListenerClass);
+        compat.mIsPackageEnabledForProfile = ReflectUtils.getMethod(compat.mLauncherAppsClass,
+                "isPackageEnabledForProfile", String.class, UserHandle.class);
+        compat.mIsActivityEnabledForProfile = ReflectUtils.getMethod(compat.mLauncherAppsClass,
+                "isActivityEnabledForProfile", ComponentName.class, UserHandle.class);
+
+        if (compat.mListenerClass != null
+                && compat.mLauncherAppsClass != null
+                && compat.mGetActivityList != null
+                && compat.mResolveActivity != null
+                && compat.mStartActivityForProfile != null
+                && compat.mAddOnAppsChangedListener != null
+                && compat.mRemoveOnAppsChangedListener != null
+                && compat.mIsPackageEnabledForProfile != null
+                && compat.mIsActivityEnabledForProfile != null) {
+            return compat;
+        }
+        return null;
+    }
 
-    LauncherAppsCompatVL(Context context) {
+    private LauncherAppsCompatVL(Context context, Object launcherApps) {
         super();
-        mLauncherApps = (LauncherApps) context.getSystemService("launcherapps");
+        mLauncherApps = launcherApps;
     }
 
     public List<LauncherActivityInfoCompat> getActivityList(String packageName,
             UserHandleCompat user) {
-        List<LauncherActivityInfo> list = mLauncherApps.getActivityList(packageName,
-                user.getUser());
+        List<Object> list = (List<Object>) ReflectUtils.invokeMethod(mLauncherApps,
+                mGetActivityList, packageName, user.getUser());
         if (list.size() == 0) {
             return Collections.EMPTY_LIST;
         }
         ArrayList<LauncherActivityInfoCompat> compatList =
                 new ArrayList<LauncherActivityInfoCompat>(list.size());
-        for (LauncherActivityInfo info : list) {
+        for (Object info : list) {
             compatList.add(new LauncherActivityInfoCompatVL(info));
         }
         return compatList;
     }
 
     public LauncherActivityInfoCompat resolveActivity(Intent intent, UserHandleCompat user) {
-        LauncherActivityInfo activity = mLauncherApps.resolveActivity(intent, user.getUser());
+        Object activity = ReflectUtils.invokeMethod(mLauncherApps, mResolveActivity,
+                        intent, user.getUser());
         if (activity != null) {
             return new LauncherActivityInfoCompatVL(activity);
         } else {
@@ -68,64 +119,89 @@ public class LauncherAppsCompatVL extends LauncherAppsCompat {
         }
     }
 
-    public void startActivityForProfile(ComponentName component, UserHandleCompat user,
-            Rect sourceBounds, Bundle opts) {
-        mLauncherApps.startActivityForProfile(component, user.getUser(), sourceBounds, opts);
+    public void startActivityForProfile(ComponentName component, Rect sourceBounds,
+            Bundle opts, UserHandleCompat user) {
+        ReflectUtils.invokeMethod(mLauncherApps, mStartActivityForProfile,
+                component, sourceBounds, opts, user.getUser());
     }
 
-    public void addOnAppsChangedCallback(LauncherAppsCompat.OnAppsChangedCallbackCompat callback) {
-        WrappedCallback wrappedCallback = new WrappedCallback(callback);
-        synchronized (mCallbacks) {
-            mCallbacks.put(callback, wrappedCallback);
+    public void addOnAppsChangedListener(LauncherAppsCompat.OnAppsChangedListenerCompat listener) {
+        Object wrappedListener = Proxy.newProxyInstance(mListenerClass.getClassLoader(),
+                new Class[]{mListenerClass}, new WrappedListener(listener));
+        synchronized (mListeners) {
+            mListeners.put(listener, wrappedListener);
         }
-        mLauncherApps.addOnAppsChangedCallback(wrappedCallback);
+        ReflectUtils.invokeMethod(mLauncherApps, mAddOnAppsChangedListener, wrappedListener);
     }
 
-    public void removeOnAppsChangedCallback(
-            LauncherAppsCompat.OnAppsChangedCallbackCompat callback) {
-        WrappedCallback wrappedCallback = null;
-        synchronized (mCallbacks) {
-            wrappedCallback = mCallbacks.remove(callback);
+    public void removeOnAppsChangedListener(
+            LauncherAppsCompat.OnAppsChangedListenerCompat listener) {
+        Object wrappedListener = null;
+        synchronized (mListeners) {
+            wrappedListener = mListeners.remove(listener);
         }
-        if (wrappedCallback != null) {
-            mLauncherApps.removeOnAppsChangedCallback(wrappedCallback);
+        if (wrappedListener != null) {
+            ReflectUtils.invokeMethod(mLauncherApps, mRemoveOnAppsChangedListener, wrappedListener);
         }
     }
 
     public boolean isPackageEnabledForProfile(String packageName, UserHandleCompat user) {
-        return mLauncherApps.isPackageEnabledForProfile(packageName, user.getUser());
+        return (Boolean) ReflectUtils.invokeMethod(mLauncherApps, mIsPackageEnabledForProfile,
+                packageName, user.getUser());
     }
 
     public boolean isActivityEnabledForProfile(ComponentName component, UserHandleCompat user) {
-        return mLauncherApps.isActivityEnabledForProfile(component, user.getUser());
+        return (Boolean) ReflectUtils.invokeMethod(mLauncherApps, mIsActivityEnabledForProfile,
+                component, user.getUser());
     }
 
-    private static class WrappedCallback extends LauncherApps.OnAppsChangedCallback {
-        private LauncherAppsCompat.OnAppsChangedCallbackCompat mCallback;
+    private static class WrappedListener implements InvocationHandler {
+        private LauncherAppsCompat.OnAppsChangedListenerCompat mListener;
+
+        public WrappedListener(LauncherAppsCompat.OnAppsChangedListenerCompat listener) {
+            mListener = listener;
+        }
 
-        public WrappedCallback(LauncherAppsCompat.OnAppsChangedCallbackCompat callback) {
-            mCallback = callback;
+        public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
+            try {
+                String methodName = m.getName();
+                if ("onPackageRemoved".equals(methodName)) {
+                    onPackageRemoved((UserHandle) args[0], (String) args[1]);
+                } else if ("onPackageAdded".equals(methodName)) {
+                    onPackageAdded((UserHandle) args[0], (String) args[1]);
+                } else if ("onPackageChanged".equals(methodName)) {
+                    onPackageChanged((UserHandle) args[0], (String) args[1]);
+                } else if ("onPackagesAvailable".equals(methodName)) {
+                    onPackagesAvailable((UserHandle) args[0], (String []) args[1],
+                            (Boolean) args[2]);
+                } else if ("onPackagesUnavailable".equals(methodName)) {
+                    onPackagesUnavailable((UserHandle) args[0], (String []) args[1],
+                            (Boolean) args[2]);
+                }
+            } finally {
+                return null;
+            }
         }
 
-        public void onPackageRemoved(String packageName, UserHandle user) {
-            mCallback.onPackageRemoved(packageName, UserHandleCompat.fromUser(user));
+        public void onPackageRemoved(UserHandle user, String packageName) {
+            mListener.onPackageRemoved(UserHandleCompat.fromUser(user), packageName);
         }
 
-        public void onPackageAdded(String packageName, UserHandle user) {
-            mCallback.onPackageAdded(packageName, UserHandleCompat.fromUser(user));
+        public void onPackageAdded(UserHandle user, String packageName) {
+            mListener.onPackageAdded(UserHandleCompat.fromUser(user), packageName);
         }
 
-        public void onPackageChanged(String packageName, UserHandle user) {
-            mCallback.onPackageChanged(packageName, UserHandleCompat.fromUser(user));
+        public void onPackageChanged(UserHandle user, String packageName) {
+            mListener.onPackageChanged(UserHandleCompat.fromUser(user), packageName);
         }
 
-        public void onPackagesAvailable(String[] packageNames, UserHandle user, boolean replacing) {
-            mCallback.onPackagesAvailable(packageNames, UserHandleCompat.fromUser(user), replacing);
+        public void onPackagesAvailable(UserHandle user, String[] packageNames, boolean replacing) {
+            mListener.onPackagesAvailable(UserHandleCompat.fromUser(user), packageNames, replacing);
         }
 
-        public void onPackagesUnavailable(String[] packageNames, UserHandle user,
+        public void onPackagesUnavailable(UserHandle user, String[] packageNames,
                 boolean replacing) {
-            mCallback.onPackagesUnavailable(packageNames, UserHandleCompat.fromUser(user),
+            mListener.onPackagesUnavailable(UserHandleCompat.fromUser(user), packageNames,
                     replacing);
         }
     }
diff --git a/src/com/android/launcher3/compat/ReflectUtils.java b/src/com/android/launcher3/compat/ReflectUtils.java
new file mode 100644
index 000000000..e1b8a1f95
--- /dev/null
+++ b/src/com/android/launcher3/compat/ReflectUtils.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2014 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.launcher3.compat;
+
+import android.util.Log;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class ReflectUtils {
+    private static final String TAG = "LauncherReflect";
+
+    public static Class getClassForName(String className) {
+        try {
+            return Class.forName(className);
+        } catch (ClassNotFoundException e) {
+            Log.e(TAG, "Couldn't find class " + className, e);
+            return null;
+        }
+    }
+
+    public static Method getMethod(Class clazz, String method) {
+        try {
+            return clazz.getMethod(method);
+        } catch (NoSuchMethodException e) {
+            Log.e(TAG, "Couldn't find methid " + clazz.getName() + " " + method, e);
+            return null;
+        }
+    }
+
+    public static Method getMethod(Class clazz, String method, Class param1) {
+        try {
+            return clazz.getMethod(method, param1);
+        } catch (NoSuchMethodException e) {
+            Log.e(TAG, "Couldn't find methid " + clazz.getName() + " " + method, e);
+            return null;
+        }
+    }
+
+    public static Method getMethod(Class clazz, String method, Class param1, Class param2) {
+        try {
+            return clazz.getMethod(method, param1, param2);
+        } catch (NoSuchMethodException e) {
+            Log.e(TAG, "Couldn't find methid " + clazz.getName() + " " + method, e);
+            return null;
+        }
+    }
+
+    public static Method getMethod(Class clazz, String method, Class param1, Class param2,
+            Class param3) {
+        try {
+            return clazz.getMethod(method, param1, param2, param3);
+        } catch (NoSuchMethodException e) {
+            Log.e(TAG, "Couldn't find methid " + clazz.getName() + " " + method, e);
+            return null;
+        }
+    }
+
+    public static Method getMethod(Class clazz, String method, Class param1, Class param2,
+            Class param3, Class param4) {
+        try {
+            return clazz.getMethod(method, param1, param2, param3, param4);
+        } catch (NoSuchMethodException e) {
+            Log.e(TAG, "Couldn't find methid " + clazz.getName() + " " + method, e);
+            return null;
+        }
+    }
+
+    public static Object invokeMethod(Object object, Method method) {
+        try {
+            return method.invoke(object);
+        } catch (SecurityException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (IllegalArgumentException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (IllegalAccessException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (InvocationTargetException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        }
+        return null;
+    }
+
+    public static Object invokeMethod(Object object, Method method, Object param1) {
+        try {
+            return method.invoke(object, param1);
+        } catch (SecurityException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (IllegalArgumentException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (IllegalAccessException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (InvocationTargetException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        }
+        return null;
+    }
+
+    public static Object invokeMethod(Object object, Method method, Object param1, Object param2) {
+        try {
+            return method.invoke(object, param1, param2);
+        } catch (SecurityException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (IllegalArgumentException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (IllegalAccessException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (InvocationTargetException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        }
+        return null;
+    }
+
+    public static Object invokeMethod(Object object, Method method, Object param1, Object param2,
+            Object param3) {
+        try {
+            return method.invoke(object, param1, param2, param3);
+        } catch (SecurityException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (IllegalArgumentException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (IllegalAccessException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (InvocationTargetException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        }
+        return null;
+    }
+
+    public static Object invokeMethod(Object object, Method method, Object param1, Object param2,
+            Object param3, Object param4) {
+        try {
+            return method.invoke(object, param1, param2, param3, param4);
+        } catch (SecurityException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (IllegalArgumentException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (IllegalAccessException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        } catch (InvocationTargetException e) {
+            Log.e(TAG, "Couldn't invoke method " + method, e);
+        }
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/launcher3/compat/UserManagerCompat.java b/src/com/android/launcher3/compat/UserManagerCompat.java
index c10a74307..256e04a7b 100644
--- a/src/com/android/launcher3/compat/UserManagerCompat.java
+++ b/src/com/android/launcher3/compat/UserManagerCompat.java
@@ -41,5 +41,4 @@ public abstract class UserManagerCompat {
     public abstract long getSerialNumberForUser(UserHandleCompat user);
     public abstract UserHandleCompat getUserForSerialNumber(long serialNumber);
     public abstract Drawable getBadgedDrawableForUser(Drawable unbadged, UserHandleCompat user);
-    public abstract String getBadgedLabelForUser(String label, UserHandleCompat user);
 }
diff --git a/src/com/android/launcher3/compat/UserManagerCompatV16.java b/src/com/android/launcher3/compat/UserManagerCompatV16.java
index 03dd0972c..2009e4e27 100644
--- a/src/com/android/launcher3/compat/UserManagerCompatV16.java
+++ b/src/com/android/launcher3/compat/UserManagerCompatV16.java
@@ -44,8 +44,4 @@ public class UserManagerCompatV16 extends UserManagerCompat {
     public long getSerialNumberForUser(UserHandleCompat user) {
         return 0;
     }
-
-    public String getBadgedLabelForUser(String label, UserHandleCompat user) {
-        return label;
-    }
 }
diff --git a/src/com/android/launcher3/compat/UserManagerCompatVL.java b/src/com/android/launcher3/compat/UserManagerCompatVL.java
index e071a8f71..8d3ca8577 100644
--- a/src/com/android/launcher3/compat/UserManagerCompatVL.java
+++ b/src/com/android/launcher3/compat/UserManagerCompatVL.java
@@ -22,8 +22,9 @@ import android.graphics.drawable.Drawable;
 import android.os.UserHandle;
 import android.os.UserManager;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 public class UserManagerCompatVL extends UserManagerCompatV17 {
@@ -33,27 +34,35 @@ public class UserManagerCompatVL extends UserManagerCompatV17 {
     }
 
     public List<UserHandleCompat> getUserProfiles() {
-        List<UserHandle> users = mUserManager.getUserProfiles();
-        if (users == null) {
-            return Collections.EMPTY_LIST;
+        Method method = ReflectUtils.getMethod(mUserManager.getClass(), "getUserProfiles");
+        if (method != null) {
+            List<UserHandle> users = (List<UserHandle>) ReflectUtils.invokeMethod(
+                    mUserManager, method);
+            if (users != null) {
+                ArrayList<UserHandleCompat> compatUsers = new ArrayList<UserHandleCompat>(
+                        users.size());
+                for (UserHandle user : users) {
+                    compatUsers.add(UserHandleCompat.fromUser(user));
+                }
+                return compatUsers;
+            }
         }
-        ArrayList<UserHandleCompat> compatUsers = new ArrayList<UserHandleCompat>(
-                users.size());
-        for (UserHandle user : users) {
-            compatUsers.add(UserHandleCompat.fromUser(user));
-        }
-        return compatUsers;
+        // Fall back to non L version.
+        return super.getUserProfiles();
     }
 
     public Drawable getBadgedDrawableForUser(Drawable unbadged, UserHandleCompat user) {
-        return mUserManager.getBadgedDrawableForUser(unbadged, user.getUser());
-    }
-
-    public String getBadgedLabelForUser(String label, UserHandleCompat user) {
-        if (user == null) {
-            return label;
+        Method method = ReflectUtils.getMethod(mUserManager.getClass(), "getBadgedDrawableForUser",
+                Drawable.class, UserHandle.class);
+        if (method != null) {
+            Drawable d = (Drawable) ReflectUtils.invokeMethod(mUserManager, method, unbadged,
+                    user.getUser());
+            if (d != null) {
+                return d;
+            }
         }
-        return mUserManager.getBadgedLabelForUser(label, user.getUser());
+        // Fall back to non L version.
+        return super.getBadgedDrawableForUser(unbadged, user);
     }
 }