Sharing with Intents

One of the most powerful features of Android is the capability to use Intents to share content and trigger actions within and among applications. An excellent and concise introduction may be found in the post Share With Intents by Android Developer Advocate Lucas Alexander. There are two basic kinds of intents in Android:

1. Explicit intents


2. Implicit intents

(see the Intents and Intent Filters developer guide and Sending Content to Other Apps for an overview of their uses). Because of the properties that we now discuss, explicit intents find their primary use for communication between components of a single application, but the most interesting uses of implicit intents enable interoperability between different applications.

Explicit Intents

Explicit intents specify by name the class that is expected to handle it. We have encountered many examples of using explicit intents, most commonly to launch new activities. For example, the following event-handling code taken from the project WebView Demo uses explicit Intents to launch a new Activity (associated with the class Webscreen) with different possibilities for the data passed to the new Activity using the putExtra() method, with the code implementing the intents highlighted in red.

public void onClick(View v) {
	switch(v.getId()){

		case R.id.button1:
		Intent j = new Intent(this, Webscreen.class);
		j.putExtra(com.lightcone.webviewdemo.Webscreen.URL, 
		"http://eagle.phys.utk.edu/guidry/recipes/mojito.html");
		startActivity(j);
		break;

		case R.id.button2:
		Intent k = new Intent(this, Webscreen.class);
		k.putExtra(com.lightcone.webviewdemo.Webscreen.URL, 
		"http://www.ssec.wisc.edu/data/east/latest_eastir.gif");
		startActivity(k);
		break;      
	}       
}

Explicit intents require that a specific named class implement the desired action. Since the class structure of an application is not generally known outside the application, explicit intents are usually used for actions that occur within a single application.

Implicit Intents and IntentFilters

An implicit intent specifies in general terms an action and may supply some data, but does not determine the component that is expected to handle the request. Instead, the Android system will decide which components are registered to implement that action and will present to the user a choice of components that have declared that they can handle the requested action. (The user has the option of specifying one of these components to be the default one, so that the choice does not have to be made each time this action is requested.) The schematic way that an implicit intent is handled by the system is illustrated in the following figure.

In this example Activity A creates an Intent describing a desired action and passes it to startActivity(). The Android System searches all apps for an intent filter that matches the intent request. When a match is found, the system starts the matching activity (Activity B) by invoking its onCreate() method and passing it the Intent.

The determination by Android of which components can handle a given request issued through an implicit intent is implemented through an IntentFilter. An IntentFilter specifies the types of intents that an activity, service, or broadcast receiver can respond to. IntentFilters are typically defined in the AndroidManifest.xml file. (For a BroadcastReceiver they also can be defined in the Java code.) For example, consider the following manifest file.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.lightcone.sharingintents" android:versionCode="1" android:versionName="1.0" >

    <application android:icon="@drawable/ic_launcher" android:label="@string/app_name" >
        <activity android:name=".SharingIntents" android:label="@string/app_name" >
            <intent-filter>
                     <action android:name="android.intent.action.MAIN" />
                     <category android:name="android.intent.category.LAUNCHER" />
          </intent-filter>
        </activity>
        <activity android:name=".MyLittleBrowser" android:label="@string/little_browser_name">
            <intent-filter>
            <action android:name="android.intent.action.VIEW" />
            <category android:name="android.intent.category.DEFAULT" />
            <data android:scheme="http"/> 
       </intent-filter>
        </activity>
    </application>

</manifest>

There are two intent filters defined in this manifest file, denoted by the snippets highlighted in red.

1. The first is standard in most apps and defines the class SharingIntents as the entry point for the app when launched normally without an expectation of receiving data (through the action android.intent.action.MAIN), and declares that the app should appear as an icon in the top-level app launcher--the app drawer on standard Android devices--when installed on a device (through the category android.intent.category.LAUNCHER).


2. The second intent filter is a little different. This snippet registers the application associated with the manifest file (SharingIntents) as being capable of handling views as webpages (http protocol), specifically through its class MyLittleBrowser. If this app is installed on the device (Note: it need not be running, only installed), any request by the user to display a webpage will bring up a list of applications registered to handle the request that will include our application.

This second capability is illustrated in the following popup menu (which was triggered by clicking on a web link in some application).

As can be seen explicitly, our app SharingIntents is now listed right up there with the big boys as capable of handling the webpage request (through its class MyLittleBrowser). Of course, the manifest file only declares that our app has this capability; it will be up to us as programmers to ensure that it actually can handle a webpage in a useful way if the user chooses it from this menu. We will describe the basics of how to do that below.

PendingIntents

We also should mention in this context PendingIntents, which are wrappers around intents. They grant permission for another application to use the wrapped intent as if it were being executed from the application responsible for the PendingIntent. The most common usage of PendingIntents occurs in three categories:

1. Notifications, where the NotificationManager executes the intent.


2. Intents that are declared to be executed at some future time by the system AlarmManager.


3. AppWidgets, which are hosted in another app (typically the homescreen or lockscreen) and must be executed from there.

In this project we shall not be concerned with PendingIntents but they are used in some of our other projects. For example, AppWidgets uses PendingIntents to declare intents that will be executed when a user performs some action with an AppWidget. In this case a PendingIntent is necessary because the homescreen or lockscreen app, not the app in which you created the AppWidget, executes the intent. Normally the homescreen or lockscreen would not have permission to do so, but the PendingIntent is the mechanism by which we grant the required permission. We also used PendingIntents to implement the notifications example in the Dialogs, Alerts, & Notifications project.

ShareActionProvider

A powerful class for facilitating sharing called ShareActionProvider was introduced with Ice Cream Sandwich (Android 4.0; API 14). As we shall see, with ShareActionProvider and a very small amount of code the sharing menus become adaptive, with the choices for a task that are used most commonly floating to the top and those seldom used relegated to a secondary menu. This will make it simple to manage implicit sharing in a sleek and user-friendly manner.

With the preceding as basic introduction, let us now turn to writing an app that demonstrates some of the ways in which we can use intents to share information and enable interoperability between applications. Because we wish to take advantage of ShareActionProvider and some other newer things, our app will be restricted to run under Android API 21 and later.

Creating the Project in Android Studio

Following the general procedure in Creating a New Project, either choose Start a new Android Studio project from the Android Studio homepage, or from the Android Studio interface choose File > New > New Project. Fill out the fields in the resulting screens as follows,

where you should substitute your namespace for <YourNamespace> (com.lightcone in my case) and <ProjectPath> is the path to the directory where you will store this Android Studio Project (/home/guidry/StudioProjects/ in my case). If you have chosen to use version control for your projects, go ahead and commit this project to version control.

Filling out the Code

Let us now create and populate the XML and Java files that we need for this project. Note: You should insert your namespace for <YourNamespace> in the following listings.

The XML Files

Edit the file res/values/colors.xml to read

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#ff9800</color>
    <color name="colorPrimaryDark">#f57c00</color>
    <color name="colorAccent">#ffc107</color>
    <color name="barColor">@color/colorPrimary</color>
    <color name="barTextColor">#ffffff</color>color>
    <color name="bkg">#99ffe0b2</color>
    <color name="textbkg">#bbffffff</color>
    <color name="browserPrimary">#9e9e9e</color>
    <color name="browserPrimaryDark">#616161</color>
    <color name="browserAccent">#607d8b</color>

</resources>

Edit the file res/values/styles.xml to read

<resources>

    <!-- Base application theme. NoActionBar because we are using a Toolbar -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
    </style>

    <style name="BrowserTheme" parent="AppTheme">
        <item name="colorPrimary">@color/browserPrimary</item>
        <item name="colorPrimaryDark">@color/browserPrimaryDark</item>
        <item name="colorAccent">@color/browserAccent</item>
    </style>

