Nous avons installé des applications par programmation.

1. Si l'application est déjà installée sur l'appareil, l'application s'ouvre automatiquement.
2. Sinon, installez l'application particulière.

Guidez-moi. Je n'ai aucune idée. Merci.

Essayez avec ceci:

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;
    }

}

Solution un peu plus propre que la réponse acceptée (basée sur cette question ):

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

J'ai choisi de le mettre dans une classe d'assistance en tant qu'utilitaire statique. Exemple d'utilisation:

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

Cette réponse montre comment obtenir l'application depuis le Play Store si l'application est manquante, bien que des précautions doivent être prises sur les appareils qui ne disposent pas du Play Store.

Le code ci-dessus n'a pas fonctionné pour moi. L'approche suivante a fonctionné.

Créez un objet Intent avec les informations appropriées, puis vérifiez si l'intent est appelable ou non à l'aide de la fonction suivante:

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

Si vous connaissez le nom du package, cela fonctionne sans utiliser de bloc try-catch ni itérer dans un tas de packages:

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();
}

Ce code vérifie que l'application est installée, mais vérifie également qu'elle est activée.

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;
    }
}

Je pense que l'utilisation du modèle try / catch n'est pas très bonne pour les performances. Je conseille d'utiliser ceci:

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;
}

Solution plus propre (sans try-catch) que la réponse acceptée (basée sur 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;
}

Vérifiez que l'application est installée ou non dans Android en utilisant kotlin.

Création de l'extension kotlin.

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

Maintenant, peut vérifier si l'application est installée ou non

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

Essaye ça

Ce code est utilisé pour vérifier si votre application avec le nom du package est installée ou non sinon il ouvrira le lien Playstore de votre application sinon votre application installée

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 );
    }

Une implémentation plus simple avec Kotlin

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

Et appelez-le comme ceci (à la recherche de l'application Spotify):

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

Réponse de @Egemen Hamutçu dans 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()
    }

Toutes les réponses vérifient uniquement que certaines applications sont installées ou non. Mais, comme nous le savons tous, une application peut être installée mais désactivée par l'utilisateur, inutilisable.

Par conséquent, cette solution vérifie les deux. c'est-à-dire, les applications installées ET activées .

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

Appelez la méthode isPackageInstalled():

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

Maintenant, utilisez la variable booléenne isAppInstalledet faites ce que vous voulez.

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

Une bonne réponse à d'autres problèmes. Si vous ne voulez pas différencier "com.myapp.debug" et "com.myapp.release" par exemple!

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;
}

Tellement mieux avec Kotlin Suger:

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

    val packageManager = context.packageManager

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