Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 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 com.actionbarsherlock.widget;
 
This class is a view for choosing an activity for handling a given android.content.Intent.

The view is composed of two adjacent buttons:

  • The left button is an immediate action and allows one click activity choosing. Tapping this button immediately executes the intent without requiring any further user input. Long press on this button shows a popup for changing the default activity.
  • The right button is an overflow action and provides an optimized menu of additional activities. Tapping this button shows a popup anchored to this view, listing the most frequently used activities. This list is initially limited to a small number of items in frequency used order. The last item, "Show all..." serves as an affordance to display all available activities.

Hide:
 
 class ActivityChooserView extends ViewGroup implements ActivityChooserModelClient {

    
An adapter for displaying the activities in an android.widget.AdapterView.
 
     private final ActivityChooserViewAdapter mAdapter;

    
Implementation of various interfaces to avoid publishing them in the APIs.
 
     private final Callbacks mCallbacks;

    
The content of this view.
 
     private final IcsLinearLayout mActivityChooserContent;

    
Stores the background drawable to allow hiding and latter showing.
 
     private final Drawable mActivityChooserContentBackground;

    
The expand activities action button;
 
     private final FrameLayout mExpandActivityOverflowButton;

    
The image for the expand activities action button;
 
     private final ImageView mExpandActivityOverflowButtonImage;

    
The default activities action button;
    private final FrameLayout mDefaultActivityButton;

    
The image for the default activities action button;
    private final ImageView mDefaultActivityButtonImage;

    
The maximal width of the list popup.
    private final int mListPopupMaxWidth;

    
The ActionProvider hosting this view, if applicable.
    ActionProvider mProvider;

    
Observer for the model data.
    private final DataSetObserver mModelDataSetOberver = new DataSetObserver() {
        @Override
        public void onChanged() {
            super.onChanged();
            .notifyDataSetChanged();
        }
        @Override
        public void onInvalidated() {
            super.onInvalidated();
            .notifyDataSetInvalidated();
        }
    };
        @Override
        public void onGlobalLayout() {
            if (isShowingPopup()) {
                if (!isShown()) {
                    getListPopupWindow().dismiss();
                } else {
                    getListPopupWindow().show();
                    if ( != null) {
                        .subUiVisibilityChanged(true);
                    }
                }
            }
        }
    };

    
Popup window for showing the activity overflow list.
    private IcsListPopupWindow mListPopupWindow;

    
Listener for the dismissal of the popup/alert.
Flag whether a default activity currently being selected.
    private boolean mIsSelectingDefaultActivity;

    
The count of activities in the popup.
Flag whether this view is attached to a window.
    private boolean mIsAttachedToWindow;

    
String resource for formatting content description of the default target.
    private final Context mContext;

    
Create a new instance.

Parameters:
context The application environment.
    public ActivityChooserView(Context context) {
        this(contextnull);
    }

    
Create a new instance.

Parameters:
context The application environment.
attrs A collection of attributes.
    public ActivityChooserView(Context contextAttributeSet attrs) {
        this(contextattrs, 0);
    }

    
Create a new instance.

Parameters:
context The application environment.
attrs A collection of attributes.
defStyle The default style to apply to this view.
    public ActivityChooserView(Context contextAttributeSet attrsint defStyle) {
        super(contextattrsdefStyle);
         = context;
        TypedArray attributesArray = context.obtainStyledAttributes(attrs,
                ..defStyle, 0);
         = attributesArray.getInt(
        Drawable expandActivityOverflowButtonDrawable = attributesArray.getDrawable(
        attributesArray.recycle();
        LayoutInflater inflater = LayoutInflater.from();
        inflater.inflate(..thistrue);
         = new Callbacks();
        .setImageDrawable(expandActivityOverflowButtonDrawable);
         = new ActivityChooserViewAdapter();
            @Override
            public void onChanged() {
                super.onChanged();
                updateAppearance();
            }
        });
        Resources resources = context.getResources();
         = Math.max(resources.getDisplayMetrics(). / 2,
              resources.getDimensionPixelSize(..));
    }

    
    public void setActivityChooserModel(ActivityChooserModel dataModel) {
        .setDataModel(dataModel);
        if (isShowingPopup()) {
            dismissPopup();
            showPopup();
        }
    }

    
Sets the background for the button that expands the activity overflow list. Note: Clients would like to set this drawable as a clue about the action the chosen activity will perform. For example, if a share activity is to be chosen the drawable should give a clue that sharing is to be performed.

Parameters:
drawable The drawable.
    public void setExpandActivityOverflowButtonDrawable(Drawable drawable) {
    }

    
