Zainstalowaliśmy aplikacje programowo.

1. Jeśli aplikacja jest już zainstalowana w urządzeniu, jest ona otwierana automatycznie.
2. W przeciwnym razie zainstaluj konkretną aplikację.

Prowadź mnie. Nie mam pojęcia. Dzięki.

Spróbuj z tym:

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

}

Nieco czystsze rozwiązanie niż przyjęta odpowiedź (na podstawie tego pytania ):

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

Zdecydowałem się umieścić go w klasie pomocniczej jako statyczne narzędzie. Przykład użycia:

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

Ta odpowiedź pokazuje, jak pobrać aplikację ze Sklepu Play, jeśli brakuje aplikacji, ale należy zachować ostrożność na urządzeniach, które nie mają Sklepu Play.

Powyższy kod nie działa dla mnie. Następujące podejście zadziałało.

Utwórz obiekt intencji z odpowiednimi informacjami, a następnie sprawdź, czy intencja jest wywoływalna, czy nie, używając następującej funkcji:

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

Jeśli znasz nazwę pakietu, działa to bez użycia bloku try-catch lub iteracji przez kilka pakietów:

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

Ten kod sprawdza, czy aplikacja jest zainstalowana, ale także sprawdza, czy jest włączona.

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

Myślę, że użycie wzorca try / catch nie jest dobre dla wydajności. Radzę skorzystać z tego:

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

Czystsze rozwiązanie (bez try-catch) niż akceptowana odpowiedź (oparta na bibliotece AndroidRate ):

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

Sprawdź, czy aplikacja jest zainstalowana lub nie w systemie Android za pomocą kotlin.

Tworzenie rozszerzenia kotlin.

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

Teraz możesz sprawdzić, czy aplikacja jest zainstalowana, czy nie

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

Spróbuj tego

Ten kod służy do sprawdzania, czy aplikacja z nazwą pakietu jest zainstalowana lub nie, jeśli nie, otworzy link do sklepu playstore Twojej aplikacji, w przeciwnym razie zainstalowana aplikacja

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

Prostsza implementacja za pomocą Kotlina

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

I nazwij to tak (szukając aplikacji Spotify):

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

@Egemen Hamutçu s odpowiedź w 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()
    }

Wszystkie odpowiedzi tylko sprawdzają, czy dana aplikacja jest zainstalowana, czy nie. Ale, jak wszyscy wiemy, aplikacja może być zainstalowana, ale wyłączona przez użytkownika, bezużyteczna.

Dlatego to rozwiązanie sprawdza oba. tj. zainstalowane i włączone aplikacje .

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

Wywołaj metodę isPackageInstalled():

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

Teraz użyj zmiennej boolowskiej isAppInstalledi rób, co chcesz.

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

Fajna odpowiedź na inne problemy. Jeśli nie chcesz na przykład rozróżniać „com.myapp.debug” i „com.myapp.release”!

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

Tak ładniej z Kotlin suger:

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

    val packageManager = context.packageManager

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