Vérifier si l'application est installée - Android


104

J'essaye d'installer des applications depuis Google Play. Je peux comprendre qu'en ouvrant l'URL de la boutique Google Play, cela ouvre Google Play et lorsque j'appuie sur le bouton de retour, l'activité reprend.

Intent marketIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(appURL));
marketIntent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY | Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
startActivity(marketIntent);

Quand je suis retourné à l'activité, j'ai essayé d'appeler ceci onResume()pour vérifier si l'application est installée, mais je reçois une erreur:

@Override
protected void onResume() {
    super.onResume();
    boolean installed = false;
    while (!installed) {
        installed  =   appInstalledOrNot(APPPACKAGE);
        if (installed) {
             Toast.makeText(this, "App installed", Toast.LENGTH_SHORT).show();
        }
    }
}

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

L'erreur est la suivante:

E / AndroidRuntime (796): java.lang.RuntimeException: Impossible de démarrer l'activité ComponentInfo {com.example.appinstaller / com.example.appinstaller.MainActivity}: android.content.ActivityNotFoundException: Aucune activité trouvée pour gérer l'intention {act = android .intent.action.VIEW dat = market: // détails? id = com.package.name flg = 0x40080000}

Je suppose que l'activité est onPause(). Y a-t-il une meilleure façon de le mettre en œuvre? J'essaie de vérifier si l'application a terminé l'installation.



@SiddharthanAsokan Si je comprends bien, ce que vous essayez de réaliser ici est de démarrer votre application -> allez sur Play Store-> cliquez sur installer -> revenez à votre propre activité -> lancez l'application nouvellement installée .. est-ce vrai?
Varun le

Non, revenez à l'application que j'ai ouverte initialement. Je dois obtenir des informations sur l'application installée à l'aide de PackageManager. Cette récupération d'informations commence après avoir installé l'application à partir de l'initiale qui a utilisé l'URL Web.
Siddharthan Asokan du

Réponses:


300

Essaye ça:

private boolean isPackageInstalled(String packageName, PackageManager packageManager) {
    try {
        packageManager.getPackageInfo(packageName, 0);
        return true;
    } catch (PackageManager.NameNotFoundException e) {
        return false;
    }
}

Il tente de récupérer des informations sur le paquet dont vous avez transmis le nom. À défaut, si un a NameNotFoundExceptionété lancé, cela signifie qu'aucun paquet avec ce nom n'est installé, nous retournons donc false.

Notez que nous passons dans a PackageManagerau lieu de a Context, de sorte que la méthode soit légèrement plus flexible et ne viole pas la loi de Demeter . Vous pouvez utiliser la méthode sans accéder à une Contextinstance, tant que vous en avez une PackageManager.

Utilisez-le comme ceci:

public void someMethod() {
    // ...

    PackageManager pm = context.getPackageManager();
    boolean isInstalled = isPackageInstalled("com.somepackage.name", pm);

    // ...
}

1
La condition est la suivante: je dois vérifier ce processus d'installation si c'est fait. Je clique sur installer et en attendant j'essaye de vérifier l'installation en boucle. Le code est correct mais la méthode pour vérifier si l'installation est terminée est ce que je recherche.
Siddharthan Asokan

3
@SiddharthanAsokan Vous pouvez utiliser un récepteur de diffusion pour l'action package_added.
Varun

@Varun Je viens de modifier le code. Ce n'est plus le nom du package d'application que j'utilise. Juste l'url Web de l'application dans le Google Play Store
Siddharthan Asokan

@Robin Kanters Veuillez consulter les modifications que j'ai apportées
Siddharthan Asokan

Ce que vous avez fait dans votre question est la même que ma réponse.
Robin Kanters

33

La réponse de Robin Kanters est juste, mais elle vérifie les applications installées quel que soit leur état activé ou désactivé.

Nous savons tous qu'une application peut être installée mais désactivée par l'utilisateur, donc inutilisable.

Cela vérifie 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;
    }
}

Vous pouvez mettre cette méthode dans une classe comme Utilset l'appeler partout en utilisant:

boolean isInstalled = Utils.isPackageInstalled("com.package.name", context.getPackageManager())

5