</resources>

Edit the file res/values/dimens.xml to read

<resources>
    <!-- Default screen margins, per the Android Design guidelines. -->
    <dimen name="activity_horizontal_margin">16dp</dimen>
    <dimen name="activity_vertical_margin">16dp</dimen>

    <dimen name="buttonWidth">320dp</dimen>
    <dimen name="textFieldWidth">350dp</dimen>
</resources>

Edit res/values/strings.xml to give

<resources>
    <string name="app_name">SharingIntents</string>
    <string name="action_settings">Settings</string>
    <string name="little_browser_name">My Little Browser</string>
    <string name="displayPick">Display Picked Image</string>
    <string name="button1_label">Share Input Text</string>
    <string name="button2_label">Scan and Share Barcode</string>
    <string name="button3_label">Select an Image</string>
    <string name="button4_label">Share this Image</string>
    <string name="browserButtonLabel">Test Browser Share</string>
    <string name="shareInvite">Share using</string>
    <string name="subject">My custom subject</string>
    <string name="websubject">Webpage share</string>
    <string name="hintText">(Input some text to share)</string>
    <string name="address1">andy@mayberry.org</string>
    <string name="address2">barney@mayberry.org</string>
    <string name="CC1">auntBee@mayberry.org</string>
    <string name="BCC1">gomerPyle@mayberry.org</string>
    <string name="shareImage">Share image using</string>
    <string name="errorTitle1">We have a problem</string>
	<string name="errorString1">ActivityNotFoundException: No app found to handle the
		barcode intent. One possibility: install the free app Barcode Scanner from the Play Store.
        Google Goggles is another free app that can handle the barcode intent."</string>
    <string name="playStoreAddress">https://play.google.com/store/apps/details?</string>
    <string name="bsString">id=com.google.zxing.client.android</string>
    <string name="toaster">Select share app from top bar menu</string>
    <string name="barcode_cancel">Barcode intent canceled</string>
</resources>

Create the directory res/menu if it doesn't exist. Right-click on res/menu and select New > File, entering the file name main.xml (with the explicit .xml extension). Edit res/menu/main.xml to read

<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <item android:id="@+id/menu_share"
        android:title="@string/shareInvite"
        app:showAsAction="ifRoom"
        app:actionProviderClass="android.support.v7.widget.ShareActionProvider"/>

    <item
        android:id="@+id/action_settings"
        android:orderInCategory="100"
        app:showAsAction="never"
        android:title="@string/action_settings"/>

</menu>

Edit res/layout/activity_main.xml to give

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_marginBottom="0dp"
    android:layout_marginLeft="0dp"
    android:layout_marginRight="0dp"
    android:layout_marginTop="0dp"
    android:background="@color/bkg"
    android:orientation="vertical" >

    <android.support.v7.widget.Toolbar
        android:id="@+id/toolbar"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:elevation="0dp"
        android:minHeight="?attr/actionBarSize"
        android:background="@color/barColor" />

    <EditText
        android:id="@+id/editText1"
        android:layout_width="@dimen/textFieldWidth"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:layout_gravity="center_horizontal"
        android:hint="@string/hintText"
        android:background="@color/textbkg"
        android:inputType="textMultiLine"
        android:padding="8dp">

        <requestFocus />
    </EditText>

    <Button
        android:id="@+id/button01"
        android:layout_width="@dimen/buttonWidth"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:layout_marginTop="15dp"
        android:paddingLeft="20dp"
        android:paddingRight="20dp"
        android:text="@string/button1_label"
        android:textSize="18sp" />

    <Button
        android:id="@+id/button02"
        android:layout_width="@dimen/buttonWidth"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:layout_marginTop="5dp"
        android:paddingLeft="0dp"
        android:paddingRight="0dp"
        android:text="@string/button2_label"
        android:textSize="18sp" />

    <Button
        android:id="@+id/button03"
        android:layout_width="@dimen/buttonWidth"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:layout_marginTop="5dp"
        android:paddingLeft="0dp"
        android:paddingRight="0dp"
        android:text="@string/button3_label"
        android:textSize="18sp" />

    <Button
        android:id="@+id/browserButton"
        android:layout_width="@dimen/buttonWidth"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:layout_marginTop="5dp"
        android:paddingLeft="0dp"
        android:paddingRight="0dp"
        android:text="@string/browserButtonLabel"
        android:textSize="18sp" />

</LinearLayout>

Create the XML file res/layout/mylittlebrowser.xml and edit it to give

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_marginBottom="0dp"
    android:layout_marginLeft="0dp"
    android:layout_marginRight="0dp"
    android:layout_marginTop="0dp"
    android:background="@color/bkg"
    android:orientation="vertical" >

    <android.support.v7.widget.Toolbar
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/toolbar3"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:elevation="0dp"
        android:minHeight="?attr/actionBarSize"
        android:background="@color/browserPrimary" />

    <WebView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/webView"
        android:layout_gravity="center_horizontal" />

</LinearLayout>

Create the XML file res/layout/pickanimage.xml and edit it to give

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_marginBottom="0dp"
    android:layout_marginLeft="0dp"
    android:layout_marginRight="0dp"
    android:layout_marginTop="0dp"
    android:background="@color/bkg"
    android:orientation="vertical" >

    <android.support.v7.widget.Toolbar
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/toolbar3"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:elevation="0dp"
        android:minHeight="?attr/actionBarSize"
        android:background="@color/browserPrimary" />

    <WebView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/webView"
        android:layout_gravity="center_horizontal" />

</LinearLayout>

That completes entry of the required XML files. Now let us add the Java classes that will be required.

The Java Class Files

Edit the class file MainActivity.java to give

package <YourNamespace>.sharingintents;

import android.os.Build;
import android.os.Bundle;
import android.support.v4.view.MenuItemCompat;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.Menu;

