Android must know-Use Intent to open third-party applications and verify availability

This article mainly records:

• Three ways to use Intent to open third-party applications or specify Activities
• How to determine whether the Intent can be parsed when using the above three methods
• Possible omissions in determining whether the Intent can be parsed

Basics

1. App entry Activity and its icon

[[202293]]

A normal application will have an entry Activity by default, which is usually written in AndroidManifest.xml as follows:

 <application>
    <activity android: name = ".MainActivity" >
 <intent-filter>
            < action android: name = "android.intent.action.MAIN" /> 
 
            <category android: name = "android.intent.category.LAUNCHER" />
 </intent-filter>
 </activity>
 ...
 </application>

Only when such an Activity is configured, the application will know which Activity to start when it is clicked. If the value of category is changed to android.intent.category.DEFAULT, then the icon of this application will not be visible on the desktop and it cannot be opened directly.

How to use Intent to open a third-party application or specify an Activity

1. Only know the package name - need to have a default entry Activity
2. Start the Activity of a specified third-party application - the package name and Activity name are required, and the Activity's Export="true"
3. Implicitly launch third-party applications

1. Use PackageManager.getLaunchIntentForPackage()

 String package_name= "xx.xx.xx" ;
 PackageManager packageManager = context.getPackageManager();
 Intent it = packageManager.getLaunchIntentForPackage(package_name);
 startActivity(it);

This method is used when you only know the package name and want to start the application. The biggest restriction on the application is that there is a default entry Activity.

When there is no default entry Activity, a NullPointerException will be reported:

 java.lang.NullPointerException: Attempt to invoke virtual method 'java.lang.String android.content.Intent.toString()'   on a null object reference

Let’s take a look at the description of the getLaunchIntentForPackage() method:

 /**
     * Returns a "good" intent to launch a front-door activity in a package.
     * This is used, for example, to implement an "open" button when browsing
     * through packages. The current implementation looks first   for a main
     * activity in the category {@link Intent#CATEGORY_INFO}, and   next   for a
     * main activity in the category {@link Intent#CATEGORY_LAUNCHER}. Returns  
     * <code> null </code> if neither are found.
 *
     * @param packageName The name   of the package to inspect.
 *
     * @ return A fully-qualified {@link Intent} that can be used to launch the
     * main activity in the package. Returns <code> null </code> if the package
     * does not contain such an activity, or if <em>packageName</em> is   not  
 * recognized.
 */
 public abstract Intent getLaunchIntentForPackage(String packageName);

public abstract Intent getLaunchIntentForPackage(String packageName);

So you can use this method to determine whether the Intent is empty.

 String package_name = "xx.xx.xx" ;
 PackageManager packageManager = getPackageManager();
 Intent it = packageManager.getLaunchIntentForPackage(package_name);
 if (it != null ){
 startActivity(it);
 } else {
 //There is no default entry Activity
 }

2. Use Intent.setComponent()

 String package_name = "xx.xx.xx" ;
 String activity_path = "xx.xx.xx.ab.xxActivity" ;
 Intent intent = new Intent();
 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);//optional
 ComponentName comp = new ComponentName(package_name,activity_path);
 intent.setComponent(comp);
 startActivity(intent);

This method can start an application-specified Activity, not limited to the default entry Activity. However, this method requires many conditions, as follows:

Know the package name of the App and the full path and name of the Activity

1. The target Activity to be started has the attribute Export="true" in AndroidManifest.xml
2. In this way, how to determine whether the target Activity exists?

The following is a very common usage circulating on the Internet:

 String package_name = "xx.xx.xx" ;
 String activity_path = "xx.xx.xx.ab.xxActivity" ;
 Intent intent = new Intent();
 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);//optional
 ComponentName cn = new ComponentName(package_name,activity_path);
 intent.setComponent(cn); 
 
 if (intent.resolveActivity(getPackageManager()) != null ) {
 startActivity(intent);
 } else {
 //The specified Activity cannot be found
 }