Essaye ça:

public static boolean isAvailable(Context ctx, Intent intent) {
final PackageManager mgr = ctx.getPackageManager();
List<ResolveInfo> list =   mgr.queryIntentActivities(intent,PackageManager.MATCH_DEFAULT_ONLY);
return list.size() > 0;
}

5

Solution plus rapide:

private boolean isPackageInstalled(String packagename, PackageManager packageManager) {
    try {
        packageManager.getPackageGids(packagename);
        return true;
    } catch (NameNotFoundException e) {
        return false;
    }
}

getPackageGidsest moins cher getPackageInfo, donc ça marche plus vite.

Run 10000 on API 15
Exists pkg:
getPackageInfo: nanoTime = 930000000
getPackageGids: nanoTime = 350000000
Not exists pkg:
getPackageInfo: nanoTime = 420000000
getPackageGids: nanoTime = 380000000

Run 10000 on API 17
Exists pkg:
getPackageInfo: nanoTime = 2942745517
getPackageGids: nanoTime = 2443716170
Not exists pkg:
getPackageInfo: nanoTime = 2467565849
getPackageGids: nanoTime = 2479833890

Run 10000 on API 22
Exists pkg:
getPackageInfo: nanoTime = 4596551615
getPackageGids: nanoTime = 1864970154
Not exists pkg:
getPackageInfo: nanoTime = 3830033616
getPackageGids: nanoTime = 3789230769

Run 10000 on API 25
Exists pkg:
getPackageInfo: nanoTime = 3436647394
getPackageGids: nanoTime = 2876970397
Not exists pkg:
getPackageInfo: nanoTime = 3252946114
getPackageGids: nanoTime = 3117544269

Remarque: cela ne fonctionnera pas dans certains espaces virtuels. Ils peuvent violer l'API Android et toujours renvoyer un tableau, même s'il n'y a pas d'application avec ce nom de package.
Dans ce cas, utilisez getPackageInfo.


0
    private boolean isAppExist() {

    PackageManager pm = getPackageManager();
    try {
        PackageInfo info = pm.getPackageInfo("com.facebook.katana", PackageManager.GET_META_DATA);
    } catch (PackageManager.NameNotFoundException e) {
        return false;
    }
    return true;
}




if (isFacebookExist()) {showToast(" Facebook is  install.");}
     else {showToast(" Facebook is not install.");}

0
isFakeGPSInstalled = Utils.isPackageInstalled(Utils.PACKAGE_ID_FAKE_GPS, this.getPackageManager());

// méthode pour vérifier le package installé true / false

  public static boolean isPackageInstalled(String packageName, PackageManager packageManager) {
    boolean found = true;
    try {
      packageManager.getPackageInfo(packageName, 0);
    } catch (PackageManager.NameNotFoundException e) {
      found = false;
    }

    return found;
  }

0

Si vous voulez l'essayer sans le bloc try catch, vous pouvez utiliser la méthode suivante, créer un intent et définir le package de l'application que vous souhaitez vérifier

val intent = Intent(Intent.ACTION_VIEW)
intent.data = uri
intent.setPackage("com.example.packageofapp")

et appelez la méthode suivante pour vérifier si l'application est installée

fun isInstalled(intent:Intent) :Boolean{
    val list = context.packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY)
    return list.isNotEmpty()
}

0

Ceux qui recherchent une solution Kotlin peuvent utiliser cette méthode,

Ici, j'ai partagé le code complet et j'ai également géré le statut activé. Vérifiez si l'application est installée dans Android Kotlin

fun isAppInstalled(packageName: String, context: Context): Boolean {
        return try {
            val packageManager = context.packageManager
            packageManager.getPackageInfo(packageName, 0)
            true
        } catch (e: PackageManager.NameNotFoundException) {
            false
        }
    }

-9
@Override 
protected void onResume() {
    super.onResume();
    boolean installed = false;

    while (!installed) {
        installed = appInstalledOrNot (APPPACKAGE);
        if (installed) {
            Toast.makeText(this, "App installed", Toast.LENGTH_SHORT).show ();
        }
    }
} 

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

8
C'est une boucle infinie.
Robin Kanters
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.