Sets the content description for the button that expands the activity overflow list. description as a clue about the action performed by the button. For example, if a share activity is to be chosen the content description should be something like "Share with".

Parameters:
resourceId The content description resource id.
    public void setExpandActivityOverflowButtonContentDescription(int resourceId) {
        CharSequence contentDescription = .getString(resourceId);
    }

    
Set the provider hosting this view, if applicable.

Hide:
Internal use only
    public void setProvider(ActionProvider provider) {
         = provider;
    }

    
Shows the popup window with activities.

Returns:
True if the popup was shown, false if already showing.
    public boolean showPopup() {
        if (isShowingPopup() || !) {
            return false;
        }
         = false;
        return true;
    }

    
Shows the popup no matter if it was already showing.

Parameters:
maxActivityCount The max number of activities to display.
    private void showPopupUnchecked(int maxActivityCount) {
        if (.getDataModel() == null) {
            throw new IllegalStateException("No data model. Did you call #setDataModel?");
        }
        final boolean defaultActivityButtonShown =
            .getVisibility() == ;
        final int activityCount = .getActivityCount();
        final int maxActivityCountOffset = defaultActivityButtonShown ? 1 : 0;
        if (maxActivityCount != .
                && activityCount > maxActivityCount + maxActivityCountOffset) {
            .setShowFooterView(true);
            .setMaxActivityCount(maxActivityCount - 1);
        } else {
            .setShowFooterView(false);
            .setMaxActivityCount(maxActivityCount);
        }
        IcsListPopupWindow popupWindow = getListPopupWindow();
        if (!popupWindow.isShowing()) {
            if ( || !defaultActivityButtonShown) {
                .setShowDefaultActivity(truedefaultActivityButtonShown);
            } else {
                .setShowDefaultActivity(falsefalse);
            }
            final int contentWidth = Math.min(.measureContentWidth(), );
            popupWindow.setContentWidth(contentWidth);
            popupWindow.show();
            if ( != null) {
                .subUiVisibilityChanged(true);
            }
            popupWindow.getListView().setContentDescription(.getString(
                    ..));
        }
    }

    
Dismisses the popup window with activities.

Returns:
True if dismissed, false if already dismissed.
    public boolean dismissPopup() {
        if (isShowingPopup()) {
            getListPopupWindow().dismiss();
            ViewTreeObserver viewTreeObserver = getViewTreeObserver();
            if (viewTreeObserver.isAlive()) {
                viewTreeObserver.removeGlobalOnLayoutListener();
            }
        }
        return true;
    }

    
Gets whether the popup window with activities is shown.

Returns:
True if the popup is shown.
    public boolean isShowingPopup() {
        return getListPopupWindow().isShowing();
    }
    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        ActivityChooserModel dataModel = .getDataModel();
        if (dataModel != null) {
            dataModel.registerObserver();
        }
         = true;
    }
    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        ActivityChooserModel dataModel = .getDataModel();
        if (dataModel != null) {
            try {
                dataModel.unregisterObserver();
            } catch (IllegalStateException e) {
                //Oh, well... fixes issue #557
            }
        }
        ViewTreeObserver viewTreeObserver = getViewTreeObserver();
        if (viewTreeObserver.isAlive()) {
            viewTreeObserver.removeGlobalOnLayoutListener();
        }
         = false;
    }
    @Override
    protected void onMeasure(int widthMeasureSpecint heightMeasureSpec) {
        View child = ;
        // If the default action is not visible we want to be as tall as the
        // ActionBar so if this widget is used in the latter it will look as
        // a normal action button.
        if (.getVisibility() != ) {
            heightMeasureSpec = MeasureSpec.makeMeasureSpec(MeasureSpec.getSize(heightMeasureSpec),
                    .);
        }
        measureChild(childwidthMeasureSpecheightMeasureSpec);
        setMeasuredDimension(child.getMeasuredWidth(), child.getMeasuredHeight());
    }
    @Override
    protected void onLayout(boolean changedint leftint topint rightint bottom) {
        .layout(0, 0, right - leftbottom - top);
        if (getListPopupWindow().isShowing()) {
        } else {
            dismissPopup();
        }
    }
        return .getDataModel();
    }

    
Sets a listener to receive a callback when the popup is dismissed.

Parameters:
listener The listener to be notified.
    public void setOnDismissListener(PopupWindow.OnDismissListener listener) {
         = listener;
    }

    
Sets the initial count of items shown in the activities popup i.e. the items before the popup is expanded. This is an upper bound since it is not guaranteed that such number of intent handlers exist.