Unfortunately, the Intent.resolveActivity() method cannot determine whether the Activity to be started in this way exists. If this Activity does not exist, a java.lang.IllegalArgumentException: Unknown component exception will be reported, causing the program to crash.

Let's look at the code for resolveActivity() and its similar method resolveActivityInfo():

 public ComponentName resolveActivity(PackageManager pm) {
    if (mComponent != null ) {
 return mComponent;
 } 
 
    ResolveInfo info = pm.resolveActivity(this,
        PackageManager.MATCH_DEFAULT_ONLY);
 if (info != null ) {
 return new ComponentName(
            info.activityInfo.applicationInfo.packageName,
            info.activityInfo. name );
 } 
 
 return   null ;
 } 
 
 public ActivityInfo resolveActivityInfo(PackageManager pm, int flags) {
 ActivityInfo ai = null ;
    if (mComponent != null ) {
 try {
            ai = pm.getActivityInfo(mComponent, flags);
        } catch (PackageManager.NameNotFoundException e) {
 // ignore  
 }
 } else {
        ResolveInfo info = pm.resolveActivity(this,
            PackageManager.MATCH_DEFAULT_ONLY | flags);
 if (info != null ) {
            ai = info.activityInfo;
 }
 } 
 
 return ai;
 }

Obviously, in this method, we set the ComponentName first, so mComponent will be returned directly to us without any judgment logic. In contrast, resolveActivityInfo() can make effective judgments and return null. Therefore, we choose to use Intent.resolveActivityInfo() to make judgments in this way:

 String package_name = "xx.xx.xx" ;
 String activity_path = "xx.xx.xx.ab.xxActivity" ;
 Intent intent = new Intent();
 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);//optional
 ComponentName cn = new ComponentName(package_name,activity_path);
 intent.setComponent(cn); 
 
 if (intent.resolveActivityInfo(getPackageManager(), PackageManager.MATCH_DEFAULT_ONLY) != null ) {
 startActivity(intent);
 } else {
 //The specified Activity cannot be found
 }

3. Implicitly launch third-party applications

This method is mostly used to start functional applications in the system, such as making calls, sending emails, previewing pictures, opening a web page using the default browser, etc.

 > Intent intent = new Intent();
 > intent.setAction( action );
 > intent.addCategory(category);
 > intent.setDataAndType( "abc://www.dfg.com" , "image/gif" );
 > startActivity(intent);
 >

• Condition 1: IntentFilter has at least one action and at least one Category, but may not have Data and Type
• Condition 2: If there is data, the data in the parameter must comply with the data rules
• Condition 3: Action and Category must match an Action and a Category in the Activity (Category default: android.intent.category.DEFAULT)

There are many implicit startup functions, so I won’t list them all. You can directly search for relevant codes when needed. Let’s take opening a web page as an example:

 Uri uri = Uri.parse( "http://www.abc.xyz" );
 Intent intent = new Intent(Intent.ACTION_VIEW, uri);
 startActivity(intent);

At this point, there is nothing wrong with using the Intent.resolveActivity() method directly:

 Uri uri = Uri.parse( "http://www.abc.xyz" );
 Intent intent = new Intent(Intent.ACTION_VIEW, uri); 
 
 if (intent.resolveActivity(getPackageManager()) != null ) {
 startActivity(intent);
 } else {
 // The required application is not installed
 }

Summarize

After reading the PackageManager code, I found that you can also use the packageManager.queryIntentActivities() method to determine whether there is an application in the system that can parse the specified Intent.

 public boolean isAvailable(Context context, Intent intent) {
    PackageManager packageManager = context.getPackageManager();
    List list = packageManager.queryIntentActivities(intent,
    PackageManager.MATCH_DEFAULT_ONLY);
 return list.size () > 0 ;
 }

So, to sum up:

• Method 1: PackageManager.getLaunchIntentForPackage(), directly determine whether the returned Intent is empty;
• Method 2: Intent.setComponent(), use Intent.resolveActivityInfo() or packageManager.queryIntentActivities();
• Method 3: Implicit start, using Intent.resolveActivity(), Intent.resolveActivityInfo(), packageManager.queryIntentActivities().