Wir haben Anwendungen programmgesteuert installiert.

1. Wenn die Anwendung bereits auf dem Gerät installiert ist, wird die Anwendung automatisch geöffnet.
2. Andernfalls installieren Sie die jeweilige Anwendung.

Führe mich. Ich habe keine Ahnung. Vielen Dank.

Versuchen Sie es damit:

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Add respective layout
        setContentView(R.layout.main_activity);

        // Use package name which we want to check
        boolean isAppInstalled = appInstalledOrNot("com.check.application");  

        if(isAppInstalled) {
            //This intent will help you to launch if the package is already installed
            Intent LaunchIntent = getPackageManager()
                .getLaunchIntentForPackage("com.check.application");
            startActivity(LaunchIntent);

            Log.i("Application is already installed.");       
        } else {
            // Do whatever we want to do if application not installed
            // For example, Redirect to play store

            Log.i("Application is not currently installed.");
        }
    }

    private boolean appInstalledOrNot(String uri) {
        PackageManager pm = getPackageManager();
        try {
            pm.getPackageInfo(uri, PackageManager.GET_ACTIVITIES);
            return true;
        } catch (PackageManager.NameNotFoundException e) {
        }

        return false;
    }

}

Etwas sauberere Lösung als die akzeptierte Antwort (basierend auf dieser Frage ):

public static boolean isAppInstalled(Context context, String packageName) {
    try {
        context.getPackageManager().getApplicationInfo(packageName, 0);
        return true;
    }
    catch (PackageManager.NameNotFoundException e) {
        return false;
    }
}

Ich habe es als statisches Dienstprogramm in eine Hilfsklasse eingeordnet. Anwendungsbeispiel:

boolean whatsappFound = AndroidUtils.isAppInstalled(context, "com.whatsapp");

Diese Antwort zeigt, wie Sie die App aus dem Play Store erhalten, wenn die App fehlt. Bei Geräten ohne Play Store ist jedoch Vorsicht geboten.

Der obige Code hat bei mir nicht funktioniert. Der folgende Ansatz hat funktioniert.

Erstellen Sie ein Intent-Objekt mit den entsprechenden Informationen und überprüfen Sie mithilfe der folgenden Funktion, ob das Intent aufrufbar ist oder nicht:

private boolean isCallable(Intent intent) {  
        List<ResolveInfo> list = getPackageManager().queryIntentActivities(intent,   
        PackageManager.MATCH_DEFAULT_ONLY);  
        return list.size() > 0;  
}

Wenn Sie den Paketnamen kennen, funktioniert dies, ohne einen Try-Catch-Block zu verwenden oder eine Reihe von Paketen zu durchlaufen:

public static boolean isPackageInstalled(Context context, String packageName) {
    final PackageManager packageManager = context.getPackageManager();
    Intent intent = packageManager.getLaunchIntentForPackage(packageName);
    if (intent == null) {
        return false;
    }
    List<ResolveInfo> list = packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
    return !list.isEmpty();
}

Dieser Code überprüft, ob die App installiert ist, überprüft aber auch, ob sie aktiviert ist.

private boolean isAppInstalled(String packageName) {
    PackageManager pm = getPackageManager();
    try {
        pm.getPackageInfo(packageName, PackageManager.GET_ACTIVITIES);
        return pm.getApplicationInfo(packageName, 0).enabled;
    }
    catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
        return false;
    }
}

Ich denke, die Verwendung von Try / Catch-Mustern ist für die Leistung nicht sehr gut. Ich rate dazu:

public static boolean appInstalledOrNot(Context context, String uri) {
    PackageManager pm = context.getPackageManager();
    List<PackageInfo> packageInfoList = pm.getInstalledPackages(PackageManager.GET_ACTIVITIES);
    if (packageInfoList != null) {
        for (PackageInfo packageInfo : packageInfoList) {
            String packageName = packageInfo.packageName;
            if (packageName != null && packageName.equals(uri)) {
                return true;
            }
        }
    }
    return false;
}

Sauberere Lösung (ohne Try-Catch) als die akzeptierte Antwort (basierend auf der AndroidRate Library ):