Parameters:
itemCount The initial popup item count.
    public void setInitialActivityCount(int itemCount) {
         = itemCount;
    }

    
Sets a content description of the default action button. This resource should be a string taking one formatting argument and will be used for formatting the content description of the button dynamically as the default target changes. For example, a resource pointing to the string "share with %1$s" will result in a content description "share with Bluetooth" for the Bluetooth activity.

Parameters:
resourceId The resource id.
    public void setDefaultActionButtonContentDescription(int resourceId) {
         = resourceId;
    }

    
Gets the list popup window which is lazily initialized.

Returns:
The popup.
        if ( == null) {
             = new IcsListPopupWindow(getContext());
            .setAdapter();
            .setModal(true);
        }
        return ;
    }

    
Updates the buttons state.
    private void updateAppearance() {
        // Expand overflow button.
        if (.getCount() > 0) {
            .setEnabled(true);
        } else {
            .setEnabled(false);
        }
        // Default activity button.
        final int activityCount = .getActivityCount();
        final int historySize = .getHistorySize();
        if (activityCount > 0 && historySize > 0) {
            ResolveInfo activity = .getDefaultActivity();
            PackageManager packageManager = .getPackageManager();
            .setImageDrawable(activity.loadIcon(packageManager));
            if ( != 0) {
                CharSequence label = activity.loadLabel(packageManager);
                String contentDescription = .getString(
                        label);
                .setContentDescription(contentDescription);
            }
        } else {
        }
        // Activity chooser content.
        if (.getVisibility() == ) {
        } else {
            .setBackgroundDrawable(null);
            .setPadding(0, 0, 0, 0);
        }
    }

    
Interface implementation to avoid publishing them in the APIs.
    private class Callbacks implements AdapterView.OnItemClickListener,
        // AdapterView#OnItemClickListener
        public void onItemClick(AdapterView<?> parentView viewint positionlong id) {
            ActivityChooserViewAdapter adapter = (ActivityChooserViewAdapterparent.getAdapter();
            final int itemViewType = adapter.getItemViewType(position);
            switch (itemViewType) {
                case .: {
                } break;
                case .: {
                    dismissPopup();
                    if () {
                        // The item at position zero is the default already.
                        if (position > 0) {
                            .getDataModel().setDefaultActivity(position);
                        }
                    } else {
                        // If the default target is not shown in the list, the first
                        // item in the model is default action => adjust index
                        position = .getShowDefaultActivity() ? position : position + 1;
                        Intent launchIntent = .getDataModel().chooseActivity(position);
                        if (launchIntent != null) {
                            .startActivity(launchIntent);
                        }
                    }
                } break;
                default:
                    throw new IllegalArgumentException();
            }
        }
        // View.OnClickListener
        public void onClick(View view) {
            if (view == ) {
                dismissPopup();
                ResolveInfo defaultActivity = .getDefaultActivity();
                final int index = .getDataModel().getActivityIndex(defaultActivity);
                Intent launchIntent = .getDataModel().chooseActivity(index);
                if (launchIntent != null) {
                    .startActivity(launchIntent);
                }
            } else if (view == ) {
                 = false;
                showPopupUnchecked();
            } else {
                throw new IllegalArgumentException();
            }
        }
        // OnLongClickListener#onLongClick
        @Override
        public boolean onLongClick(View view) {
            if (view == ) {
                if (.getCount() > 0) {
                     = true;
                    showPopupUnchecked();
                }
            } else {
                throw new IllegalArgumentException();
            }
            return true;
        }
        // PopUpWindow.OnDismissListener#onDismiss
        public void onDismiss() {
            notifyOnDismissListener();
            if ( != null) {
                .subUiVisibilityChanged(false);
            }
        }
        private void notifyOnDismissListener() {
            if ( != null) {
                .onDismiss();
            }
        }
    }
    private static class SetActivated {
        public static void invoke(View viewboolean activated) {
            view.setActivated(activated);
        }
    }
    private static final boolean IS_HONEYCOMB = .. >= ..;

    
