diff options
Diffstat (limited to 'src/com/android/launcher3/compat')
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); } } |