public static boolean isPackageExists(@NonNull final Context context, @NonNull final String targetPackage) {
    List<ApplicationInfo> packages = context.getPackageManager().getInstalledApplications(0);
    for (ApplicationInfo packageInfo : packages) {
        if (targetPackage.equals(packageInfo.packageName)) {
            return true;
        }
    }
    return false;
}

Überprüfen Sie, ob die App in Android mithilfe von Kotlin installiert ist oder nicht.

Kotlin-Erweiterung erstellen.

fun PackageManager.isAppInstalled(packageName: String): Boolean = try {
        getApplicationInfo(packageName, PackageManager.GET_META_DATA)
        true
    } catch (e: Exception) {
        false
    }

Jetzt können Sie überprüfen, ob die App installiert ist oder nicht

if (packageManager.isAppInstalled("AppPackageName")) {
    // App is installed
}else{
    // App is not installed
}

Versuche dies

Dieser Code wird verwendet, um zu überprüfen, ob Ihre Anwendung mit dem Paketnamen installiert ist oder nicht. Andernfalls wird der Playstore-Link Ihrer App geöffnet, andernfalls wird Ihre App installiert

String your_apppackagename="com.app.testing";
    PackageManager packageManager = getPackageManager();
    ApplicationInfo applicationInfo = null;
    try {
        applicationInfo = packageManager.getApplicationInfo(your_apppackagename, 0);
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
    if (applicationInfo == null) {
        // not installed it will open your app directly on playstore
        startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://play.google.com/store/apps/details?id=" + your_apppackagename)));
    } else {
        // Installed
        Intent LaunchIntent = packageManager.getLaunchIntentForPackage(your_apppackagename);
        startActivity( LaunchIntent );
    }

Eine einfachere Implementierung mit Kotlin

fun PackageManager.isAppInstalled(packageName: String): Boolean =
        getInstalledApplications(PackageManager.GET_META_DATA)
                .firstOrNull { it.packageName == packageName } != null

Und nennen Sie es so (auf der Suche nach Spotify-App):

packageManager.isAppInstalled("com.spotify.music")

@Egemen Hamutçus Antwort in Kotlin B-)

    private fun isAppInstalled(context: Context, uri: String): Boolean {
        val packageInfoList = context.packageManager.getInstalledPackages(PackageManager.GET_ACTIVITIES)
        return packageInfoList.asSequence().filter { it?.packageName == uri }.any()
    }

Alle Antworten überprüfen nur, ob eine bestimmte App installiert ist oder nicht. Wie wir alle wissen, kann eine App installiert, aber vom Benutzer deaktiviert und unbrauchbar gemacht werden.

Daher prüft diese Lösung beide. dh installierte UND aktivierte Apps .

public static boolean isPackageInstalled(String packageName, PackageManager packageManager) {
     try {
          return packageManager.getApplicationInfo(packageName, 0).enabled;
     }
     catch (PackageManager.NameNotFoundException e) {
          return false;
     }
}

Rufen Sie die Methode auf isPackageInstalled():

boolean isAppInstalled = isPackageInstalled("com.android.app" , this.getPackageManager());

Verwenden isAppInstalledSie jetzt die boolesche Variable und machen Sie, was Sie wollen.

if(isAppInstalled ) {
    /* do whatever you want */
}

Eine coole Antwort auf andere Probleme. Wenn Sie beispielsweise nicht zwischen "com.myapp.debug" und "com.myapp.release" unterscheiden möchten!

public static boolean isAppInstalled(final Context context, final String packageName) {
    final List<ApplicationInfo> appsInfo = context.getPackageManager().getInstalledApplications(0);
    for (final ApplicationInfo appInfo : appsInfo) {
        if (appInfo.packageName.contains(packageName)) return true;
    }
    return false;
}

So schön mit Kotlin Suger:

  private fun isSomePackageInstalled(context: Context, packageName: String): Boolean {

    val packageManager = context.packageManager

    return runCatching { packageManager.getPackageInfo(packageName, 0) }.isSuccess
  }