Adapter for backing the list of activities shown in the popup.
    private class ActivityChooserViewAdapter extends BaseAdapter {
        public static final int MAX_ACTIVITY_COUNT_UNLIMITED = .;
        public static final int MAX_ACTIVITY_COUNT_DEFAULT = 4;
        private static final int ITEM_VIEW_TYPE_ACTIVITY = 0;
        private static final int ITEM_VIEW_TYPE_FOOTER = 1;
        private static final int ITEM_VIEW_TYPE_COUNT = 3;
        private ActivityChooserModel mDataModel;
        private int mMaxActivityCount = ;
        private boolean mShowDefaultActivity;
        private boolean mHighlightDefaultActivity;
        private boolean mShowFooterView;
        public void setDataModel(ActivityChooserModel dataModel) {
            ActivityChooserModel oldDataModel = .getDataModel();
            if (oldDataModel != null && isShown()) {
                try {
                    oldDataModel.unregisterObserver();
                } catch (IllegalStateException e) {
                    //Oh, well... fixes issue #557
                }
            }
             = dataModel;
            if (dataModel != null && isShown()) {
                dataModel.registerObserver();
            }
            notifyDataSetChanged();
        }
        @Override
        public int getItemViewType(int position) {
            if ( && position == getCount() - 1) {
                return ;
            } else {
                return ;
            }
        }
        @Override
        public int getViewTypeCount() {
            return ;
        }
        public int getCount() {
            int count = 0;
            int activityCount = .getActivityCount();
            if (! && .getDefaultActivity() != null) {
                activityCount--;
            }
            count = Math.min(activityCount);
            if () {
                count++;
            }
            return count;
        }
        public Object getItem(int position) {
            final int itemViewType = getItemViewType(position);
            switch (itemViewType) {
                case :
                    return null;
                case :
                    if (! && .getDefaultActivity() != null) {
                        position++;
                    }
                    return .getActivity(position);
                default:
                    throw new IllegalArgumentException();
            }
        }
        public long getItemId(int position) {
            return position;
        }
        public View getView(int positionView convertViewViewGroup parent) {
            final int itemViewType = getItemViewType(position);
            switch (itemViewType) {
                case :
                    if (convertView == null || convertView.getId() != ) {
                        convertView = LayoutInflater.from(getContext()).inflate(
                                ..parentfalse);
                        convertView.setId();
                        TextView titleView = (TextViewconvertView.findViewById(..);
                        titleView.setText(.getString(
                                ..));
                    }
                    return convertView;
                case :
                    if (convertView == null || convertView.getId() != ..) {
                        convertView = LayoutInflater.from(getContext()).inflate(
                                ..parentfalse);
                    }
                    PackageManager packageManager = .getPackageManager();
                    // Set the icon
                    ImageView iconView = (ImageViewconvertView.findViewById(..);
                    ResolveInfo activity = (ResolveInfogetItem(position);
                    iconView.setImageDrawable(activity.loadIcon(packageManager));
                    // Set the title.
                    TextView titleView = (TextViewconvertView.findViewById(..);
                    titleView.setText(activity.loadLabel(packageManager));
                    if () {
                        // Highlight the default.
                        if ( && position == 0 && ) {
                            SetActivated.invoke(convertViewtrue);
                        } else {
                            SetActivated.invoke(convertViewfalse);
                        }
                    }
                    return convertView;
                default:
                    throw new IllegalArgumentException();
            }
        }
        public int measureContentWidth() {
            // The user may have specified some of the target not to be shown but we
            // want to measure all of them since after expansion they should fit.
            final int oldMaxActivityCount = ;
            int contentWidth = 0;
            View itemView = null;
            final int widthMeasureSpec = MeasureSpec.makeMeasureSpec(0, .);
            final int heightMeasureSpec = MeasureSpec.makeMeasureSpec(0, .);
            final int count = getCount();
            for (int i = 0; i < counti++) {
                itemView = getView(iitemViewnull);
                itemView.measure(widthMeasureSpecheightMeasureSpec);
                contentWidth = Math.max(contentWidthitemView.getMeasuredWidth());
            }
             = oldMaxActivityCount;
            return contentWidth;
        }
        public void setMaxActivityCount(int maxActivityCount) {
            if ( != maxActivityCount) {
                 = maxActivityCount;
                notifyDataSetChanged();
            }
        }
        public ResolveInfo getDefaultActivity() {
            return .getDefaultActivity();
        }
        public void setShowFooterView(boolean showFooterView) {
            if ( != showFooterView) {
                 = showFooterView;
                notifyDataSetChanged();
            }
        }
        public int getActivityCount() {
            return .getActivityCount();
        }
        public int getHistorySize() {
            return .getHistorySize();
        }
        public int getMaxActivityCount() {
            return ;
        }
        public ActivityChooserModel getDataModel() {
            return ;
        }
        public void setShowDefaultActivity(boolean showDefaultActivity,
                boolean highlightDefaultActivity) {
            if ( != showDefaultActivity
                    ||  != highlightDefaultActivity) {
                 = showDefaultActivity;
                 = highlightDefaultActivity;
                notifyDataSetChanged();
            }
        }
        public boolean getShowDefaultActivity() {
            return ;
        }
    }