import android.app.AlertDialog;
import android.content.ActivityNotFoundException;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.net.Uri;
import android.util.Log;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.support.v7.widget.ShareActionProvider;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity implements OnClickListener {

    private static final String TAG = "SHARE";
    private static final int REQUEST_CODE = 1;
    private ShareActionProvider shareActionProvider;
    private EditText inputText;
    private boolean isBarcodeScan = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Create top toolbar.  This assumes a NoActionBar style in styles.xml
        // since it will be replaced by the following toolbar.

        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        // Remove default toolbar title and replace with an icon
        if (toolbar != null) {
            toolbar.setNavigationIcon(R.mipmap.ic_launcher);
        }

        // Set background color.  Handle method getColor deprecated as of API 23
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            toolbar.setTitleTextColor(getResources().getColor(R.color.barTextColor, null));
        } else {
            toolbar.setTitleTextColor(getResources().getColor(R.color.barTextColor));
        }

        toolbar.setTitle("");
        setSupportActionBar(toolbar);

        // Identify buttons in XML layout and attach click  listeners to each
        View button01 = findViewById(R.id.button01);
        button01.setOnClickListener(this);
        View button02 = findViewById(R.id.button02);
        button02.setOnClickListener(this);
        View button03 = findViewById(R.id.button03);
        button03.setOnClickListener(this);
        View browserButton = findViewById(R.id.browserButton);
        browserButton.setOnClickListener(this);

        // Get handle to input text field
        inputText = (EditText) findViewById(R.id.editText1);

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {

        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);

        // Get the share menu item
        MenuItem menuItem = menu.findItem(R.id.menu_share);
        // Get the provider
        shareActionProvider = (ShareActionProvider) MenuItemCompat.getActionProvider(menuItem);

        return true;
    }

    // Process button clicks
    @Override
    public void onClick(View v) {

        switch (v.getId()) {

            // For button 1, share string data
            case R.id.button01:
                isBarcodeScan = false;
                // Launch the text share intent and associate it with the ShareActionProvider
                Intent share = shareText(inputText.getText().toString());
                Log.i(TAG, "intent=" + share.toString());
                shareActionProvider.setShareIntent(share);

                // Force the soft keyboard closed so following Toast instructions easy to see
                InputMethodManager inputManager = (InputMethodManager)
                        getSystemService(Context.INPUT_METHOD_SERVICE);
                inputManager.hideSoftInputFromWindow(v.getWindowToken(),
                        InputMethodManager.HIDE_NOT_ALWAYS);

                // Display Toast with instructions
                Toast.makeText(this, getString(R.string.toaster),
                        Toast.LENGTH_LONG).show();
                break;

            // For button 2, share barcode data
            case R.id.button02:
                isBarcodeScan = true;
                shareActionProvider.setShareIntent(shareBarcode());
                break;

            // For button 3, pick an image from gallery or other sources and share
            case R.id.button03:
                Intent j = new Intent(this, PickAnImage.class);
                startActivity(j);
                break;

            // For browserButton, test the shared custom browser MyLittleBrowser.  If
            // no preferred browser has been set, this should display a list of
            // apps registered to display webpages, including MyLittleBrowser.  Choosing
            // MyLittleBrowser should display the url given below in MyLittleBrowser.

            case R.id.browserButton:
                String url = "http://developers.google.com";
                Intent k = new Intent(Intent.ACTION_VIEW);
                k.setData(Uri.parse(url));
                startActivity(k);
                break;
        }
    }

    // Method to allow app to share text through implicit intent.  It returns
    // the sharing intent that it creates for potential use in the
    // ShareActionProvider that is managing the share menu in the top action bar.

    public Intent shareText(String s) {

        // Create a sharing intent
        Intent sharingIntent = new Intent(android.content.Intent.ACTION_SEND);

        // Set its type to text
        sharingIntent.setType("text/plain");

        // These allow some custom addresses to be defined. They will be filled in
        // automatically if an email client is invoked for the share, for example.

        String addresses[] = {getString(R.string.address1), getString(R.string.address2)};
        String CCaddresses[] = {getString(R.string.CC1)};
        String BCCaddresses[] = {getString(R.string.BCC1)};

        // Add the text to be shared to the intent
        sharingIntent.putExtra(android.content.Intent.EXTRA_TEXT, s);

        // Following optional fields for email. Will be ignored by sharing app
        // if not appropriate. For example, non-email apps may use the SUBJECT
        // extra and ignore the others.

        // Hardwire in a default subject
        sharingIntent.putExtra(android.content.Intent.EXTRA_SUBJECT,
                getString(R.string.subject));

        // Add default addresses
        sharingIntent.putExtra(android.content.Intent.EXTRA_EMAIL, addresses);
        sharingIntent.putExtra(android.content.Intent.EXTRA_CC, CCaddresses);
        sharingIntent.putExtra(android.content.Intent.EXTRA_BCC, BCCaddresses);

        // If this is text from a barcode scan created by shareBarcode(), wrap
        // the intent in a chooser and start. If it is from input text, don't
        // start here (will be invoked from the task bar share menu in that case).

        if (isBarcodeScan) startActivity(Intent.createChooser(sharingIntent,
                getString(R.string.shareInvite)));

        return sharingIntent;
    }

    /**
     * Following method for scanning barcodes adapted from article by Alexander Lucas at
     *
     * http://android-developers.blogspot.com/2012/02/share-with-intents.html
     *
     * For this to work you must have an app installed on the device that can handle
     * the barcode scanning intent.  Barcode Scanner or Google Goggles are available for
     * free from the Google Play Store and will do the job.  Below we will check to see if
     * there is a barcode scanning app on the device and give the user a choice of installing
     * Barcode Scanner from the Play Store if not.
     */

    public Intent shareBarcode() {

        // Check for an app on the device to handle a barcode scan
        Intent intent = new Intent("com.google.zxing.client.android.SCAN");

        // Clear the app called with above intent from activity stack, so users arrive at
        // the main screen of the app rather than the barcode scanning screen when next
        // launched from the homescreen.

        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT);

        /** The following should scan most standard barcode formats but one can
         restrict the formats for particular applications by adding extras to the intent.
         Some examples:

         // QR codes (2D barcodes) only:
         intent.putExtra("SCAN_MODE", "QR_CODE_MODE");
         // 1D barcodes only:
         intent.putExtra("SCAN_MODE", "ONE_D_MODE");
         // Only UPC and EAN barcodes (appropriate for shopping apps):
         intent.putExtra("SCAN_MODE", "PRODUCT_MODE"

         For more info, see http://code.google.com/p/zxing/source/browse/trunk/android/src/
         com/google/zxing/client/android/Intents.java
         */

        // The essential piece of the following is the startActivityForResult method, but we
        // wrap it in a try-catch to address the case of no app installed on the device that
        // can handle the barcode intent. We don't take similar precautions with the image and
        // plain text share examples because we assume that most devices will have apps
        // installed that can handle those MIME types.

        try {

            // App to handle barcode is present, so start the scanning intent. When result is
            // is returned, the onActivityResult() callback below will be invoked.

            startActivityForResult(intent, REQUEST_CODE);

        } catch (ActivityNotFoundException e1) {
            // If no barcode scanning app on device, notify and give option to acquire one
            e1.printStackTrace();
            String errorTitle = getString(R.string.errorTitle1);
            String error = getString(R.string.errorString1);
            int icon = R.mipmap.ic_launcher;
            showTask(errorTitle, error, icon, this);
        }
        return intent;
    }

    // Will be called when the barcode scanning intent returns. It processes the
    // results into a string and calls shareText() to share the string.

    public void onActivityResult(int requestCode, int resultCode, Intent intent) {

        if (requestCode == REQUEST_CODE) {
            if (resultCode == RESULT_OK) {
                //  Results have been returned, so process them
                String contents = intent.getStringExtra("SCAN_RESULT");
                String format = intent.getStringExtra("SCAN_RESULT_FORMAT");
                Log.i(TAG, "scan string=" + contents + " scan format=" + format);
                shareText(contents);
            } else if (resultCode == RESULT_CANCELED) {
                String error = getString(R.string.barcode_cancel);
                Toast.makeText(this, error, Toast.LENGTH_SHORT).show();
            }
        }
    }

    /**
     * Method showTask() creates a custom  dialog that  presents a summary of the task
     * to the user and has buttons to either launch the task by executing the method launchTask()
     * or cancel the dialog.  In this case this dialog will be presented only if no app to handle the
     * barcode intent is found on the device. The dialog will give that warning and give the user
     * the option of going directly to the Android app market (asssuming a data connection exists)
     * to install the free app Barcode Scanner, which can handle the barcode intent, or to click
     * the Cancel button if the user wants to deal with the issue manually (for example, by
     * downloading a different barcode app like Google Goggles).
     */

    private void showTask(String title, String message, int icon, Context context) {
        AlertDialog alertDialog = new AlertDialog.Builder(context).create();
        alertDialog.setTitle(title);
        alertDialog.setMessage(message);
        alertDialog.setIcon(icon);

        int positive = AlertDialog.BUTTON_POSITIVE;
        int negative = AlertDialog.BUTTON_NEGATIVE;

        alertDialog.setButton(positive, "Get Barcode Scanner", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                launchTask();
            }
        });

        alertDialog.setButton(negative, "Cancel", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {

            }
        });

        alertDialog.show();
    }


    // Method launchTask() is invoked by the showTask dialog to retrieve the app Barcode
    // Scanner from the Android app market (Play Store) if the device doesn't have a barcode scanner
    // app installed.

    private void launchTask() {
        String marketString = getString(R.string.playStoreAddress) + getString(R.string.bsString);
        goToMarket(marketString);
    }

    // Go to Android Play Store for a specific app defined by its url address in Play Store.
    private void goToMarket(String appString) {
        Intent i = new Intent(Intent.ACTION_VIEW);
        i.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT);
        i.setData(Uri.parse(appString));
        startActivity(i);
    }

}

