Java 类android.content.pm.LauncherActivityInfo 实例源码

@Override
public ApplicationInfo getApplicationInfo(String packageName, int flags, UserHandle user) {
    final boolean isPrimaryUser = Process.myUserHandle().equals(user);
    if (!isPrimaryUser && (flags == 0)) {
        // We are looking for an installed app on a secondary profile. Prior to O, the only
        // entry point for work profiles is through the LauncherActivity.
        List<LauncherActivityInfo> activityList =
                mLauncherApps.getActivityList(packageName, user);
        return activityList.size() > 0 ? activityList.get(0).getApplicationInfo() : null;
    }
    try {
        ApplicationInfo info =
                mContext.getPackageManager().getApplicationInfo(packageName, flags);
        // There is no way to check if the app is installed for managed profile. But for
        // primary profile, we can still have this check.
        if (isPrimaryUser && ((info.flags & ApplicationInfo.FLAG_INSTALLED) == 0)
                || !info.enabled) {
            return null;
        }
        return info;
    } catch (PackageManager.NameNotFoundException e) {
        // Package not found
        return null;
    }
}

@Override
public boolean startConfigActivity(Activity activity, int requestCode) {
    if (getUser().equals(Process.myUserHandle())) {
        return super.startConfigActivity(activity, requestCode);
    }
    try {
        Method m = LauncherApps.class.getDeclaredMethod(
                "getShortcutConfigActivityIntent", LauncherActivityInfo.class);
        IntentSender is = (IntentSender) m.invoke(
                activity.getSystemService(LauncherApps.class), mInfo);
        activity.startIntentSenderForResult(is, requestCode, null, 0, 0, 0);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

@Override
public void onPackageAdded(String packageName, UserHandle user) {
    String prefKey = INSTALLED_PACKAGES_PREFIX + mUserManager.getSerialNumberForUser(user);
    HashSet<String> packageSet = new HashSet<>();
    final boolean userAppsExisted = getUserApps(packageSet, prefKey);
    if (!packageSet.contains(packageName)) {
        List<LauncherActivityInfo> activities =
                mLauncherApps.getActivityList(packageName, user);
        if (!activities.isEmpty()) {
            LauncherActivityInfo activityInfo = activities.get(0);

            packageSet.add(packageName);
            mPrefs.edit().putStringSet(prefKey, packageSet).apply();
            onLauncherAppsAdded(Arrays.asList(
                    new LauncherActivityInstallInfo(activityInfo, System.currentTimeMillis())),
                    user, userAppsExisted);
        }
    }
}

/**
 * Updates the entries related to the given package in memory and persistent DB.
 */
public synchronized void updateIconsForPkg(String packageName, UserHandle user) {
    removeIconsForPkg(packageName, user);
    try {
        int uninstalled = android.os.Build.VERSION.SDK_INT >= 24 ? PackageManager.MATCH_UNINSTALLED_PACKAGES : PackageManager.GET_UNINSTALLED_PACKAGES;

        PackageInfo info = mPackageManager.getPackageInfo(packageName,
                uninstalled);
        long userSerial = mUserManager.getSerialNumberForUser(user);
        for (LauncherActivityInfo app : mLauncherApps.getActivityList(packageName, user)) {
            addIconToDBAndMemCache(app, info, userSerial, false /*replace existing*/);
        }
    } catch (NameNotFoundException e) {
        e.printStackTrace();
        return;
    }
}

public void updateDbIcons(Set<String> ignorePackagesForMainUser) {
    // Remove all active icon update tasks.
    mWorkerHandler.removeCallbacksAndMessages(ICON_UPDATE_TOKEN);

    mIconProvider.updateSystemStateString();
    for (UserHandle user : mUserManager.getUserProfiles()) {
        // Query for the set of apps
        final List<LauncherActivityInfo> apps = mLauncherApps.getActivityList(null, user);
        // Fail if we don't have any apps
        // TODO: Fix this. Only fail for the current user.
        if (apps == null || apps.isEmpty()) {
            return;
        }

        // Update icon cache. This happens in segments and {@link #onPackageIconsUpdated}
        // is called by the icon cache when the job is complete.
        updateDBIcons(user, apps, Process.myUserHandle().equals(user)
                ? ignorePackagesForMainUser : Collections.<String>emptySet());
    }
}

/**
 * Adds an entry into the DB and the in-memory cache.
 * @param replaceExisting if true, it will recreate the bitmap even if it already exists in
 *                        the memory. This is useful then the previous bitmap was created using
 *                        old data.
 */
@Thunk private synchronized void addIconToDBAndMemCache(LauncherActivityInfo app,
        PackageInfo info, long userSerial, boolean replaceExisting) {
    final ComponentKey key = new ComponentKey(app.getComponentName(), app.getUser());
    CacheEntry entry = null;
    if (!replaceExisting) {
        entry = mCache.get(key);
        // We can't reuse the entry if the high-res icon is not present.
        if (entry == null || entry.isLowResIcon || entry.icon == null) {
            entry = null;
        }
    }
    if (entry == null) {
        entry = new CacheEntry();
        entry.icon = LauncherIcons.createBadgedIconBitmap(getFullResIcon(app), app.getUser(),
                mContext,  app.getApplicationInfo().targetSdkVersion);
    }
    entry.title = app.getLabel();
    entry.contentDescription = mUserManager.getBadgedLabelForUser(entry.title, app.getUser());
    mCache.put(key, entry);

    Bitmap lowResIcon = generateLowResIcon(entry.icon, mActivityBgColor);
    ContentValues values = newContentValues(entry.icon, lowResIcon, entry.title.toString(),
            app.getApplicationInfo().packageName);
    addIconToDB(values, app.getComponentName(), info, userSerial);
}

/**
 * Tries to create a new PendingInstallShortcutInfo which represents the same target,
 * but is an app target and not a shortcut.
 * @return the newly created info or the original one.
 */
private static PendingInstallShortcutInfo convertToLauncherActivityIfPossible(
        PendingInstallShortcutInfo original) {
    if (original.isLauncherActivity()) {
        // Already an activity target
        return original;
    }
    if (!Utilities.isLauncherAppTarget(original.launchIntent)) {
        return original;
    }

    LauncherActivityInfo info = LauncherAppsCompat.getInstance(original.mContext)
            .resolveActivity(original.launchIntent, original.user);
    if (info == null) {
        return original;
    }
    // Ignore any conflicts in the label name, as that can change based on locale.
    return new PendingInstallShortcutInfo(info, original.mContext);
}

@Override
public View getView(int position, View convertView, ViewGroup viewGroup) {
    ViewHolder holder = new ViewHolder();
    if(convertView == null) {
        convertView = mInflater.inflate(R.layout.app_list_item,null, false);
        holder.icon = (ImageView)convertView.findViewById(R.id.icon);
        holder.lable = (TextView)convertView.findViewById(R.id.label);
        convertView.setTag(holder);
    } else {
        holder = (ViewHolder) convertView.getTag();
    }
    LauncherActivityInfo appInfo = mData.get(position);
    holder.icon.setImageDrawable(appInfo.getIcon(0));
    holder.lable.setText(appInfo.getLabel());
    return convertView;
}

@Override
public View getView(int position, View convertView, ViewGroup viewGroup) {
    ViewHolder holder = new ViewHolder();
    if(convertView == null) {
        convertView = mInflater.inflate(R.layout.app_list_item,null, false);
        holder.icon = (ImageView)convertView.findViewById(R.id.icon);
        holder.lable = (TextView)convertView.findViewById(R.id.label);
        convertView.setTag(holder);
    } else {
        holder = (ViewHolder) convertView.getTag();
    }
    LauncherActivityInfo appInfo = mData.get(position);
    holder.icon.setImageDrawable(appInfo.getIcon(0));
    holder.lable.setText(appInfo.getLabel());
    return convertView;
}

@Override
public List<ShortcutConfigActivityInfo> getCustomShortcutActivityList(
        @Nullable PackageUserKey packageUser) {
    List<ShortcutConfigActivityInfo> result = new ArrayList<>();
    UserHandle myUser = Process.myUserHandle();

    try {
        Method m = LauncherApps.class.getDeclaredMethod("getShortcutConfigActivityList",
                String.class, UserHandle.class);
        final List<UserHandle> users;
        final String packageName;
        if (packageUser == null) {
            users = UserManagerCompat.getInstance(mContext).getUserProfiles();
            packageName = null;
        } else {
            users = new ArrayList<>(1);
            users.add(packageUser.mUser);
            packageName = packageUser.mPackageName;
        }
        for (UserHandle user : users) {
            boolean ignoreTargetSdk = myUser.equals(user);
            List<LauncherActivityInfo> activities =
                    (List<LauncherActivityInfo>) m.invoke(mLauncherApps, packageName, user);
            for (LauncherActivityInfo activityInfo : activities) {
                if (ignoreTargetSdk || activityInfo.getApplicationInfo().targetSdkVersion >=
                        Build.VERSION_CODES.O) {
                    result.add(new ShortcutConfigActivityInfoVO(activityInfo));
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

    return result;
}

/**
 * Make an ShortcutInfo object for a shortcut that is an application.
 */
public ShortcutInfo getAppShortcutInfo(
        Intent intent, boolean allowMissingTarget, boolean useLowResIcon) {
    if (user == null) {
        return null;
    }

    ComponentName componentName = intent.getComponent();
    if (componentName == null) {
        return null;
    }

    Intent newIntent = new Intent(Intent.ACTION_MAIN, null);
    newIntent.addCategory(Intent.CATEGORY_LAUNCHER);
    newIntent.setComponent(componentName);
    LauncherActivityInfo lai = LauncherAppsCompat.getInstance(mContext)
            .resolveActivity(newIntent, user);
    if ((lai == null) && !allowMissingTarget) {
        return null;
    }

    final ShortcutInfo info = new ShortcutInfo();
    info.itemType = LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
    info.user = user;
    info.intent = newIntent;

    mIconCache.getTitleAndIcon(info, lai, useLowResIcon);
    if (mIconCache.isDefaultIcon(info.iconBitmap, user)) {
        Bitmap icon = loadIcon(info);
        info.iconBitmap = icon != null ? icon : info.iconBitmap;
    }

    if (lai != null && PackageManagerHelper.isAppSuspended(lai.getApplicationInfo())) {
        info.isDisabled = ShortcutInfo.FLAG_DISABLED_SUSPENDED;
    }

    // from the db
    if (TextUtils.isEmpty(info.title)) {
        info.title = getTitle();
    }

    // fall back to the class name of the activity
    if (info.title == null) {
        info.title = componentName.getClassName();
    }

    info.contentDescription = mUserManager.getBadgedLabelForUser(info.title, info.user);
    return info;
}

/**
 * Add the supplied ApplicationInfo objects to the list, and enqueue it into the
 * list to broadcast when notify() is called.
 *
 * If the app is already in the list, doesn't add it.
 */
public void add(AppInfo info, LauncherActivityInfo activityInfo) {
    if (!mAppFilter.shouldShowApp(info.componentName.getPackageName(), mContext)) {
        return;
    }
    if (findActivity(data, info.componentName, info.user)) {
        return;
    }
    mIconCache.getTitleAndIcon(info, activityInfo, true /* useLowResIcon */);

    data.add(info);
    added.add(info);
}

/**
 * Add the icons for the supplied apk called packageName.
 */
public void addPackage(Context context, String packageName, UserHandle user) {
    final LauncherAppsCompat launcherApps = LauncherAppsCompat.getInstance(context);
    final List<LauncherActivityInfo> matches = launcherApps.getActivityList(packageName,
            user);

    for (LauncherActivityInfo info : matches) {
        add(new AppInfo(context, info, user), info);
    }
}

/**
 * Returns whether <em>apps</em> contains <em>component</em>.
 */
private static boolean findActivity(List<LauncherActivityInfo> apps,
        ComponentName component) {
    for (LauncherActivityInfo info : apps) {
        if (info.getComponentName().equals(component)) {
            return true;
        }
    }
    return false;
}

private void scheduleManagedHeuristicRunnable(final ManagedProfileHeuristic heuristic,
        final UserHandle user, final List<LauncherActivityInfo> apps) {
    if (heuristic != null) {
        // Assume the app lists now is updated.
        mIsManagedHeuristicAppsUpdated = false;
        final Runnable managedHeuristicRunnable = new Runnable() {
            @Override
            public void run() {
                if (mIsManagedHeuristicAppsUpdated) {
                    // If app list is updated, we need to reschedule it otherwise old app
                    // list will override everything in processUserApps().
                    sWorker.post(new Runnable() {
                        public void run() {
                            final List<LauncherActivityInfo> updatedApps =
                                    mLauncherApps.getActivityList(null, user);
                            scheduleManagedHeuristicRunnable(heuristic, user,
                                    updatedApps);
                        }
                    });
                } else {
                    heuristic.processUserApps(apps);
                }
            }
        };
        runOnMainThread(new Runnable() {
            @Override
            public void run() {
                // Check isLoadingWorkspace on the UI thread, as it is updated on the UI
                // thread.
                if (mIsLoadingAndBindingWorkspace) {
                    synchronized (mBindCompleteRunnables) {
                        mBindCompleteRunnables.add(managedHeuristicRunnable);
                    }
                } else {
                    runOnWorkerThread(managedHeuristicRunnable);
                }
            }
        });
    }
}

/**
 * Checks the list of user apps, and generates package event accordingly.
 * {@see #onLauncherAppsAdded}, {@see #onLauncherPackageRemoved}
 */
void processUserApps(List<LauncherActivityInfo> apps, UserHandle user) {
    String prefKey = INSTALLED_PACKAGES_PREFIX + mUserManager.getSerialNumberForUser(user);
    HashSet<String> oldPackageSet = new HashSet<>();
    final boolean userAppsExisted = getUserApps(oldPackageSet, prefKey);

    HashSet<String> packagesRemoved = new HashSet<>(oldPackageSet);
    HashSet<String> newPackageSet = new HashSet<>();
    ArrayList<LauncherActivityInstallInfo> packagesAdded = new ArrayList<>();

    for (LauncherActivityInfo info : apps) {
        String packageName = info.getComponentName().getPackageName();
        newPackageSet.add(packageName);
        packagesRemoved.remove(packageName);

        if (!oldPackageSet.contains(packageName)) {
            oldPackageSet.add(packageName);
            packagesAdded.add(new LauncherActivityInstallInfo(
                    info, info.getFirstInstallTime()));
        }
    }

    if (!packagesAdded.isEmpty() || !packagesRemoved.isEmpty()) {
        mPrefs.edit().putStringSet(prefKey, newPackageSet).apply();

        if (!packagesAdded.isEmpty()) {
            Collections.sort(packagesAdded);
            onLauncherAppsAdded(packagesAdded, user, userAppsExisted);
        }

        if (!packagesRemoved.isEmpty()) {
            for (String pkg : packagesRemoved) {
                onLauncherPackageRemoved(pkg, user);
            }
        }
    }
}

private Drawable getIconFromHandler(LauncherActivityInfo info) {
    Bitmap bm = mIconsManager.getDrawableIconForPackage(info.getComponentName());
    if (bm == null) {
        return null;
    }
    return new BitmapDrawable(mContext.getResources(), LauncherIcons.createIconBitmap(bm, mContext));
}

public void addCustomInfoToDataBase(Drawable icon, ItemInfo info, CharSequence title) {
    LauncherActivityInfo app = mLauncherApps.resolveActivity(info.getIntent(), info.user);
    final ComponentKey key = new ComponentKey(app.getComponentName(), app.getUser());
    CacheEntry entry = mCache.get(key);
    PackageInfo packageInfo = null;
    try {
        packageInfo = mPackageManager.getPackageInfo(
                app.getComponentName().getPackageName(), 0);
    } catch (NameNotFoundException e) {
        e.printStackTrace();
    }
    // We can't reuse the entry if the high-res icon is not present.
    if (entry == null || entry.isLowResIcon || entry.icon == null) {
        entry = new CacheEntry();
    }
    entry.icon = LauncherIcons.createIconBitmap(icon, mContext);

    entry.title = title != null ? title : app.getLabel();

    entry.contentDescription = mUserManager.getBadgedLabelForUser(entry.title, app.getUser());
    mCache.put(key, entry);

    Bitmap lowResIcon = generateLowResIcon(entry.icon, mActivityBgColor);
    ContentValues values = newContentValues(entry.icon, lowResIcon, entry.title.toString(),
            app.getApplicationInfo().packageName);
    if (packageInfo != null) {
        addIconToDB(values, app.getComponentName(), packageInfo,
                mUserManager.getSerialNumberForUser(app.getUser()));
    }
}

/**
 * Updates {@param application} only if a valid entry is found.
 */
public synchronized void updateTitleAndIcon(AppInfo application) {
    CacheEntry entry = cacheLocked(application.componentName,
            Provider.<LauncherActivityInfo>of(null),
            application.user, false, application.usingLowResIcon);
    if (entry.icon != null && !isDefaultIcon(entry.icon, application.user)) {
        applyCacheEntry(entry, application);
    }
}

/**
 * Fill in {@param info} with the icon and label for {@param activityInfo}
 */
public synchronized void getTitleAndIcon(ItemInfoWithIcon info,
        LauncherActivityInfo activityInfo, boolean useLowResIcon) {

    // If we already have activity info, no need to use package icon
    getTitleAndIcon(info, Provider.of(activityInfo), false, useLowResIcon);
}

/**
 * Fill in {@param shortcutInfo} with the icon and label for {@param info}
 */
private synchronized void getTitleAndIcon(
        @NonNull ItemInfoWithIcon infoInOut,
        @NonNull Provider<LauncherActivityInfo> activityInfoProvider,
        boolean usePkgIcon, boolean useLowResIcon) {
    CacheEntry entry = cacheLocked(infoInOut.getTargetComponent(), activityInfoProvider,
            infoInOut.user, usePkgIcon, useLowResIcon);
    applyCacheEntry(entry, infoInOut);
}

@Thunk SerializedIconUpdateTask(long userSerial, HashMap<String, PackageInfo> pkgInfoMap,
        Stack<LauncherActivityInfo> appsToAdd,
        Stack<LauncherActivityInfo> appsToUpdate) {
    mUserSerial = userSerial;
    mPkgInfoMap = pkgInfoMap;
    mAppsToAdd = appsToAdd;
    mAppsToUpdate = appsToUpdate;
}

/**
 * Initializes a PendingInstallShortcutInfo to represent a launcher target.
 */
PendingInstallShortcutInfo(LauncherActivityInfo info, Context context) {
    activityInfo = info;
    shortcutInfo = null;
    providerInfo = null;

    data = null;
    user = info.getUser();
    mContext = context;

    launchIntent = AppInfo.makeLaunchIntent(info);
    label = info.getLabel().toString();
}

public AppInfo(LauncherActivityInfo info, UserHandle user, boolean quietModeEnabled) {
    this.componentName = info.getComponentName();
    this.container = ItemInfo.NO_ID;
    this.user = user;
    if (PackageManagerHelper.isAppSuspended(info.getApplicationInfo())) {
        isDisabled |= ShortcutInfo.FLAG_DISABLED_SUSPENDED;
    }
    if (quietModeEnabled) {
        isDisabled |= ShortcutInfo.FLAG_DISABLED_QUIET_USER;
    }

    intent = makeLaunchIntent(info);
}

public List<LauncherActivityInfoCompat> getActivityList(String packageName,
        UserHandleCompat user) {
    List<LauncherActivityInfo> list = mLauncherApps.getActivityList(packageName,
            user.getUser());
    if (list.size() == 0) {
        return Collections.emptyList();
    }
    ArrayList<LauncherActivityInfoCompat> compatList =
            new ArrayList<LauncherActivityInfoCompat>(list.size());
    for (LauncherActivityInfo info : list) {
        compatList.add(new LauncherActivityInfoCompatVL(info));
    }
    return compatList;
}

public LauncherActivityInfoCompat resolveActivity(Intent intent, UserHandleCompat user) {
    LauncherActivityInfo activity = mLauncherApps.resolveActivity(intent, user.getUser());
    if (activity != null) {
        return new LauncherActivityInfoCompatVL(activity);
    } else {
        return null;
    }
}

public List<LauncherActivityInfoCompat> getActivityList(String packageName,
        UserHandleCompat user) {
    List<LauncherActivityInfo> list = mLauncherApps.getActivityList(packageName,
            user.getUser());
    if (list.size() == 0) {
        return Collections.emptyList();
    }
    ArrayList<LauncherActivityInfoCompat> compatList =
            new ArrayList<LauncherActivityInfoCompat>(list.size());
    for (LauncherActivityInfo info : list) {
        compatList.add(new LauncherActivityInfoCompatVL(info));
    }
    return compatList;
}

public LauncherActivityInfoCompat resolveActivity(Intent intent, UserHandleCompat user) {
    LauncherActivityInfo activity = mLauncherApps.resolveActivity(intent, user.getUser());
    if (activity != null) {
        return new LauncherActivityInfoCompatVL(activity);
    } else {
        return null;
    }
}

public Drawable getIcon(Context context, PackageManager pm, LauncherActivityInfo appInfo) {
    UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
    String name = appInfo.getComponentName().flattenToString() + ":" + userManager.getSerialNumberForUser(appInfo.getUser());

    BitmapDrawable drawable;

    synchronized (drawables) {
        drawable = drawables.get(name);
        if(drawable == null) {
            Drawable loadedIcon = loadIcon(context, pm, appInfo);

            if(loadedIcon instanceof BitmapDrawable)
                drawable = (BitmapDrawable) loadedIcon;
            else {
                int width = Math.max(loadedIcon.getIntrinsicWidth(), 1);
                int height = Math.max(loadedIcon.getIntrinsicHeight(), 1);

                Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
                Canvas canvas = new Canvas(bitmap);

                loadedIcon.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
                loadedIcon.draw(canvas);

                drawable = new BitmapDrawable(context.getResources(), bitmap);
            }

            drawables.put(name, drawable);
        }
    }

    return drawable;
}

private Drawable getIcon(PackageManager pm, LauncherActivityInfo appInfo) {
    try {
        return appInfo.getBadgedIcon(0);
    } catch (NullPointerException e) {
        return pm.getDefaultActivityIcon();
    }
}

public List<LauncherActivityInfoCompat> getActivityList(String packageName,
        UserHandleCompat user) {
    List<LauncherActivityInfo> list = mLauncherApps.getActivityList(packageName,
            user.getUser());
    if (list.size() == 0) {
        return Collections.emptyList();
    }
    ArrayList<LauncherActivityInfoCompat> compatList =
            new ArrayList<LauncherActivityInfoCompat>(list.size());
    for (LauncherActivityInfo info : list) {
        compatList.add(new LauncherActivityInfoCompatVL(info));
    }
    return compatList;
}

public LauncherActivityInfoCompat resolveActivity(Intent intent, UserHandleCompat user) {
    LauncherActivityInfo activity = mLauncherApps.resolveActivity(intent, user.getUser());
    if (activity != null) {
        return new LauncherActivityInfoCompatVL(activity);
    } else {
        return null;
    }
}

public List<LauncherActivityInfoCompat> getActivityList(String packageName,
        UserHandleCompat user) {
    List<LauncherActivityInfo> list = mLauncherApps.getActivityList(packageName,
            user.getUser());
    if (list.size() == 0) {
        return Collections.emptyList();
    }
    ArrayList<LauncherActivityInfoCompat> compatList =
            new ArrayList<LauncherActivityInfoCompat>(list.size());
    for (LauncherActivityInfo info : list) {
        compatList.add(new LauncherActivityInfoCompatVL(info));
    }
    return compatList;
}

public LauncherActivityInfoCompat resolveActivity(Intent intent, UserHandleCompat user) {
    LauncherActivityInfo activity = mLauncherApps.resolveActivity(intent, user.getUser());
    if (activity != null) {
        return new LauncherActivityInfoCompatVL(activity);
    } else {
        return null;
    }
}

@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
    // launch the app
    LauncherActivityInfo appInfo = mAdapter.getItem(position);
    ComponentName appComponent = appInfo.getComponentName();
    Intent intent = new Intent(Intent.makeMainActivity(appComponent));
    startActivity(intent);
    // appInfo.getApplicationInfo().processName
    Intent result = new Intent();
    result.putExtra("processName", appInfo.getApplicationInfo().processName);
    setResult(Activity.RESULT_OK, result);
    finish();
}

public List<LauncherActivityInfoCompat> getActivityList(String packageName,
        UserHandleCompat user) {
    List<LauncherActivityInfo> list = mLauncherApps.getActivityList(packageName,
            user.getUser());
    if (list.size() == 0) {
        return Collections.emptyList();
    }
    ArrayList<LauncherActivityInfoCompat> compatList =
            new ArrayList<LauncherActivityInfoCompat>(list.size());
    for (LauncherActivityInfo info : list) {
        compatList.add(new LauncherActivityInfoCompatVL(info));
    }
    return compatList;
}

public LauncherActivityInfoCompat resolveActivity(Intent intent, UserHandleCompat user) {
    LauncherActivityInfo activity = mLauncherApps.resolveActivity(intent, user.getUser());
    if (activity != null) {
        return new LauncherActivityInfoCompatVL(activity);
    } else {
        return null;
    }
}

@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
    // launch the app
    LauncherActivityInfo appInfo = mAdapter.getItem(position);
    ComponentName appComponent = appInfo.getComponentName();
    Intent intent = new Intent(Intent.makeMainActivity(appComponent));
    startActivity(intent);
    // appInfo.getApplicationInfo().processName
    Intent result = new Intent();
    result.putExtra("processName", appInfo.getApplicationInfo().processName);
    setResult(Activity.RESULT_OK, result);
    finish();
}

public List<LauncherActivityInfoCompat> getActivityList(String packageName,
        UserHandleCompat user) {
    List<LauncherActivityInfo> list = mLauncherApps.getActivityList(packageName,
            user.getUser());
    if (list.size() == 0) {
        return Collections.EMPTY_LIST;
    }
    ArrayList<LauncherActivityInfoCompat> compatList =
            new ArrayList<LauncherActivityInfoCompat>(list.size());
    for (LauncherActivityInfo info : list) {
        compatList.add(new LauncherActivityInfoCompatVL(info));
    }
    return compatList;
}

public LauncherActivityInfoCompat resolveActivity(Intent intent, UserHandleCompat user) {
    LauncherActivityInfo activity = mLauncherApps.resolveActivity(intent, user.getUser());
    if (activity != null) {
        return new LauncherActivityInfoCompatVL(activity);
    } else {
        return null;
    }
}