Jak uzyskać listę zainstalowanych aplikacji na Androida i wybrać jedną do uruchomienia

326

Zadałem podobne pytanie do tego na początku tego tygodnia, ale nadal nie rozumiem, jak uzyskać listę wszystkich zainstalowanych aplikacji, a następnie wybrać jedną do uruchomienia.

Próbowałem:

Intent intent = new Intent(ACTION_MAIN);
intent.addCategory(CATEGORY_LAUNCHER);

i pokazuje to tylko aplikacje, które są wstępnie zainstalowane lub mogą obsługiwać ACTION_MAINtyp zamierzony.

Wiem też, że mogę użyć, PackageManageraby uzyskać wszystkie zainstalowane aplikacje, ale jak mam to zrobić, aby uruchomić określoną aplikację?

2 Prawda
źródło
Jak uzyskać tylko informacje o wybranej aplikacji z listy?
Pedrum

Odpowiedzi:

277

Poniżej znajduje się kod, aby uzyskać listę działań / aplikacji zainstalowanych na Androidzie:

Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
List<ResolveInfo> pkgAppsList = context.getPackageManager().queryIntentActivities( mainIntent, 0);

Otrzymasz wszystkie niezbędne dane ResolveInfodo uruchomienia aplikacji. Możesz sprawdzić ResolveInfojavadoc tutaj .

Karan
źródło
3
Jak mogę rozpocząć jedną z nich? Mam ActivityInfo wewnątrz ResolveInfo, ale nie mogę go uruchomić.
Spidey
1
Nieważne, znalazłem to. Powinienem utworzyć nową intencję, używając pełnej nazwy klasy (pakiet + klasa).
Spidey
Jak uzyskać tylko informacje o wybranej aplikacji z listy?
Pedrum
1
Chciałem zrozumieć zasady sklepu Android / Play dotyczące mojej aplikacji czytającej i przechowującej listę wszystkich aplikacji oraz potencjalnie komunikującej się z serwerem. Czy są jakieś wytyczne?
dowjones123
1
@ dowjones123 Czy zdarzyło Ci się znaleźć wytyczne dotyczące tego?
RmK
415

Oto czystszy sposób korzystania z PackageManager

final PackageManager pm = getPackageManager();
//get a list of installed apps.
List<ApplicationInfo> packages = pm.getInstalledApplications(PackageManager.GET_META_DATA);

for (ApplicationInfo packageInfo : packages) {
    Log.d(TAG, "Installed package :" + packageInfo.packageName);
    Log.d(TAG, "Source dir : " + packageInfo.sourceDir);
    Log.d(TAG, "Launch Activity :" + pm.getLaunchIntentForPackage(packageInfo.packageName)); 
}
// the getLaunchIntentForPackage returns an intent that you can use with startActivity() 

Więcej informacji tutaj http://qtcstation.com/2011/02/how-to-launch-another-app-from-your-app/

Nelson Ramirez
źródło
Działa gr8. Ale kiedy wypróbowałem to na Androidzie 4.0.3, nic nie jest drukowane !! Wszelkie wskazówki?
Saurabh Verma
Upewnij się, że nie odfiltrowujesz instrukcji dziennika debugowania.
QED,
Ten kod działa jednak, czy masz pomysł, jak umieścić tę listę aplikacji w ListView?
androidBoomer
@androidBoomer robię to samo. przeczytaj to tutaj - vogella.com/tutorials/AndroidListView/article.html
David T.
@DavidT. Już to rozgryzłem. Teraz pracuję nad tym, jak uzyskać dostęp do tych zainstalowanych aplikacji, aby utworzyć skrót w mojej aplikacji. Czy to jest możliwe?
androidBoomer
61

Inny sposób filtrowania aplikacji systemowych (działa na przykładzie king9981):

/**
 * Return whether the given PackageInfo represents a system package or not.
 * User-installed packages (Market or otherwise) should not be denoted as
 * system packages.
 * 
 * @param pkgInfo
 * @return
 */