Create the class file MyLittleBrowser.java and edit it to give

package <YourNamespace>.sharingintents;

import java.net.URL;

import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.view.MenuItemCompat;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.support.v7.widget.ShareActionProvider;

public class MyLittleBrowser extends AppCompatActivity {

    private static final String TAG = "SHARE";
    private WebSettings wset;
    private ShareActionProvider shareActionProvider;
    private String urlString;

    /**
     * Called when the activity is first created.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.mylittlebrowser);

        // Create top toolbar.  This assumes a NoActionBar style in styles.xml
        // since it will be replaced by the following toolbar.

        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar3);
        if (toolbar == null) Log.i(TAG, "Toolbar is null");
        // Remove default toolbar title and replace with an icon
        toolbar.setNavigationIcon(R.mipmap.ic_launcher);

        // Set background color.  Handle method getColor deprecated as of API 23
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            toolbar.setTitleTextColor(getResources().getColor(R.color.barTextColor, null));
        } else {
            toolbar.setTitleTextColor(getResources().getColor(R.color.barTextColor));
        }

        toolbar.setTitle("");
        setSupportActionBar(toolbar);


        // Set up the WebView display.  See the projects WebViewDemo and WebViewDemo2
        // for more detailed discussion.

        WebView webview = (WebView) findViewById(R.id.webView); //new WebView(this);

        if (webview == null) Log.i(TAG, "Webview is null");

        // The following prevents redirection out of MyLittleBrowser to another browser, forcing
        // redirects from pages displayed in MyLittleBrowser to stay in MyLittleBrowser.
        // See http://stackoverflow.com/questions/4066438/
        // android-webview-how-to-handle-redirects-in-app-instead-of-opening-a-browser

        webview.setWebViewClient(new WebViewClient() {
            public boolean shouldOverrideUrlLoading(WebView view, String url) {
                view.loadUrl(url);
                return false;
            }

            // This will fire when main webpage has finished loading.  We use it
            // to enable a text share of the page title and URL.

            public void onPageFinished(WebView view, String url) {

                // Get the title of the webpage once loaded
                String webpageTitle = view.getTitle();

                // Attach an intent to the ShareActionProvider that will share the title and
                // url of the webpage loaded.

                shareActionProvider.setShareIntent(shareText(webpageTitle + ":\n\n" + url));
            }
        });

        //setContentView(webview);
        wset = webview.getSettings();
        wset.setBuiltInZoomControls(true);
        wset.setJavaScriptEnabled(true);  // Turning on Javascript can introduce vulnerabilities

        /** This class is launched only by an implicit share intent from an app requesting that
         * a webpage be displayed because of the declaration in the manifest file of the
         * present app
         *
         * <activity android:name=".MyLittleBrowser" android:label="@string/little_browser_name">
             <intent-filter>
             <action android:name="android.intent.action.VIEW" />
             <category android:name="android.intent.category.DEFAULT" />
             <data android:scheme="http"/>
             </intent-filter>
         * </activity>
         *
         * Thus we must
         * first query the Intent that launched this class (very likely from a completely different app)
         * to retrieve the data that it contains. If all is well this will be the address of an HTML
         * page, which we shall display using WebView.
         */

        // Get the Intent that called this class (implicitly, probably from another app)
        Intent intent = getIntent();

        // Extract the action that the calling Intent used
        String intentAction = intent.getAction();

        // Extract the data from the Intent
        Uri intentData = intent.getData();

        // Wrap following in try-catch since URL constructor throws MalformedURLException
        try {
            String scheme = intentData.getScheme();
            String host = intentData.getHost();
            String path = intentData.getPath();
            String query = intentData.getQuery();
            urlString = new URL(scheme, host, path).toString();
            if (query != null) urlString = urlString + "?" + query;
            webview.loadUrl(urlString);
            Log.i(TAG, "scheme=" + scheme + " host=" + host + " path=" + path + " query=" + query);
            Log.i(TAG, "action=" + intentAction + " URL=" + urlString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {

        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);

        // Get the share menu item.
        MenuItem menuItem = menu.findItem(R.id.menu_share);

        // Get the provider. We will invoke it in onPageFinished(webview, url) to
        // enable a text share of the page title and URL once a webpage is loaded.

        shareActionProvider = (ShareActionProvider) MenuItemCompat.getActionProvider(menuItem);

        return true;
    }

    // The class MyLittleBrowser is designed to display an html share from another app,
    // but we add to it the capability to do its own implicit share of the webpage title
    // and url that it processes. Very similar to textShare() in MainActivity. It
    // returns the text-sharing intent for use as an argument in populating the
    // ShareActionProvider menu when the webpage has finished loading; this is
    // invoked in the method onPageFinished() defined above.

    public Intent shareText(String s) {

        // Create a sharing intent
        Intent sharingIntent = new Intent(android.content.Intent.ACTION_SEND);

        // Set the type of the intent to text
        sharingIntent.setType("text/plain");

        // These allow some custom addresses to be defined. They will be filled in
        // automatically if an email client is invoked for the share, for example.

        String addresses[] = {getString(R.string.address1),
                getString(R.string.address2)};
        String CCaddresses[] = {getString(R.string.CC1)};
        String BCCaddresses[] = {getString(R.string.BCC1)};

        // Add the text to be shared to the intent
        sharingIntent.putExtra(android.content.Intent.EXTRA_TEXT, s);

        // Following optional fields for email. Will be ignored by sharing app
        // if not appropriate. For example, non-email apps may use the SUBJECT
        // extra and ignore the others.

        // Hardwire in a default subject
        sharingIntent.putExtra(android.content.Intent.EXTRA_SUBJECT,
                getString(R.string.websubject));

        // Add some pre-defined addresses
        sharingIntent.putExtra(android.content.Intent.EXTRA_EMAIL, addresses);
        sharingIntent.putExtra(android.content.Intent.EXTRA_CC, CCaddresses);
        sharingIntent.putExtra(android.content.Intent.EXTRA_BCC, BCCaddresses);

        return sharingIntent;
    }
}

Create the class file PickAnImage.java and edit it to give

package <YourNamespace>.sharingintents;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.view.MenuItemCompat;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;
import android.support.v7.widget.ShareActionProvider;

public class PickAnImage extends AppCompatActivity implements OnClickListener {

    private static final String TAG = "SHARE";
    private static final int REQUEST_CODE = 1;
    private Bitmap bitmap;
    private ImageView imageView;
    private Button shareButton;
    private Uri uri;
    private ShareActionProvider shareActionProvider;

    /**
     * Called when the activity is first created.
     */

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.pickanimage);

