Java tutorial
/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.support.v7ox.widget; import android.content.Context; import android.content.Intent; import android.content.pm.PackageManager; import android.content.pm.ResolveInfo; import android.graphics.drawable.Drawable; import android.os.Build; import android.support.v4ox.view.ActionProvider; //import android.support.v7ox.appcompat.R; import com.gigigo.permissions.R; import android.support.v7ox.widget.ActivityChooserModel.OnChooseActivityListener; import android.util.TypedValue; import android.view.Menu; import android.view.MenuItem; import android.view.MenuItem.OnMenuItemClickListener; import android.view.SubMenu; import android.view.View; /** * Provides a share action, which is suitable for an activity's app bar. Creates * views that enable data sharing. If the provider appears in the * overflow menu, it creates a submenu with the appropriate sharing * actions. * * <h3 id="add-share-action">Adding a share action</h3> * * <p>To add a "share" action to your activity, put a * <code>ShareActionProvider</code> in the app bar's menu resource. For * example:</p> * * <pre> * <item android:id="@+id/action_share" * android:title="@string/share" * app:showAsAction="ifRoom" * app:actionProviderClass="ShareActionProvider"/> * </pre> * * <p>You do not need to specify an icon, since the * <code>ShareActionProvider</code> widget takes care of its own appearance and * behavior. However, you do need to specify a title with * <code>android:title</code>, in case the action ends up in the overflow * menu.</p> * * <p>Next, set up the intent that contains the content your activity is * able to share. You should create this intent in your handler for * {@link android.app.Activity#onCreateOptionsMenu onCreateOptionsMenu()}, * and update it every time the shareable content changes. To set up the * intent:</p> * * <ol> * <li>Get a reference to the ShareActionProvider by calling {@link * android.view.MenuItem#getActionProvider getActionProvider()} and * passing the share action's {@link android.view.MenuItem}. For * example: * * <pre> * MenuItem shareItem = menu.findItem(R.id.action_share); * ShareActionProvider myShareActionProvider = * (ShareActionProvider) MenuItemCompat.getActionProvider(shareItem);</pre></li> * * <li>Create an intent with the {@link android.content.Intent#ACTION_SEND} * action, and attach the content shared by the activity. For example, the * following intent shares an image: * * <pre> * Intent myShareIntent = new Intent(Intent.ACTION_SEND); * myShareIntent.setType("image/*"); * myShareIntent.putExtra(Intent.EXTRA_STREAM, myImageUri);</pre></li> * * <li>Call {@link #setShareIntent setShareIntent()} to attach this intent to * the action provider: * * <pre> * myShareActionProvider.setShareIntent(myShareIntent); * </pre></li> * * <li>When the content changes, modify the intent or create a new one, * and call {@link #setShareIntent setShareIntent()} again. For example: * * <pre> * // Image has changed! Update the intent: * myShareIntent.putExtra(Intent.EXTRA_STREAM, myNewImageUri); * myShareActionProvider.setShareIntent(myShareIntent);</pre></li> * </ol> * * <h3 id="rankings">Share target rankings</h3> * * <p>The share action provider retains a ranking for each share target, * based on how often the user chooses each one. The more often a user * chooses a target, the higher its rank; the * most-commonly used target appears in the app bar as the default target.</p> * * <p>By default, the target ranking information is stored in a private * file with the name specified by {@link * #DEFAULT_SHARE_HISTORY_FILE_NAME}. Ordinarily, the share action provider stores * all the history in this single file. However, using a single set of * rankings may not make sense if the * share action provider is used for different kinds of content. For * example, if the activity sometimes shares images and sometimes shares * contacts, you would want to maintain two different sets of rankings.</p> * * <p>To set the history file, call {@link #setShareHistoryFileName * setShareHistoryFileName()} and pass the name of an XML file. The file * you specify is used until the next time you call {@link * #setShareHistoryFileName setShareHistoryFileName()}.</p> * * @see ActionProvider */ public class ShareActionProvider extends ActionProvider { /** * Listener for the event of selecting a share target. */ public interface OnShareTargetSelectedListener { /** * Called when a share target has been selected. The client can * decide whether to perform some action before the sharing is * actually performed. * <p> * <strong>Note:</strong> Modifying the intent is not permitted and * any changes to the latter will be ignored. * </p> * <p> * <strong>Note:</strong> You should <strong>not</strong> handle the * intent here. This callback aims to notify the client that a * sharing is being performed, so the client can update the UI * if necessary. * </p> * * @param source The source of the notification. * @param intent The intent for launching the chosen share target. * @return The return result is ignored. Always return false for consistency. */ boolean onShareTargetSelected(ShareActionProvider source, Intent intent); } /** * The default for the maximal number of activities shown in the sub-menu. */ private static final int DEFAULT_INITIAL_ACTIVITY_COUNT = 4; /** * The the maximum number activities shown in the sub-menu. */ private int mMaxShownActivityCount = DEFAULT_INITIAL_ACTIVITY_COUNT; /** * Listener for handling menu item clicks. */ private final ShareMenuItemOnMenuItemClickListener mOnMenuItemClickListener = new ShareMenuItemOnMenuItemClickListener(); /** * The default name for storing share history. */ public static final String DEFAULT_SHARE_HISTORY_FILE_NAME = "share_history.xml"; /** * Context for accessing resources. */ private final Context mContext; /** * The name of the file with share history data. */ private String mShareHistoryFileName = DEFAULT_SHARE_HISTORY_FILE_NAME; private OnShareTargetSelectedListener mOnShareTargetSelectedListener; private OnChooseActivityListener mOnChooseActivityListener; /** * Creates a new instance. * * @param context Context for accessing resources. */ public ShareActionProvider(Context context) { super(context); mContext = context; } /** * Sets a listener to be notified when a share target has been selected. * The listener can optionally decide to handle the selection and * not rely on the default behavior which is to launch the activity. * <p> * <strong>Note:</strong> If you choose the backing share history file * you will still be notified in this callback. * </p> * @param listener The listener. */ public void setOnShareTargetSelectedListener(OnShareTargetSelectedListener listener) { mOnShareTargetSelectedListener = listener; setActivityChooserPolicyIfNeeded(); } /** * {@inheritDoc} */ @Override public View onCreateActionView() { // Create the view and set its data model. ActivityChooserView activityChooserView = new ActivityChooserView(mContext); if (!activityChooserView.isInEditMode()) { ActivityChooserModel dataModel = ActivityChooserModel.get(mContext, mShareHistoryFileName); activityChooserView.setActivityChooserModel(dataModel); } // Lookup and set the expand action icon. TypedValue outTypedValue = new TypedValue(); mContext.getTheme().resolveAttribute(R.attr.actionModeShareDrawable_ox, outTypedValue, true); Drawable drawable = AppCompatDrawableManager.get().getDrawable(mContext, outTypedValue.resourceId); activityChooserView.setExpandActivityOverflowButtonDrawable(drawable); activityChooserView.setProvider(this); // Set content description. activityChooserView .setDefaultActionButtonContentDescription(R.string.abc_shareactionprovider_share_with_application); activityChooserView .setExpandActivityOverflowButtonContentDescription(R.string.abc_shareactionprovider_share_with); return activityChooserView; } /** * {@inheritDoc} */ @Override public boolean hasSubMenu() { return true; } /** * {@inheritDoc} */ @Override public void onPrepareSubMenu(SubMenu subMenu) { // Clear since the order of items may change. subMenu.clear(); ActivityChooserModel dataModel = ActivityChooserModel.get(mContext, mShareHistoryFileName); PackageManager packageManager = mContext.getPackageManager(); final int expandedActivityCount = dataModel.getActivityCount(); final int collapsedActivityCount = Math.min(expandedActivityCount, mMaxShownActivityCount); // Populate the sub-menu with a sub set of the activities. for (int i = 0; i < collapsedActivityCount; i++) { ResolveInfo activity = dataModel.getActivity(i); subMenu.add(0, i, i, activity.loadLabel(packageManager)).setIcon(activity.loadIcon(packageManager)) .setOnMenuItemClickListener(mOnMenuItemClickListener); } if (collapsedActivityCount < expandedActivityCount) { // Add a sub-menu for showing all activities as a list item. SubMenu expandedSubMenu = subMenu.addSubMenu(Menu.NONE, collapsedActivityCount, collapsedActivityCount, mContext.getString(R.string.abc_activity_chooser_view_see_all)); for (int i = 0; i < expandedActivityCount; i++) { ResolveInfo activity = dataModel.getActivity(i); expandedSubMenu.add(0, i, i, activity.loadLabel(packageManager)) .setIcon(activity.loadIcon(packageManager)) .setOnMenuItemClickListener(mOnMenuItemClickListener); } } } /** * Sets the file name of a file for persisting the share history which * history will be used for ordering share targets. This file will be used * for all view created by {@link #onCreateActionView()}. Defaults to * {@link #DEFAULT_SHARE_HISTORY_FILE_NAME}. Set to <code>null</code> * if share history should not be persisted between sessions. * * <p class="note"> * <strong>Note:</strong> The history file name can be set any time, however * only the action views created by {@link #onCreateActionView()} after setting * the file name will be backed by the provided file. Therefore, if you want to * use different history files for sharing specific types of content, every time * you change the history file with {@link #setShareHistoryFileName(String)} you must * call {@link android.support.v7ox.app.AppCompatActivity#supportInvalidateOptionsMenu()} * to recreate the action view. You should <strong>not</strong> call * {@link android.support.v7ox.app.AppCompatActivity#supportInvalidateOptionsMenu()} from * {@link android.support.v7ox.app.AppCompatActivity#onCreateOptionsMenu(Menu)}. * * <pre> * private void doShare(Intent intent) { * if (IMAGE.equals(intent.getMimeType())) { * mShareActionProvider.setHistoryFileName(SHARE_IMAGE_HISTORY_FILE_NAME); * } else if (TEXT.equals(intent.getMimeType())) { * mShareActionProvider.setHistoryFileName(SHARE_TEXT_HISTORY_FILE_NAME); * } * mShareActionProvider.setIntent(intent); * supportInvalidateOptionsMenu(); * } * </pre> * * @param shareHistoryFile The share history file name. */ public void setShareHistoryFileName(String shareHistoryFile) { mShareHistoryFileName = shareHistoryFile; setActivityChooserPolicyIfNeeded(); } /** * Sets an intent with information about the share action. Here is a * sample for constructing a share intent: * * <pre> * Intent shareIntent = new Intent(Intent.ACTION_SEND); * shareIntent.setType("image/*"); * Uri uri = Uri.fromFile(new File(getFilesDir(), "foo.jpg")); * shareIntent.putExtra(Intent.EXTRA_STREAM, uri.toString()); * </pre> * * @param shareIntent The share intent. * * @see Intent#ACTION_SEND * @see Intent#ACTION_SEND_MULTIPLE */ public void setShareIntent(Intent shareIntent) { if (shareIntent != null) { final String action = shareIntent.getAction(); if (Intent.ACTION_SEND.equals(action) || Intent.ACTION_SEND_MULTIPLE.equals(action)) { updateIntent(shareIntent); } } ActivityChooserModel dataModel = ActivityChooserModel.get(mContext, mShareHistoryFileName); dataModel.setIntent(shareIntent); } /** * Reusable listener for handling share item clicks. */ private class ShareMenuItemOnMenuItemClickListener implements OnMenuItemClickListener { @Override public boolean onMenuItemClick(MenuItem item) { ActivityChooserModel dataModel = ActivityChooserModel.get(mContext, mShareHistoryFileName); final int itemId = item.getItemId(); Intent launchIntent = dataModel.chooseActivity(itemId); if (launchIntent != null) { final String action = launchIntent.getAction(); if (Intent.ACTION_SEND.equals(action) || Intent.ACTION_SEND_MULTIPLE.equals(action)) { updateIntent(launchIntent); } mContext.startActivity(launchIntent); } return true; } } /** * Set the activity chooser policy of the model backed by the current * share history file if needed which is if there is a registered callback. */ private void setActivityChooserPolicyIfNeeded() { if (mOnShareTargetSelectedListener == null) { return; } if (mOnChooseActivityListener == null) { mOnChooseActivityListener = new ShareActivityChooserModelPolicy(); } ActivityChooserModel dataModel = ActivityChooserModel.get(mContext, mShareHistoryFileName); dataModel.setOnChooseActivityListener(mOnChooseActivityListener); } /** * Policy that delegates to the {@link OnShareTargetSelectedListener}, if such. */ private class ShareActivityChooserModelPolicy implements OnChooseActivityListener { @Override public boolean onChooseActivity(ActivityChooserModel host, Intent intent) { if (mOnShareTargetSelectedListener != null) { mOnShareTargetSelectedListener.onShareTargetSelected(ShareActionProvider.this, intent); } return false; } } private void updateIntent(Intent intent) { if (Build.VERSION.SDK_INT >= 21) { // If we're on Lollipop, we can open the intent as a document intent.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT | Intent.FLAG_ACTIVITY_MULTIPLE_TASK); } else { // Else, we will use the old CLEAR_WHEN_TASK_RESET flag intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET); } } }