private boolean isSystemPackage(PackageInfo pkgInfo) {
    return ((pkgInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0);
}
Kenneth Evans
źródło
4
To najlepsza odpowiedź na odfiltrowanie aplikacji systemowych.
Bjorn
5
Ale nie filtruję aplikacji, takich jak ustawienia, mapy lub ..., jak je też wymienić
Ata
7
Część „? True: false” Twojego zwrotu jest zbędna
k2col
uprościć powrót ((pkgInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)! = 0);
Bhavesh Rangani,
jak filtrować płatne aplikacje?
Pemba Tamang
55

Oto dobry przykład:

class PInfo {
    private String appname = "";
    private String pname = "";
    private String versionName = "";
    private int versionCode = 0;
    private Drawable icon;
    private void prettyPrint() {
        Log.v(appname + "\t" + pname + "\t" + versionName + "\t" + versionCode);
    }
}

private ArrayList<PInfo> getPackages() {
    ArrayList<PInfo> apps = getInstalledApps(false); /* false = no system packages */
    final int max = apps.size();
    for (int i=0; i<max; i++) {
        apps.get(i).prettyPrint();
    }
    return apps;
}

private ArrayList<PInfo> getInstalledApps(boolean getSysPackages) {
    ArrayList<PInfo> res = new ArrayList<PInfo>();        
    List<PackageInfo> packs = getPackageManager().getInstalledPackages(0);
    for(int i=0;i<packs.size();i++) {
        PackageInfo p = packs.get(i);
        if ((!getSysPackages) && (p.versionName == null)) {
            continue ;
        }
        PInfo newInfo = new PInfo();
        newInfo.appname = p.applicationInfo.loadLabel(getPackageManager()).toString();
        newInfo.pname = p.packageName;
        newInfo.versionName = p.versionName;
        newInfo.versionCode = p.versionCode;
        newInfo.icon = p.applicationInfo.loadIcon(getPackageManager());
        res.add(newInfo);
    }
    return res; 
}
king9981
źródło
1
Jak wykonać jedną z nich, jeśli zajdzie taka potrzeba? Mam na myśli, czy możesz dostać zamiar?
Ton
Świetny. Dzięki za odpowiedź. Użyłem twojej odpowiedzi w mojej aplikacji i mam mały problem z rozmiarem ikony. większość z nich jest normalna, a niektóre są bardzo duże lub małe. Jak mogę to naprawić? Masz jakiś pomysł? dzięki
Meysam Valueian
36

Pobieranie listy zainstalowanych aplikacji niesystemowych

public static void installedApps()
{
    List<PackageInfo> packList = getPackageManager().getInstalledPackages(0);
    for (int i=0; i < packList.size(); i++)
    {
        PackageInfo packInfo = packList.get(i);
        if (  (packInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0)
        {
            String appName = packInfo.applicationInfo.loadLabel(getPackageManager()).toString();
            Log.e("App № " + Integer.toString(i), appName);
        }
    }
}
XXX
źródło
19

Aby filtrować aplikacje oparte na systemie:

private boolean isSystemPackage(ResolveInfo ri) {
    return (ri.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
}
SamCsharpAs3
źródło
18

Aby pobrać wszystkie zainstalowane aplikacje, możesz użyć Menedżera pakietów.

    List<PackageInfo> apps = getPackageManager().getInstalledPackages(0);

Aby uruchomić, możesz użyć nazwy pakietu

Intent launchApp = getPackageManager().getLaunchIntentForPackage(“package name”)
startActivity(launchApp);

Aby uzyskać więcej informacji, możesz przeczytać ten blog http://codebucket.co.in/android-get-list-of-all-installed-apps/

Arvind
źródło
To jest bardziej do rzeczy. Możemy ustawić odpowiednią kontrolę, sprawdzając naszą wymaganą aplikację.
Noman
13

Listę zainstalowanych aplikacji można znaleźć na urządzeniu z Androidem, używając poniższego kodu „packageInfo” Zawiera informacje o zainstalowanej aplikacji w urządzeniu. możemy pobrać Intent dla aplikacji zainstalowanej z obiektu packageinfo i używając startactivity (intent), możemy uruchomić aplikację. od Ciebie zależy, jak zorganizujesz interfejs użytkownika w widoku listy lub widoku siatki. więc po zdarzeniu kliknięcia na podstawie pozycji można pobrać obiekt docelowy i rozpocząć cel działania.

final PackageManager pm = getPackageManager();

List<ApplicationInfo> packages = pm.getInstalledApplications(PackageManager.GET_META_DATA);


for (ApplicationInfo packageInfo : packages) 

{
 if(pm.getLaunchIntentForPackage(packageInfo.packageName)!= null &&   

                   !pm.getLaunchIntentForPackage(packageInfo.packageName).equals(""))


{

    System.out.println("Package Name :" + packageInfo.packageName);

    System.out.println("Launch Intent For Package :"   +  
                  pm.getLaunchIntentForPackage(packageInfo.packageName));

    System.out.println("Application Label :"   + pm.getApplicationLabel(packageInfo));

    System.out.println("Application Label :"   + 
                           pm.getApplicationIcon(packageInfo.packageName).toString());

    System.out.println("i : "+i);

    /*if(i==2)

    {
         startActivity(pm.getLaunchIntentForPackage(packageInfo.packageName));

     break;

    }*/

    i++;

}
}
Prashant Agrawal
źródło
13

Miałem obowiązek odfiltrować aplikacje systemowe, których użytkownik tak naprawdę nie używa (np. „Com.qualcomm.service”, „usługi aktualizacji” itp.). Ostatecznie dodałem kolejny warunek, aby odfiltrować listę aplikacji. Właśnie sprawdziłem, czy aplikacja ma „cel uruchamiania”.

Tak więc wynikowy kod wygląda jak ...

PackageManager pm = getPackageManager();
        List<ApplicationInfo> apps = pm.getInstalledApplications(PackageManager.GET_GIDS);

        for (ApplicationInfo app : apps) {
            if(pm.getLaunchIntentForPackage(app.packageName) != null) {
                // apps with launcher intent
                if((app.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
                    // updated system apps

                } else if ((app.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
                    // system apps

                } else {
                    // user installed apps

                }
                appsList.add(app);
            }

        }
joecizac
źródło
Dzięki. GetLaunchIntentForPackage jest bardzo przydatny, aby aplikacje były obecne w szufladzie aplikacji :-)
Gabriel Hautclocq
10

Jeśli w jednym pakiecie znajduje się wiele programów uruchamiających, kod ma problem. Np .: na LG Optimus Facebook dla LG, MySpace dla LG, Twitter dla LG zawiera w jednym pakiecie nazwę SNS i jeśli użyjesz powyższego SNS, to się powtórzy. Po wielu godzinach badań przyszedłem z poniższym kodem. Wydaje się działać dobrze.

private List<String> getInstalledComponentList()
            throws NameNotFoundException {
        final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
        mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
        List<ResolveInfo> ril = getPackageManager().queryIntentActivities(mainIntent, 0);
        List<String> componentList = new ArrayList<String>();
        String name = null;

        for (ResolveInfo ri : ril) {
            if (ri.activityInfo != null) {
                Resources res = getPackageManager().getResourcesForApplication(ri.activityInfo.applicationInfo);
                if (ri.activityInfo.labelRes != 0) {
                    name = res.getString(ri.activityInfo.labelRes);
                } else {
                    name = ri.activityInfo.applicationInfo.loadLabel(
                            getPackageManager()).toString();
                }
                componentList.add(name);
            }
        }
        return componentList;
    }
kakopappa
źródło
7

@Jas: Nie mam już tego kodu, ale znalazłem coś blisko. Zrobiłem to, aby wyszukać „komponenty” mojej aplikacji, są to tylko czynności z określoną kategorią.

private List<String> getInstalledComponentList() {
    Intent componentSearchIntent = new Intent();
    componentSearchIntent.addCategory(Constants.COMPONENTS_INTENT_CATEGORY);
    componentSearchIntent.setAction(Constants.COMPONENTS_INTENT_ACTION_DEFAULT);
    List<ResolveInfo> ril = getPackageManager().queryIntentActivities(componentSearchIntent, PackageManager.MATCH_DEFAULT_ONLY);
    List<String> componentList = new ArrayList<String>();
    Log.d(LOG_TAG, "Search for installed components found " + ril.size() + " matches.");
    for (ResolveInfo ri : ril) {
        if (ri.activityInfo != null) {
            componentList.add(ri.activityInfo.packageName);// + ri.activityInfo.name);
            Log.d(LOG_TAG, "Found installed: " + componentList.get(componentList.size()-1));
        }
    }
    return componentList;
}

Skomentowałem część, od której pochodzi nazwa działania, ale jest to dość proste.

Spidey
źródło
6

Czyste rozwiązanie, które skutecznie odfiltrowuje aplikacje systemowe

Ideą tego rozwiązania jest to, że główna aktywność każdej aplikacji systemowej nie ma niestandardowej ikony aktywności . Ta metoda daje mi doskonały wynik:

 public static Set<PackageInfo> getInstalledApps(Context ctx) {
    final PackageManager packageManager = ctx.getPackageManager();

    final List<PackageInfo> allInstalledPackages = packageManager.getInstalledPackages(PackageManager.GET_META_DATA);
    final Set<PackageInfo> filteredPackages = new HashSet();

    Drawable defaultActivityIcon = packageManager.getDefaultActivityIcon();

    for(PackageInfo each : allInstalledPackages) {
        if(ctx.getPackageName().equals(each.packageName)) {
            continue;  // skip own app
        }

        try {
            // add only apps with application icon
            Intent intentOfStartActivity = packageManager.getLaunchIntentForPackage(each.packageName);
            if(intentOfStartActivity == null)
                continue;

            Drawable applicationIcon = packageManager.getActivityIcon(intentOfStartActivity);
            if(applicationIcon != null && !defaultActivityIcon.equals(applicationIcon)) {
                filteredPackages.add(each);
            }
        } catch (PackageManager.NameNotFoundException e) {
            Log.i("MyTag", "Unknown package name " + each.packageName);
        }
    }

    return filteredPackages;
}
funcoder
źródło
3
private static boolean isThisASystemPackage(Context context, PackageInfo  packageInfo ) {
        try {
            PackageInfo sys = context.getPackageManager().getPackageInfo("android", PackageManager.GET_SIGNATURES);
            return (packageInfo != null && packageInfo.signatures != null &&
                    sys.signatures[0].equals(packageInfo.signatures[0]));
        } catch (NameNotFoundException e) {
            return false;
        }
    }
użytkownik1546570
źródło
2

Mam inne rozwiązanie:

ArrayList<AppInfo> myAppsToUpdate;

    // How to get the system and the user apps.
    public ArrayList<AppInfo> getAppsToUpdate() {

        PackageManager pm = App.getContext().getPackageManager();
        List<ApplicationInfo> installedApps = pm.getInstalledApplications(0);
        myAppsToUpdate = new ArrayList<AppInfo>();
        for (ApplicationInfo aInfo : installedApps) {

            if ((aInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
                // System apps 
            } else {
                // Users apps
                AppInfo appInfo = new AppInfo();
                appInfo.setAppName(aInfo.loadLabel(pm).toString());
                appInfo.setPackageName(aInfo.packageName);
                appInfo.setLaunchActivity(pm.getLaunchIntentForPackage(aInfo.packageName).toString());
                try {
                    PackageInfo info = pm.getPackageInfo(aInfo.packageName, 0);
                    appInfo.setVersionName(info.versionName.toString());
                    appInfo.setVersionCode("" + info.versionCode);
                    myAppsToUpdate.add(appInfo);
                } catch (NameNotFoundException e) {
                    Log.e("ERROR", "we could not get the user's apps");
                }

            }
        }
        return myAppsToUpdate;
    }
Victor Ruiz.
źródło
2

Pobierz wszystkie aplikacje:

    PackageManager pm = getContext().getPackageManager();
    List<ApplicationInfo> apps = pm.getInstalledApplications(0);

Sprawdź, czy zainstalowana aplikacja, a następnie otwórz:

if((app.flags & (ApplicationInfo.FLAG_UPDATED_SYSTEM_APP | ApplicationInfo.FLAG_SYSTEM)) > 0) {
                String app_package = app.packageName;
Intent launchIntent = context.getPackageManager().getLaunchIntentForPackage(app_package);
context.startActivity(launchIntent);
Chandra Agarwala
źródło
0

możesz użyć tego:

PackageManager pm = getApplicationContext().getPackageManager();
                List<ResolveInfo> activityList = pm.queryIntentActivities(shareIntent, 0);
                for (final ResolveInfo app : activityList) 
                {
                   if ((app.activityInfo.name).contains("facebook")) 
                   {
                     // facebook  
                   }

                   if ((app.activityInfo.name).contains("android.gm")) 
                   {
                     // gmail  
                   }

                   if ((app.activityInfo.name).contains("mms")) 
                   {
                     // android messaging app
                   }

                   if ((app.activityInfo.name).contains("com.android.bluetooth")) 
                   {
                     // android bluetooth  
                   }
                }
Akshay Paliwal
źródło
0
public static List<ApplicationInfo> getApplications(Context context) {
    return context.getPackageManager().getInstalledApplications(PackageManager.GET_META_DATA);
}
Reza
źródło