        // Create top toolbar.  This assumes a NoActionBar style in styles.xml,
        // since it will be replaced by the following toolbar.

        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar2);
        // Remove default toolbar title and replace with an icon
        if (toolbar != null) {
            toolbar.setNavigationIcon(R.mipmap.ic_launcher);
        }

        // Set background color.  Handle method getColor deprecated as of API 23
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            toolbar.setTitleTextColor(getResources().getColor(R.color.barTextColor, null));
        } else {
            toolbar.setTitleTextColor(getResources().getColor(R.color.barTextColor));
        }
        // Note: getColor(color) deprecated as of API 23
        //toolbar.setTitleTextColor(getResources().getColor(R.color.barTextColor));
        toolbar.setTitle("");
        setSupportActionBar(toolbar);
        imageView = (ImageView) findViewById(R.id.theImage);
        shareButton = (Button) findViewById(R.id.button04);
        shareButton.setOnClickListener(this);
        chooseImage();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {

        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);

        // Get the share menu item
        MenuItem menuItem = menu.findItem(R.id.menu_share);
        // Get the provider
        shareActionProvider = (ShareActionProvider) MenuItemCompat.getActionProvider(menuItem);

        return true;
    }

    // This will allow you to choose an image from the device by selecting it in a file chooser
    // such as Gallery.  It will be displayed in an ImageView once selected.

    public void chooseImage() {
        Intent intent = new Intent();
        intent.setType("image/*");
        intent.setAction(Intent.ACTION_GET_CONTENT);
        intent.addCategory(Intent.CATEGORY_OPENABLE);

        startActivityForResult(intent, REQUEST_CODE);

        /** Alternative: Preceding line can be replaced by the following commented-out line,
         * which may give the user some say in the form of the chooser for some devices.  See the
         * API documentation of the Intent static string constant ACTION_GET_CONTENT for
         * discussion of the difference.
         */

        //startActivityForResult (Intent.createChooser(intent, "Message"), REQUEST_CODE);
    }

    // Executed when the activity started from chooseImage() with startActivityForResults
    // returns a result.  Uses a content resolver to retrieve an image from the device,
    // assign it to a bitmap, and display the bitmap. The Uri of the image file that is displayed
    // in the bitmap is saved in the variable uri to be passed to the method shareImage(uri),
    // which shares the bitmap.

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
        InputStream inStream = null;
        if (requestCode == REQUEST_CODE && resultCode == Activity.RESULT_OK)
            try {
                uri = intent.getData();
                inStream = getContentResolver().openInputStream(uri);
                bitmap = BitmapFactory.decodeStream(inStream);
                imageView.setImageBitmap(bitmap);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } finally {
                if (inStream != null)
                    try {
                        inStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
            }
        super.onActivityResult(requestCode, resultCode, intent);
    }

    // Share the bitmap that was selected from the local filesystem using the chooseImage()
    // method by using an implicit intent.  When launched with
    // shareActionProvider.setShareIntent(shareImage(uri)) in the onClick method below,
    // this will populate the top Toolbar with an adaptive sharing menu (most used apps
    // will float to the top and the current default will appear as a separate icon), and
    // will open the sharing menu (if the startActivity line below is not commented out).

    public Intent shareImage(Uri uri) {
        Intent shareIntent = new Intent(Intent.ACTION_SEND);
        shareIntent.setType("image/*");
        // Clear activity stack if reset
        shareIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT);
        //shareIntent.setAction(Intent.ACTION_SEND);
        Log.i(TAG, "shareImage:  Uri=" + uri);
        shareIntent.putExtra(Intent.EXTRA_STREAM, uri);

        // Comment out following line to populate top ActionBar with adaptive sharing menu
        // but not open the sharing menu until selected by user. With this line present
        // the menu will be added and will be opened by default, which is likely the most
        // user-friendly workflow.

        startActivity(Intent.createChooser(shareIntent, getString(R.string.shareImage)));

        return shareIntent;
    }

    @Override
    public void onClick(View v) {

        switch (v.getId()) {

            case R.id.button04:
                Log.i(TAG, "uri=" + uri.toString());
                Intent temp = shareImage(uri);
                Log.i(TAG, "intent=" + temp.toString());

                shareActionProvider.setShareIntent(shareImage(uri));
                break;
        }
    }
}

The Manifest File

Edit the AndroidManifest.xml file to give

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="<YourNamespace>.sharingintents">
    
    <uses-permission android:name="android.permission.INTERNET" ></uses-permission>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name=".PickAnImage"
            android:label="@string/displayPick" />
        <activity
            android:name=".MyLittleBrowser"
            android:label="@string/little_browser_name" 
       android:theme="@style/BrowserTheme">
            <intent-filter>
                <action android:name="android.intent.action.VIEW" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:scheme="http" />
            </intent-filter>
        </activity>
    </application>

</manifest>

where the material added to the default file created by Android Studio is indicated in red.

Trying it Out

Launch the app on a device or on an emulator to give the following main screen, with an editable textfield, four buttons, and a toolbar with menu.

Notice that in the top toolbar there is a share icon (three dots connected by straight lines), but if you click it you will see that its dropdown menu is not yet populated with anything. Also, if you click the overflow menu (three vertical dots to the right of the toolbar) you will see that there is a Settings category, but we won't be populating it with anything in this project so nothing happens if you click it.

The Share Text Button

After filling in the EditText field with some text, clicking the Share Input Text button gives the image shown below,

where a transient Toast prompts us to choose an app from the top menu bar. Indeed, the share icon dropdown menu is now populated, as is confirmed by clicking it, which gives the image below left, with a primary set of entries and a "See all" choice. If one clicks See all on the sharing dropdown menu, the menu expands into the full menu shown below right.

These new features correspond to options that are available for sharing our text, and display a list of all apps running on the device that have declared in their manifests that they can handle a text share. These sharing options have some powerful features that are being managed under the hood by Android:

1. The share menu is adaptive: all apps in the list have declared ability to deal with the share, but over time apps with a history of being chosen to share this data type from the app float to the top of the menu and the others float down to the secondary menu (and so are not initially visible when one clicks on the share icon).


2. The app that Android has decided you are most likely to use for this share is placed in its own icon in the toolbar. (See the figure below left, where the icon for Google Keep is being displayed. You can force an override of the default app by long-pressing on it and selecting a new one, and the default app displayed may change on its own accord if you begin selecting a new app regularly for this share.)

We may now choose one of the apps in the list with which to share our text.

Using the menu shown below left and choosing Evernote-Create Note from the options gives the screen shown below right, with the subject and text that we have shared pasted into the Evernote app (Evernote is available in a free version from Google Play). At this point we are in the Evernote app and can perform any of the functions it is capable of on text content.

Since plain text is a format that many apps can handle, you will likely have many other options in the sharing choice menu; In the above example the total list of apps competing to handle my shared text included 31 options (the above images show only part of the scrolling list). You can investigate other options for sharing text by choosing them rather than Evernote from the list. You will probably find that many are useful, others not so much.

The Share Barcode Button

The action associated with clicking the Share Barcode button depends on whether your device has a barcode scanning app installed that can handle our intent. Let us first assume that it does not. The following two screens illustrate actions on a device where no barcode scanning app is found.

On the left screen the app has detected no appropriate app to handle the barcode scan on the device and opened a dialog window giving the user the choice of going to the Android app market (Google Play) to install the free app Barcode Scanner. In the right image the user has clicked the Get Barcode Scanner button and has been taken to the installation screen in the Google Play store for the Barcode Scanner app. Alternatively, you can hit Cancel on the screen in the left image and install a barcode scanning app manually.

Assuming that your device has at least one barcode scanning app installed, clicking the Share Barcode button brings up a sharing choice menu for barcode scanners (notice also that the top bar has been populated with barcode scanner sharing options, with the symbol for Barcode Scanner being displayed as the default in this example):

Selecting one should open a barcode scanning window. Placing a 1D or 2D (QR) barcode in the window causes the code to be scanned and opens the sharing choice window corresponding to the image below left. Choosing Gmail from the list of apps gives the mail app shown in the image below right, with the To, Cc, Bcc, Subject, and text body fields already populated with our shared information (you may have to use the options menu in Gmail to display all these fields if they are not set to display by default).

We are now in the Gmail app, so we can perform any of its normal functions, such as editing, adding attachments, or sending. In this example the scan was of a 2D QR barcode on a brochure, containing a Web address (for a hotel chain in this case). You can explore the action of other options in the share choice menu by repeating the procedure and choosing one of them in the share choice menu instead of Gmail.

The Pick an Image Button

Clicking the Select an Image button gives a screen similar to the one below left, where apps on the device that have file managing capability for image files appear in the share menu. (Exactly what the screen will look like depends somewhat on the version of Android; this screenshot is from a device running Android 6.0.1.) The screen below right resulted from selecting (Google) Photos in this case and then selecting an image from there.

Clicking the Share this Image button invokes the method chooseAnImage() from the class PickAnImage, giving the screen below left, where we see that many apps have declared that they can handle a bitmap image. (Note that all options also are available from the dropdown sharing menu at the top.) Selecting Google+ from the app list displayed there gives the screen below right, with our previously-chosen image inserted into the editing interface.

This is now ready to add any additional information desired before posting. For the other options appear in the share choice menu their actions can be explored by repeating the procedure and selecting them from the share choice menu instead of Google+. For example, choosing Android Beam instead gives the figure below left, ready to share by touching another Android device (if Beam is turned on for both phones), and choosing Snapseed instead opens the image in the Snapseed photo editor, as illustrated below right, ready to edit.

Responding to an HTTP Request from Another App

Finally, close the application SharingIntents and open another application that contains web links. Provided that you have disabled any default browser choice (as described above in the first box), you will be presented with a choice screen similar to that displayed below left, with My Little Browser as one of the options to display the HTTP request.

Selecting My Little Browser from this list displays the webpage corresponding to the link, as illustrated in the above right figure (which in this case resulted ultimately from a link displayed in a page).

How it Works

Five important functionalities are demonstrated in this application:

1. How to use intents to share plain-text data.


2. How to use intents to retrieve an arbitrary image from your device.


3. How to use intents to share an image from your application to another.


4. How to use intent filters to declare that your application handles http (web display) requests from other applications.


5. How to implement functionality to handle such http requests from other applications.

A brief summary of how the code listed above implements each of these will be given now, with more detail to be found in the extensive comments for the Java code.

Using ShareActionProvider

The rather impressive management of the sharing menu implemented in the top tool bar in the above examples is done almost entirely by Android in response to a few lines of code. Let's illustrate by how it behaves in MainActivity.java. The toolbar menu is inflated in the method onCreateOptionsMenu(Menu menu) by the statements

// Get the share menu item
MenuItem menuItem = menu.findItem(R.id.menu_share);
// Get the provider
shareActionProvider = (ShareActionProvider) MenuItemCompat.getActionProvider(menuItem);

where we have defined a ShareActionProvider object called shareActionProvider, and the sharing menu items are implemented by the tag marked in red in res/menu/menu.xml

<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <item android:id="@+id/menu_share"
     android:title="@string/shareInvite"
     app:showAsAction="ifRoom"
     app:actionProviderClass="android.support.v7.widget.ShareActionProvider"/>

    <item
        android:id="@+id/action_settings"
        android:orderInCategory="100"
        app:showAsAction="never"
        android:title="@string/action_settings"/>

</menu>

with the ShareActionProvider referenced from the Java code by R.id.menu_share. The only essential additional action is that when we wish to populate and invoke the ShareActionProvider menus a statement of the form

shareActionProvider.setShareIntent(shareIntent)

must be executed, where shareIntent is the Intent that will implement the share. Specific examples of this will be given below.

Using Intents to Share Plain Text

This functionality is implemented in the method shareText(String s) of the class MainActivity, where s is the text to be shared. The key points:

• We create an Intent object sharingIntent by means of the constructor Intent(String action), using as the String argument the Intent class String constant ACTION_SEND.




Notice that the argument for the Intent constructor must be in a namespace, because the system uses intents globally. Thus the argument for the Intent constructor in the method shareText is specified by the fully-qualified android.content.Intent.ACTION_SEND.




• The setType(String mimetype) method of Intent is used to set an explicit MIME data type of text/plain for sharingIntent. This method is used to create intents that specify only a data type and not actual data. Restricting the share intent to a specific data type has the advantage that only apps registered (through their manifest files) to handle that data type will respond to the share request.

  
  

  A MIME (Multipurpose Internet Mail Extensions) type is an internet standard that extends basic email to include Non-ASCII text Attachments that are not text Message bodies having multiple parts Header information in non-ASCII character sets Most modern email is transmitted using the Short Message Transport Protocol (SMTP) in MIME format, but MIME is now used in a broad range of other applications too, most notably for Web data transmision. Some commonly-used MIME types include image/jpeg: JPEG image image/png: Portable Network Graphics (PNG) video/mp4: MP4 video video/mpeg: MPEG-1 video with multiplexed audio audio/mp4: MP4 audio audio/vnd.wave: WAV audio text/plain: Plain text data text/html: Hyper-Text Markup Language (HTML) text/xml: Extensible Markup Language (XML) application/pdf: Portable Document Format (PDF) but there are many others; here is a more complete list. Unlike MIME type matching in some contexts, in the Android framework the MIME type is case-sensitive. Thus MIME types in Android applications should always be specified with lower case letters, and MIME types received from outside of Android should be converted to lower case before use. If the exact data type is unknown beforehand, less restrictive MIME types may be specified. For example, if you know that you want to share a bitmap but its precise format might possibly be PNG, JPEG, GIF, ... in a given instance, the MIME type could be specified as simply image/*, with the expectation that the application responding to the share request will be able to interpret the specific image format.

  
  


• We define a set of string arrays that will hold String data and used the overloaded putExtra methods of Intent to add data to the intent, in particular putExtra(String name, CharSequence value) and putExtra(String name, String[] value). The variable name in these methods corresponds to string constants of the Intent class that specify particular uses of the data being passed in the variable value. For example,
  
  
  • android.content.Intent.EXTRA_TEXT, which specifies data that are to be interpreted as the main text to be transmitted.
  
  
  • android.content.Intent.EXTRA_SUBJECT, which specifies data that are to be interpreted as a subject line, in a suitable context.
  
  
  As noted above, since Intents are used globally these constants must be referenced by a fully qualified name, such as android.content.Intent.EXTRA_TEXT.


• To start an activity with the intent just defined, we may generally use
  
  
  • The Activity method startActivity(Intent intent), if we need to start the activity and don't need a result returned.
  
  
  • The Activity method startActivityForResults(Intent intent, int requestCode), if we need to start an activity and have a result returned (where the user-defined integer requestCode will be used to associate the returned result with the intent that requested it).
  
  
  In this example no result needs to be returned, so the first form is used.


• In the argument of startActivity(Intent intent) a construction employing the static Intent method Intent.createChooser(Intent target, CharSequence title) (which returns an Intent) is used. This is a convenience method creating an ACTION_CHOOSER intent that will display a chooser allowing the user to select among the options displayed to handle the action specified by the intent.


• Finally, the method shareText() is used to return the Intent that was constructed to implement the text share.

Now, in the onClick(View v) method, we use

Intent share = shareText(inputText.getText().toString());
shareActionProvider.setShareIntent(share);

to launch the sharing intent and associate it with the ShareActionProvider, which will populate the sharing menu in the top toolbar with sharing options that can be chosen to complete the text share. The images shown above illustrate these features of the method shareText(String s) in action.

Using Intents to Read a Barcode and Share its Content

The method shareBarcode() of MainActivity implements a barcode scan and then shares the result of that scan as a string with other applications. The method is laced heavily with comments and is based on the excellent example and discussion given in Share With Intents, by Lucas Alexander. The reader is referred to both for a deeper understanding of how the method works and we shall only make some general comments here.

• Since not every device will have an app installed that can handle our barcode scan request, we wrap things in a try-catch structure, catch ActivityNotFoundException, indicating that no suitable app to handle the barcode scan exists on the device, and pop up some dialog giving the user the option of installing Barcode Scanner from Google Play. This is handled mostly in the methods showTask(), launchTask(), and goToMarket()..


• The class providing the constants to use when sending an Intent to Barcode Scanner may be found in the package com.google.zxing.client.android.


• In this example we wish to launch the barcode scan and have the result returned as a string, so the Activity method startActivityForResults(Intent intent, int requestCode) is used.


• When the onActivityResult() method is called, returning the correct codes, we process the data using the getStringExtra(String name) method of Intent, using for the argument name appropriate constants that are defined in the package com.google.zxing.client.android, such as SCAN_RESULT.


• The method shareBarcode() returns the scanning intent that it generates and in onClick(View v) we use
  
  

  shareActionProvider.setShareIntent(shareBarcode());
  

  to launch the barcode scanner and to invoke the ShareActionProvider to manage the share menu in the action bar.

Once the string has been returned corresponding to the scan result, the method shareText(String s) documented above is used to share it with other applications. Note that since shareText(String s) is being used both to share text generated in the input EditText and to share text generated by the barcode scanner method, a boolean isBarcodeScan is required to distinguish the two uses.

intent.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT);

Using Intents to Retrieve Images from your Device

In this example implicit intents are used to retrieve a bitmap stored on the device, and then another implicit intent is used to share that image. Both are implemented in the class PickAnImage. The first is discussed in this section and the second in the next section. The work for the image retrieval is done in the methods chooseImage() and onActivityResult(...). In chooseImage() we

• Create a new Intent called intent.


• Use the Intent method setType(String mimetype) to set the MIME type to image/*, appropriate for a general bitmap image.


• Use the Intent method setAction(String action), which sets the general action to be performed as a result of the Intent, with the constant argument Intent.ACTION_GET_CONTENT, which allows the user to select a particular kind of data and return it.
  
  
  

  Notice that this is different from Intent.ACTION_PICK, which would specify a URI of existing data from which the user can pick. Here we only specify the type of data in which we are interested, not specific locations. There are two general ways in which this action can be used: For a specific kind of data the MIME type can be set to the kind of data desired and then startActivity(Intent) is invoked. The system will then launch the best application to select that kind of data for you (or present you with a list of choices). In some cases there may be more than one possible data type in which the user is interested (Example: adding an attachment to an email message, which might be one of several data types). Then the GET_CONTENT intent should be wrapped with a chooser using createChooser(Intent, CharSequence), just as we did above in the text sharing example. This gives a proper interface for the user to pick how to send your data and allows specifying a prompt indicating the action being taken. In this case one usually specifies a broad MIME type such as image/* or */*, giving a range of content types the user can select. In the example being discussed here we have used the first choice above, indicating an interest in general bitmap images but letting the system decide how to present the choices to us.

  
  


• Use the addCategory(String category) method of Intent, which adds new categories to the Intent. In this case the argument category corresponds to the static string constant Intent.CATEGORY_OPENABLE, indicating that the intent wants only URIs that can be opened with the static method ContentResolver.openInputStream(), which we discuss further below.
  
  
  

  Categories add detail about the action the intent is to perform. The argument category can be one of the predefined Intent categories such as Intent.CATEGORY_OPENABLE, or can be a custom category in your own namespace. As discussed in the documentation for IntentFilter, when a filter is resolving an intent three conditions must be met in comparing the intent and the intent filter: The actions must match. The categories must match The data must match. (See IntentFilter for definitions of precisely what a match entails in each case.) Thus, specifying categories is one way to delimit the apps that will respond to your intent.

  
  


• We then invoke the Activity method startActivityForResults(intent, REQUEST_CODE), since in this case we need a result to be returned. The user-defined integer REQUEST_CODE is passed with the intent and will be used to associate the returned result with the intent that requested it.


• When the activity associated with startActivityForResults(intent, REQUEST_CODE) returns results, our override of the Activity method onActivityResult() will be executed. In this method we first check that the requestCode matches that used to start the intent and that the resultCode returned is Activity.RESULT_OK, indicating that the operation succeeded. If these conditions are satisfied,
  
  
  1. We use the getData() method of Intent to return the Uri for the image resource that the user has selected, which we store in the variable uri for use later in the method shareImage(Uri uri).
  
  
  2. We define an InputStream (readable source of bytes, in this case from the filesystem):
     
     
     • First we use the getContentResolver() method that Activity inherits from Context, which returns an instance of ContentResolver for the application's package (see the Content Providers document and the next box below).
     
     
     • Then the ContentResolver method openInputStream(Uri uri) returns an InputStream corresponding to the content associated with uri.
  
  
  3. This stream is then used as input to BitmapFactory.decodeStream(InputStream is), which returns a Bitmap that we assign to the variable bitmap.
  
  
  4. Finally, we use the method setImageBitmap(Bitmap bitmap) of ImageView to display the returned bitmap in an ImageView.

The above actions are wrapped in try-catch-finally structures because openInputStream(uri) throws FileNotFoundException and the close() method of InputStream throws IOException.

Using Intents to Share an Image from your Application

In the method shareImage(Uri uri) in the class PickAnImage we do something similar to the earlier example of sharing text except that we now share the bitmap image that was retrieved using the chooseImage() method, whose Uri has been passed to shareImage() as the variable uri. First we create an Intent called shareIntent. Then,

• We set the data type to a general image format image/* using the Intent method setType(String mimetype).


• We add the flag Intent.FLAG_ACTIVITY_NEW_DOCUMENT that has been described in a previous box.


• We use the setAction(String actions) of Intent to set the action to Intent.ACTION_SEND, indicating an action to deliver some data to someone who is not specified; it will be the responsibility of the receiver of the action to ask the user where the data should be sent.


• We use the method putExtra(String name, CharSequence value) to add an extra to the intent using the name Intent.EXTRA_STREAM, which specifies a URI holding a stream of data associated with the Intent, and the value uri.


• Then, we wrap a chooser with a startActivity command, as described above in the sharing text example, and have the method return the intent that we just constructed.

Finally, in the onClick(View v) method, we use

shareActionProvider.setShareIntent(shareImage(uri));

to initiate the image share and invoke the ShareActionProvider to manage the share menu.

Handling Implicit HTTP Intents with Our App

Now we shift emphasis from exporting content to other apps to registering our own app to receive and process shares from other apps. There are two basic steps in setting up the class MyLittleBrowser to handle implicit HTTP requests from other applications.

1. We must use the SharingIntents manifest file to indicate that our application can handle such requests through its MyLittleBrowser class. This is accomplished by the following entry in the manifest file.
   
   

   <activity
         android:name=".MyLittleBrowser"
         android:label="@string/little_browser_name" >
         <intent-filter>
               <action android:name="android.intent.action.VIEW" />
               <category android:name="android.intent.category.DEFAULT" />
               <data android:scheme="http" />
         </intent-filter>
   </activity>
   

   in which the tag marked in red declares that the class MyLittleBrowser can handle HTTP data.


2. Because of the above declaration, once the application SharingIntents is installed, My Little Browser will appear in the share options for another app wishing to share HTTP data. Here is an example from an older phone:
   
   
   
   
   Since we may now receive some HTTP data from another application at any time, we had better set up the class MyLittleBrowser to handle these data! This consists of the following steps in our simple example.


• A WebView is implemented to display results, similar to what has been described in the project WebView Demo, and a WebViewClient is set up to prevent data sent to our browser class from being redirected, as described in the following box.
  
  
  

  If a WebViewClient is not provided, WebView will ask the Activity Manager to choose a handler for the url. Overriding the shouldOverrideUrlLoading(WebView, String) method WebViewClient gives the host application a chance to take over control when a new url is about to be loaded in the current WebView. (Note: this method will be deprecated in favor of shouldOverrideUrlLoading (WebView, WebResourceRequest) in API 24.) If this method returns true the host application will handle the url. If it returns false the current WebView will handle the url. Thus you can force page redirects to be handled within the original WebView by returning false from this overridden method (see this example).

  
  


• We retrieve the intent that called this activity by using the getIntent() method of Activity and assign it to the variable intent.


• The getAction() method of Intent is then invoked, which retrieves the general action to be performed, such as ACTION_VIEW (which displays the data to the user), and we assign it to the variable intentData. The action is useful in deciding how the rest of the information in the intent should be interpreted. Remember, if the component is responding to an implicit intent, the information could have come from many different applications on the device.


• We use the Intent method getData() to extract the data from intent and assign it to the variable intentData, which we expect to be a Uri.


• Next the following Uri methods are invoked on intentData:


1. The getScheme() method, which returns the scheme part of the Uri, e.g. "http".


2. The getHost() method, which returns the host, e.g., "google.com".


3. The getPath() method, which returns the decoded path.


4. The getQuery() method, which returns any decoded query information (the part of the Uri after a "?" and before a "#").


5. This information is then used to form a URL for the webpage, by employing a constructor of the URL class.


6. Finally, a string representation of the URL is inserted in the loadURL (String url) method of WebView to display the webpage in My Little Browser.


Since the constructor of URL throws MalformedURLException, all of this is wrapped in a try-catch structure to catch the exceptions.

MyLittleBrowser has been constructed to receive and process HTML shares from other apps. But as an illustration we have also built into it the capability to share itself. In particular, by clicking its sharing menu in the task bar it can share as text the title and URL of the webpage loaded by MyLittleBrowser, as illustrated in the following share of a MyLittleBrowser webpage to Google Translate

This MyLittleBrowser capability is implemented much like the text share described in MainActivity, except that

1. We set up the ShareActionProvider in onCreateOptionsMenu(menu), but implement it in the WebViewClient method onPageFinished(WebView view, String url), which is called after the webpage is finished loading.


2. We use the WebView method getTitle() to retrieve the title of the webpage and add it to the URL passed by onPageFinished(WebView, url) to construct the text to be shared. Note that this URL is not necessarily the one used originally to open the page (which is held in the variable urlString) because of possible page redirects.

Of course, our browser as presently implemented is fairly minimal (but spunky!). Nevertheless, it is now registered and provisioned to handle requests to display webpages for other apps on the device, just like any other installed browser app. And it would not be hard to make it much more capable using the APIs of the WebView and WebViewClient classes; see Exercise 4 below.

Examples of Flexible Interoperability through Intents

Intents, particularly of the implicit pursuasion, provide extremely flexible and therefore often extremely useful interoperability among applications that need know little directly about each other. Let us illustrate with several examples using the present application.

Sharing a Barcode Scan to Barcode Scanner

Notice that if you choose Barcode Scanner to handle the share intent when sharing text/plain data (assuming Barcode Scanner is installed on the device), this will produce a QR code corresponding to the shared text, as illustrated in the following two figures.

The image above right is the 2D QR code corresponding to a book number 9780122191411 that was scanned with this app from a 1D barcode (and note that Barcode Scanner has also appended our default subject line as plain text in the image.) You can verify this by scanning this QR code with a barcode scanning app, or even more directly by noting that in the right figure above there is a share icon. If you click it you will get a dropdown menu of apps that our share to Barcode Scanner can itself share with. Choosing Gmail from the options gives

confirming our interpretation of the QR code as representing the number 9780122191411. Thus, you could use SharingIntents to

• Create barcodes by typing text into our EditText field, sharing to Barcode Scanner, and then choosing an app with which to share the resulting QR code from its sharing menu.


• Convert 1D barcodes into 2D QR codes by using our app to scan the 1D barcode, choosing Barcode Scanner as the share app, and then using the share menu of Barcode Scanner to export the result.

These possibilities suggest once again the power and utility of the Android implicit intents sharing model.

Sharing an Image to Google Goggles

An interesting sharing option for an image is that if Google Goggles is chosen from the share menu as the app to handle the image, it will scan it and attempt to identify it by matching it against images in its database. If it is unable to match, it will present a set of images that it believes to be closest to your image, but if it detects what it believes to be a match it identifies the image and provides links to further information. The following figures illustrate.

In the figure lower left the Select an Image button of MainActivity has been used to select an unknown image from the SD card of the phone. (The actual image in this example was accessed from the /mnt/sdcard/.kayakimages/airlines subdirectory on a phone, which corresponds to resource images used by the travel app Kayak. The image is fuzzy because it is of low-resolution and intended for use only as an icon in the app.) Clicking on the Share this Image button gives a share menu shown below right, from which we choose Goggles.

After scanning and analyzing the image, Goggles returns the screen below left, indicating that it believes our image matches the logo of Sichuan Airlines. Clicking on the lower panel of this image returns the set of weblinks shown in the image below right, which confirms that this is a (low-resolution) image of the Sichuan Airlines logo, and gives us a set of links to information about the airline.

Clicking on the Wikipedia link takes us to an article about the airline, where you would learn that it is a subsidiary of China Southern Airlines that began operations in 1988, that it has 81 planes that fly to more than 60 destinations (at the time this screenshot was made) with a main hub in Chengdu, China, and that it has a frequent flyer program with the seriously cool name Golden Panda.

As another example of sharing an image to Goggles using our app, the figure below left shows an image selected from the cloud (Google Photos) on my phone using the Select an Image button of our app, along with a share menu. Choosing Goggles from the menu causes the image to be scanned and identified as San Sebastian Cathedral in Donostia (San Sebastian) Spain, as illustrated in the middle figure below. Clicking the information window at the bottom produced the webpage shown below right, with information, links, and maps concerning this landmark.

These examples illustate potentially useful deductions and information that interoperability among our app, Google Goggles, a Google search backend, a Web browser, and Wikipedia has facilitated, all enabled smoothly and seamlessly by a series of Android intents interconnecting independent applications that require only minimal prior knowledge of each other.

How Different Apps Handle a Text Share

A useful illustration of the principle that in sharing using implicit intents the app that the user chooses to handle the data may deal with the same data in different ways is afforded by considering what happens if different choices are made for the app to handle the share in the chooser window. Here are some illustrative examples of how different apps installed on my phone deal with the text sharing example discussed above. (All apps listed are available in free versions from Google Play, if you want to check this yourself.)

1. Gmail email client: The mail window comes up with the Text, Subject, To, CC, and BCC fields filled in. (You may have to enable display of some of those fields in the Gmail options menu in order to see them.)


2. Slices twitter client: New tweet window filled in with the subject and text.


3. Google Drive: Opens an Upload to Drive dialog.


4. Dropbox: Opens a dialog to upload as a file to your Dropbox account.


5. Google+: Opens a posting screen with the shared text filled in and the usual options displayed.


6. Hanping Pro: Attempts to translate the English text to Chinese. Works for words and short phrases.


7. K9 email client: The mail window comes up with the Text, Subject, To, CC, and BCC fields filled in (essentially the same result as for Gmail).


8. Translate language translation: Attempts to interpret language of the text and to translate it into a variety of languages of your choice. Works even for sentences not in English. For example, using "Comment allez vous?" for the shared text and choosing Translate for the share app correctly identifies the phrase as French and translates it into English as "How are you?" (or into other languages, if you choose).


9. Barcode Scanner: Displays the text as a 2D (QR) code and the subject as text.


10. Copy to clipboard: Copies the text to the clipboard, from which it can be pasted into any applications accepting Paste.


11. Bluetooth: Searches for nearby bluetooth devices. If one is found and the other device accepts the upload, transfers a file containing the share.

In some of these cases the app has used the text simply as English text. In others like Barcode Scanner, Dropbox, Hanping Pro, or Translate the app has played to its unique strengths and processed the text string into something different.

Last modified: July 22, 2016