ChooserActivity.java revision 6ef8578ef44a69a391861e1103cee0ca9b745775 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.internal.app;
18
19import android.animation.ObjectAnimator;
20import android.annotation.NonNull;
21import android.app.Activity;
22import android.content.ComponentName;
23import android.content.Context;
24import android.content.Intent;
25import android.content.IntentSender;
26import android.content.IntentSender.SendIntentException;
27import android.content.ServiceConnection;
28import android.content.pm.ActivityInfo;
29import android.content.pm.LabeledIntent;
30import android.content.pm.PackageManager;
31import android.content.pm.PackageManager.NameNotFoundException;
32import android.content.pm.ResolveInfo;
33import android.database.DataSetObserver;
34import android.graphics.Color;
35import android.graphics.drawable.Drawable;
36import android.graphics.drawable.Icon;
37import android.os.Bundle;
38import android.os.Handler;
39import android.os.IBinder;
40import android.os.Message;
41import android.os.Parcelable;
42import android.os.RemoteException;
43import android.os.ResultReceiver;
44import android.os.UserHandle;
45import android.os.UserManager;
46import android.service.chooser.ChooserTarget;
47import android.service.chooser.ChooserTargetService;
48import android.service.chooser.IChooserTargetResult;
49import android.service.chooser.IChooserTargetService;
50import android.text.TextUtils;
51import android.util.FloatProperty;
52import android.util.Log;
53import android.util.Slog;
54import android.view.LayoutInflater;
55import android.view.View;
56import android.view.View.MeasureSpec;
57import android.view.View.OnClickListener;
58import android.view.View.OnLongClickListener;
59import android.view.ViewGroup;
60import android.view.ViewGroup.LayoutParams;
61import android.view.animation.AnimationUtils;
62import android.view.animation.Interpolator;
63import android.widget.AbsListView;
64import android.widget.BaseAdapter;
65import android.widget.ListView;
66import com.android.internal.R;
67import com.android.internal.logging.MetricsLogger;
68
69import java.util.ArrayList;
70import java.util.Collections;
71import java.util.Comparator;
72import java.util.List;
73
74public class ChooserActivity extends ResolverActivity {
75    private static final String TAG = "ChooserActivity";
76
77    private static final boolean DEBUG = false;
78
79    private static final int QUERY_TARGET_SERVICE_LIMIT = 5;
80    private static final int WATCHDOG_TIMEOUT_MILLIS = 5000;
81
82    private Bundle mReplacementExtras;
83    private IntentSender mChosenComponentSender;
84    private IntentSender mRefinementIntentSender;
85    private RefinementResultReceiver mRefinementResultReceiver;
86
87    private Intent mReferrerFillInIntent;
88
89    private ChooserListAdapter mChooserListAdapter;
90    private ChooserRowAdapter mChooserRowAdapter;
91
92    private final List<ChooserTargetServiceConnection> mServiceConnections = new ArrayList<>();
93
94    private static final int CHOOSER_TARGET_SERVICE_RESULT = 1;
95    private static final int CHOOSER_TARGET_SERVICE_WATCHDOG_TIMEOUT = 2;
96
97    private final Handler mChooserHandler = new Handler() {
98        @Override
99        public void handleMessage(Message msg) {
100            switch (msg.what) {
101                case CHOOSER_TARGET_SERVICE_RESULT:
102                    if (DEBUG) Log.d(TAG, "CHOOSER_TARGET_SERVICE_RESULT");
103                    if (isDestroyed()) break;
104                    final ServiceResultInfo sri = (ServiceResultInfo) msg.obj;
105                    if (!mServiceConnections.contains(sri.connection)) {
106                        Log.w(TAG, "ChooserTargetServiceConnection " + sri.connection
107                                + " returned after being removed from active connections."
108                                + " Have you considered returning results faster?");
109                        break;
110                    }
111                    if (sri.resultTargets != null) {
112                        mChooserListAdapter.addServiceResults(sri.originalTarget,
113                                sri.resultTargets);
114                    }
115                    unbindService(sri.connection);
116                    sri.connection.destroy();
117                    mServiceConnections.remove(sri.connection);
118                    if (mServiceConnections.isEmpty()) {
119                        mChooserHandler.removeMessages(CHOOSER_TARGET_SERVICE_WATCHDOG_TIMEOUT);
120                        sendVoiceChoicesIfNeeded();
121                    }
122                    break;
123
124                case CHOOSER_TARGET_SERVICE_WATCHDOG_TIMEOUT:
125                    if (DEBUG) {
126                        Log.d(TAG, "CHOOSER_TARGET_SERVICE_WATCHDOG_TIMEOUT; unbinding services");
127                    }
128                    unbindRemainingServices();
129                    sendVoiceChoicesIfNeeded();
130                    break;
131
132                default:
133                    super.handleMessage(msg);
134            }
135        }
136    };
137
138    @Override
139    protected void onCreate(Bundle savedInstanceState) {
140        Intent intent = getIntent();
141        Parcelable targetParcelable = intent.getParcelableExtra(Intent.EXTRA_INTENT);
142        if (!(targetParcelable instanceof Intent)) {
143            Log.w("ChooserActivity", "Target is not an intent: " + targetParcelable);
144            finish();
145            super.onCreate(null);
146            return;
147        }
148        Intent target = (Intent) targetParcelable;
149        if (target != null) {
150            modifyTargetIntent(target);
151        }
152        Parcelable[] targetsParcelable
153                = intent.getParcelableArrayExtra(Intent.EXTRA_ALTERNATE_INTENTS);
154        if (targetsParcelable != null) {
155            final boolean offset = target == null;
156            Intent[] additionalTargets =
157                    new Intent[offset ? targetsParcelable.length - 1 : targetsParcelable.length];
158            for (int i = 0; i < targetsParcelable.length; i++) {
159                if (!(targetsParcelable[i] instanceof Intent)) {
160                    Log.w(TAG, "EXTRA_ALTERNATE_INTENTS array entry #" + i + " is not an Intent: "
161                            + targetsParcelable[i]);
162                    finish();
163                    super.onCreate(null);
164                    return;
165                }
166                final Intent additionalTarget = (Intent) targetsParcelable[i];
167                if (i == 0 && target == null) {
168                    target = additionalTarget;
169                    modifyTargetIntent(target);
170                } else {
171                    additionalTargets[offset ? i - 1 : i] = additionalTarget;
172                    modifyTargetIntent(additionalTarget);
173                }
174            }
175            setAdditionalTargets(additionalTargets);
176        }
177
178        mReplacementExtras = intent.getBundleExtra(Intent.EXTRA_REPLACEMENT_EXTRAS);
179        CharSequence title = intent.getCharSequenceExtra(Intent.EXTRA_TITLE);
180        int defaultTitleRes = 0;
181        if (title == null) {
182            defaultTitleRes = com.android.internal.R.string.chooseActivity;
183        }
184        Parcelable[] pa = intent.getParcelableArrayExtra(Intent.EXTRA_INITIAL_INTENTS);
185        Intent[] initialIntents = null;
186        if (pa != null) {
187            initialIntents = new Intent[pa.length];
188            for (int i=0; i<pa.length; i++) {
189                if (!(pa[i] instanceof Intent)) {
190                    Log.w(TAG, "Initial intent #" + i + " not an Intent: " + pa[i]);
191                    finish();
192                    super.onCreate(null);
193                    return;
194                }
195                final Intent in = (Intent) pa[i];
196                modifyTargetIntent(in);
197                initialIntents[i] = in;
198            }
199        }
200
201        mReferrerFillInIntent = new Intent().putExtra(Intent.EXTRA_REFERRER, getReferrer());
202
203        mChosenComponentSender = intent.getParcelableExtra(
204                Intent.EXTRA_CHOSEN_COMPONENT_INTENT_SENDER);
205        mRefinementIntentSender = intent.getParcelableExtra(
206                Intent.EXTRA_CHOOSER_REFINEMENT_INTENT_SENDER);
207        setSafeForwardingMode(true);
208        super.onCreate(savedInstanceState, target, title, defaultTitleRes, initialIntents,
209                null, false);
210
211        MetricsLogger.action(this, MetricsLogger.ACTION_ACTIVITY_CHOOSER_SHOWN);
212    }
213
214    @Override
215    protected void onDestroy() {
216        super.onDestroy();
217        if (mRefinementResultReceiver != null) {
218            mRefinementResultReceiver.destroy();
219            mRefinementResultReceiver = null;
220        }
221        unbindRemainingServices();
222        mChooserHandler.removeMessages(CHOOSER_TARGET_SERVICE_RESULT);
223    }
224
225    @Override
226    public Intent getReplacementIntent(ActivityInfo aInfo, Intent defIntent) {
227        Intent result = defIntent;
228        if (mReplacementExtras != null) {
229            final Bundle replExtras = mReplacementExtras.getBundle(aInfo.packageName);
230            if (replExtras != null) {
231                result = new Intent(defIntent);
232                result.putExtras(replExtras);
233            }
234        }
235        if (aInfo.name.equals(IntentForwarderActivity.FORWARD_INTENT_TO_USER_OWNER)
236                || aInfo.name.equals(IntentForwarderActivity.FORWARD_INTENT_TO_MANAGED_PROFILE)) {
237            result = Intent.createChooser(result,
238                    getIntent().getCharSequenceExtra(Intent.EXTRA_TITLE));
239        }
240        return result;
241    }
242
243    @Override
244    void onActivityStarted(TargetInfo cti) {
245        if (mChosenComponentSender != null) {
246            final ComponentName target = cti.getResolvedComponentName();
247            if (target != null) {
248                final Intent fillIn = new Intent().putExtra(Intent.EXTRA_CHOSEN_COMPONENT, target);
249                try {
250                    mChosenComponentSender.sendIntent(this, Activity.RESULT_OK, fillIn, null, null);
251                } catch (IntentSender.SendIntentException e) {
252                    Slog.e(TAG, "Unable to launch supplied IntentSender to report "
253                            + "the chosen component: " + e);
254                }
255            }
256        }
257    }
258
259    @Override
260    void onPrepareAdapterView(AbsListView adapterView, ResolveListAdapter adapter,
261            boolean alwaysUseOption) {
262        final ListView listView = adapterView instanceof ListView ? (ListView) adapterView : null;
263        mChooserListAdapter = (ChooserListAdapter) adapter;
264        mChooserRowAdapter = new ChooserRowAdapter(mChooserListAdapter);
265        mChooserRowAdapter.registerDataSetObserver(new OffsetDataSetObserver(adapterView));
266        adapterView.setAdapter(mChooserRowAdapter);
267        if (listView != null) {
268            listView.setItemsCanFocus(true);
269        }
270    }
271
272    @Override
273    int getLayoutResource() {
274        return R.layout.chooser_grid;
275    }
276
277    @Override
278    boolean shouldGetActivityMetadata() {
279        return true;
280    }
281
282    @Override
283    boolean shouldAutoLaunchSingleChoice() {
284        return false;
285    }
286
287    private void modifyTargetIntent(Intent in) {
288        final String action = in.getAction();
289        if (Intent.ACTION_SEND.equals(action) ||
290                Intent.ACTION_SEND_MULTIPLE.equals(action)) {
291            in.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT |
292                    Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
293        }
294    }
295
296    @Override
297    protected boolean onTargetSelected(TargetInfo target, boolean alwaysCheck) {
298        if (mRefinementIntentSender != null) {
299            final Intent fillIn = new Intent();
300            final List<Intent> sourceIntents = target.getAllSourceIntents();
301            if (!sourceIntents.isEmpty()) {
302                fillIn.putExtra(Intent.EXTRA_INTENT, sourceIntents.get(0));
303                if (sourceIntents.size() > 1) {
304                    final Intent[] alts = new Intent[sourceIntents.size() - 1];
305                    for (int i = 1, N = sourceIntents.size(); i < N; i++) {
306                        alts[i - 1] = sourceIntents.get(i);
307                    }
308                    fillIn.putExtra(Intent.EXTRA_ALTERNATE_INTENTS, alts);
309                }
310                if (mRefinementResultReceiver != null) {
311                    mRefinementResultReceiver.destroy();
312                }
313                mRefinementResultReceiver = new RefinementResultReceiver(this, target, null);
314                fillIn.putExtra(Intent.EXTRA_RESULT_RECEIVER,
315                        mRefinementResultReceiver);
316                try {
317                    mRefinementIntentSender.sendIntent(this, 0, fillIn, null, null);
318                    return false;
319                } catch (SendIntentException e) {
320                    Log.e(TAG, "Refinement IntentSender failed to send", e);
321                }
322            }
323        }
324        return super.onTargetSelected(target, alwaysCheck);
325    }
326
327    @Override
328    void startSelected(int which, boolean always, boolean filtered) {
329        super.startSelected(which, always, filtered);
330
331        if (mChooserListAdapter != null) {
332            // Log the index of which type of target the user picked.
333            // Lower values mean the ranking was better.
334            int cat = 0;
335            int value = which;
336            switch (mChooserListAdapter.getPositionTargetType(which)) {
337                case ChooserListAdapter.TARGET_CALLER:
338                    cat = MetricsLogger.ACTION_ACTIVITY_CHOOSER_PICKED_APP_TARGET;
339                    break;
340                case ChooserListAdapter.TARGET_SERVICE:
341                    cat = MetricsLogger.ACTION_ACTIVITY_CHOOSER_PICKED_SERVICE_TARGET;
342                    value -= mChooserListAdapter.getCallerTargetCount();
343                    break;
344                case ChooserListAdapter.TARGET_STANDARD:
345                    cat = MetricsLogger.ACTION_ACTIVITY_CHOOSER_PICKED_STANDARD_TARGET;
346                    value -= mChooserListAdapter.getCallerTargetCount()
347                            + mChooserListAdapter.getServiceTargetCount();
348                    break;
349            }
350
351            if (cat != 0) {
352                MetricsLogger.action(this, cat, value);
353            }
354        }
355    }
356
357    void queryTargetServices(ChooserListAdapter adapter) {
358        final PackageManager pm = getPackageManager();
359        int targetsToQuery = 0;
360        for (int i = 0, N = adapter.getDisplayResolveInfoCount(); i < N; i++) {
361            final DisplayResolveInfo dri = adapter.getDisplayResolveInfo(i);
362            final ActivityInfo ai = dri.getResolveInfo().activityInfo;
363            final Bundle md = ai.metaData;
364            final String serviceName = md != null ? convertServiceName(ai.packageName,
365                    md.getString(ChooserTargetService.META_DATA_NAME)) : null;
366            if (serviceName != null) {
367                final ComponentName serviceComponent = new ComponentName(
368                        ai.packageName, serviceName);
369                final Intent serviceIntent = new Intent(ChooserTargetService.SERVICE_INTERFACE)
370                        .setComponent(serviceComponent);
371
372                if (DEBUG) {
373                    Log.d(TAG, "queryTargets found target with service " + serviceComponent);
374                }
375
376                try {
377                    final String perm = pm.getServiceInfo(serviceComponent, 0).permission;
378                    if (!ChooserTargetService.BIND_PERMISSION.equals(perm)) {
379                        Log.w(TAG, "ChooserTargetService " + serviceComponent + " does not require"
380                                + " permission " + ChooserTargetService.BIND_PERMISSION
381                                + " - this service will not be queried for ChooserTargets."
382                                + " add android:permission=\""
383                                + ChooserTargetService.BIND_PERMISSION + "\""
384                                + " to the <service> tag for " + serviceComponent
385                                + " in the manifest.");
386                        continue;
387                    }
388                } catch (NameNotFoundException e) {
389                    Log.e(TAG, "Could not look up service " + serviceComponent, e);
390                    continue;
391                }
392
393                final ChooserTargetServiceConnection conn =
394                        new ChooserTargetServiceConnection(this, dri);
395                if (bindServiceAsUser(serviceIntent, conn, BIND_AUTO_CREATE | BIND_NOT_FOREGROUND,
396                        UserHandle.CURRENT)) {
397                    if (DEBUG) {
398                        Log.d(TAG, "Binding service connection for target " + dri
399                                + " intent " + serviceIntent);
400                    }
401                    mServiceConnections.add(conn);
402                    targetsToQuery++;
403                }
404            }
405            if (targetsToQuery >= QUERY_TARGET_SERVICE_LIMIT) {
406                if (DEBUG) Log.d(TAG, "queryTargets hit query target limit "
407                        + QUERY_TARGET_SERVICE_LIMIT);
408                break;
409            }
410        }
411
412        if (!mServiceConnections.isEmpty()) {
413            if (DEBUG) Log.d(TAG, "queryTargets setting watchdog timer for "
414                    + WATCHDOG_TIMEOUT_MILLIS + "ms");
415            mChooserHandler.sendEmptyMessageDelayed(CHOOSER_TARGET_SERVICE_WATCHDOG_TIMEOUT,
416                    WATCHDOG_TIMEOUT_MILLIS);
417        } else {
418            sendVoiceChoicesIfNeeded();
419        }
420    }
421
422    private String convertServiceName(String packageName, String serviceName) {
423        if (TextUtils.isEmpty(serviceName)) {
424            return null;
425        }
426
427        final String fullName;
428        if (serviceName.startsWith(".")) {
429            // Relative to the app package. Prepend the app package name.
430            fullName = packageName + serviceName;
431        } else if (serviceName.indexOf('.') >= 0) {
432            // Fully qualified package name.
433            fullName = serviceName;
434        } else {
435            fullName = null;
436        }
437        return fullName;
438    }
439
440    void unbindRemainingServices() {
441        if (DEBUG) {
442            Log.d(TAG, "unbindRemainingServices, " + mServiceConnections.size() + " left");
443        }
444        for (int i = 0, N = mServiceConnections.size(); i < N; i++) {
445            final ChooserTargetServiceConnection conn = mServiceConnections.get(i);
446            if (DEBUG) Log.d(TAG, "unbinding " + conn);
447            unbindService(conn);
448            conn.destroy();
449        }
450        mServiceConnections.clear();
451        mChooserHandler.removeMessages(CHOOSER_TARGET_SERVICE_WATCHDOG_TIMEOUT);
452    }
453
454    void onSetupVoiceInteraction() {
455        // Do nothing. We'll send the voice stuff ourselves.
456    }
457
458    void onRefinementResult(TargetInfo selectedTarget, Intent matchingIntent) {
459        if (mRefinementResultReceiver != null) {
460            mRefinementResultReceiver.destroy();
461            mRefinementResultReceiver = null;
462        }
463
464        if (selectedTarget == null) {
465            Log.e(TAG, "Refinement result intent did not match any known targets; canceling");
466        } else if (!checkTargetSourceIntent(selectedTarget, matchingIntent)) {
467            Log.e(TAG, "onRefinementResult: Selected target " + selectedTarget
468                    + " cannot match refined source intent " + matchingIntent);
469        } else if (super.onTargetSelected(selectedTarget.cloneFilledIn(matchingIntent, 0), false)) {
470            finish();
471            return;
472        }
473        onRefinementCanceled();
474    }
475
476    void onRefinementCanceled() {
477        if (mRefinementResultReceiver != null) {
478            mRefinementResultReceiver.destroy();
479            mRefinementResultReceiver = null;
480        }
481        finish();
482    }
483
484    boolean checkTargetSourceIntent(TargetInfo target, Intent matchingIntent) {
485        final List<Intent> targetIntents = target.getAllSourceIntents();
486        for (int i = 0, N = targetIntents.size(); i < N; i++) {
487            final Intent targetIntent = targetIntents.get(i);
488            if (targetIntent.filterEquals(matchingIntent)) {
489                return true;
490            }
491        }
492        return false;
493    }
494
495    void filterServiceTargets(String packageName, List<ChooserTarget> targets) {
496        if (targets == null) {
497            return;
498        }
499
500        final PackageManager pm = getPackageManager();
501        for (int i = targets.size() - 1; i >= 0; i--) {
502            final ChooserTarget target = targets.get(i);
503            final ComponentName targetName = target.getComponentName();
504            if (packageName != null && packageName.equals(targetName.getPackageName())) {
505                // Anything from the original target's package is fine.
506                continue;
507            }
508
509            boolean remove;
510            try {
511                final ActivityInfo ai = pm.getActivityInfo(targetName, 0);
512                remove = !ai.exported || ai.permission != null;
513            } catch (NameNotFoundException e) {
514                Log.e(TAG, "Target " + target + " returned by " + packageName
515                        + " component not found");
516                remove = true;
517            }
518
519            if (remove) {
520                targets.remove(i);
521            }
522        }
523    }
524
525    @Override
526    ResolveListAdapter createAdapter(Context context, List<Intent> payloadIntents,
527            Intent[] initialIntents, List<ResolveInfo> rList, int launchedFromUid,
528            boolean filterLastUsed) {
529        final ChooserListAdapter adapter = new ChooserListAdapter(context, payloadIntents,
530                initialIntents, rList, launchedFromUid, filterLastUsed);
531        if (DEBUG) Log.d(TAG, "Adapter created; querying services");
532        queryTargetServices(adapter);
533        return adapter;
534    }
535
536    final class ChooserTargetInfo implements TargetInfo {
537        private final DisplayResolveInfo mSourceInfo;
538        private final ResolveInfo mBackupResolveInfo;
539        private final ChooserTarget mChooserTarget;
540        private Drawable mBadgeIcon = null;
541        private CharSequence mBadgeContentDescription;
542        private Drawable mDisplayIcon;
543        private final Intent mFillInIntent;
544        private final int mFillInFlags;
545        private final float mModifiedScore;
546
547        public ChooserTargetInfo(DisplayResolveInfo sourceInfo, ChooserTarget chooserTarget,
548                float modifiedScore) {
549            mSourceInfo = sourceInfo;
550            mChooserTarget = chooserTarget;
551            mModifiedScore = modifiedScore;
552            if (sourceInfo != null) {
553                final ResolveInfo ri = sourceInfo.getResolveInfo();
554                if (ri != null) {
555                    final ActivityInfo ai = ri.activityInfo;
556                    if (ai != null && ai.applicationInfo != null) {
557                        final PackageManager pm = getPackageManager();
558                        mBadgeIcon = pm.getApplicationIcon(ai.applicationInfo);
559                        mBadgeContentDescription = pm.getApplicationLabel(ai.applicationInfo);
560                    }
561                }
562            }
563            final Icon icon = chooserTarget.getIcon();
564            // TODO do this in the background
565            mDisplayIcon = icon != null ? icon.loadDrawable(ChooserActivity.this) : null;
566
567            if (sourceInfo != null) {
568                mBackupResolveInfo = null;
569            } else {
570                mBackupResolveInfo = getPackageManager().resolveActivity(getResolvedIntent(), 0);
571            }
572
573            mFillInIntent = null;
574            mFillInFlags = 0;
575        }
576
577        private ChooserTargetInfo(ChooserTargetInfo other, Intent fillInIntent, int flags) {
578            mSourceInfo = other.mSourceInfo;
579            mBackupResolveInfo = other.mBackupResolveInfo;
580            mChooserTarget = other.mChooserTarget;
581            mBadgeIcon = other.mBadgeIcon;
582            mBadgeContentDescription = other.mBadgeContentDescription;
583            mDisplayIcon = other.mDisplayIcon;
584            mFillInIntent = fillInIntent;
585            mFillInFlags = flags;
586            mModifiedScore = other.mModifiedScore;
587        }
588
589        public float getModifiedScore() {
590            return mModifiedScore;
591        }
592
593        @Override
594        public Intent getResolvedIntent() {
595            if (mSourceInfo != null) {
596                return mSourceInfo.getResolvedIntent();
597            }
598            return getTargetIntent();
599        }
600
601        @Override
602        public ComponentName getResolvedComponentName() {
603            if (mSourceInfo != null) {
604                return mSourceInfo.getResolvedComponentName();
605            } else if (mBackupResolveInfo != null) {
606                return new ComponentName(mBackupResolveInfo.activityInfo.packageName,
607                        mBackupResolveInfo.activityInfo.name);
608            }
609            return null;
610        }
611
612        private Intent getBaseIntentToSend() {
613            Intent result = mSourceInfo != null
614                    ? mSourceInfo.getResolvedIntent() : getTargetIntent();
615            if (result == null) {
616                Log.e(TAG, "ChooserTargetInfo: no base intent available to send");
617            } else {
618                result = new Intent(result);
619                if (mFillInIntent != null) {
620                    result.fillIn(mFillInIntent, mFillInFlags);
621                }
622                result.fillIn(mReferrerFillInIntent, 0);
623            }
624            return result;
625        }
626
627        @Override
628        public boolean start(Activity activity, Bundle options) {
629            throw new RuntimeException("ChooserTargets should be started as caller.");
630        }
631
632        @Override
633        public boolean startAsCaller(Activity activity, Bundle options, int userId) {
634            final Intent intent = getBaseIntentToSend();
635            if (intent == null) {
636                return false;
637            }
638            intent.setComponent(mChooserTarget.getComponentName());
639            intent.putExtras(mChooserTarget.getIntentExtras());
640            activity.startActivityAsCaller(intent, options, true, userId);
641            return true;
642        }
643
644        @Override
645        public boolean startAsUser(Activity activity, Bundle options, UserHandle user) {
646            throw new RuntimeException("ChooserTargets should be started as caller.");
647        }
648
649        @Override
650        public ResolveInfo getResolveInfo() {
651            return mSourceInfo != null ? mSourceInfo.getResolveInfo() : mBackupResolveInfo;
652        }
653
654        @Override
655        public CharSequence getDisplayLabel() {
656            return mChooserTarget.getTitle();
657        }
658
659        @Override
660        public CharSequence getExtendedInfo() {
661            // ChooserTargets have badge icons, so we won't show the extended info to disambiguate.
662            return null;
663        }
664
665        @Override
666        public Drawable getDisplayIcon() {
667            return mDisplayIcon;
668        }
669
670        @Override
671        public Drawable getBadgeIcon() {
672            return mBadgeIcon;
673        }
674
675        @Override
676        public CharSequence getBadgeContentDescription() {
677            return mBadgeContentDescription;
678        }
679
680        @Override
681        public TargetInfo cloneFilledIn(Intent fillInIntent, int flags) {
682            return new ChooserTargetInfo(this, fillInIntent, flags);
683        }
684
685        @Override
686        public List<Intent> getAllSourceIntents() {
687            final List<Intent> results = new ArrayList<>();
688            if (mSourceInfo != null) {
689                // We only queried the service for the first one in our sourceinfo.
690                results.add(mSourceInfo.getAllSourceIntents().get(0));
691            }
692            return results;
693        }
694    }
695
696    public class ChooserListAdapter extends ResolveListAdapter {
697        public static final int TARGET_BAD = -1;
698        public static final int TARGET_CALLER = 0;
699        public static final int TARGET_SERVICE = 1;
700        public static final int TARGET_STANDARD = 2;
701
702        private static final int MAX_SERVICE_TARGETS = 8;
703
704        private final List<ChooserTargetInfo> mServiceTargets = new ArrayList<>();
705        private final List<TargetInfo> mCallerTargets = new ArrayList<>();
706
707        private float mLateFee = 1.f;
708
709        private final BaseChooserTargetComparator mBaseTargetComparator
710                = new BaseChooserTargetComparator();
711
712        public ChooserListAdapter(Context context, List<Intent> payloadIntents,
713                Intent[] initialIntents, List<ResolveInfo> rList, int launchedFromUid,
714                boolean filterLastUsed) {
715            // Don't send the initial intents through the shared ResolverActivity path,
716            // we want to separate them into a different section.
717            super(context, payloadIntents, null, rList, launchedFromUid, filterLastUsed);
718
719            if (initialIntents != null) {
720                final PackageManager pm = getPackageManager();
721                for (int i = 0; i < initialIntents.length; i++) {
722                    final Intent ii = initialIntents[i];
723                    if (ii == null) {
724                        continue;
725                    }
726                    final ActivityInfo ai = ii.resolveActivityInfo(pm, 0);
727                    if (ai == null) {
728                        Log.w(TAG, "No activity found for " + ii);
729                        continue;
730                    }
731                    ResolveInfo ri = new ResolveInfo();
732                    ri.activityInfo = ai;
733                    UserManager userManager =
734                            (UserManager) getSystemService(Context.USER_SERVICE);
735                    if (ii instanceof LabeledIntent) {
736                        LabeledIntent li = (LabeledIntent)ii;
737                        ri.resolvePackageName = li.getSourcePackage();
738                        ri.labelRes = li.getLabelResource();
739                        ri.nonLocalizedLabel = li.getNonLocalizedLabel();
740                        ri.icon = li.getIconResource();
741                        ri.iconResourceId = ri.icon;
742                    }
743                    if (userManager.isManagedProfile()) {
744                        ri.noResourceId = true;
745                        ri.icon = 0;
746                    }
747                    mCallerTargets.add(new DisplayResolveInfo(ii, ri,
748                            ri.loadLabel(pm), null, ii));
749                }
750            }
751        }
752
753        @Override
754        public boolean showsExtendedInfo(TargetInfo info) {
755            // We have badges so we don't need this text shown.
756            return false;
757        }
758
759        @Override
760        public View onCreateView(ViewGroup parent) {
761            return mInflater.inflate(
762                    com.android.internal.R.layout.resolve_grid_item, parent, false);
763        }
764
765        @Override
766        public void onListRebuilt() {
767            if (mServiceTargets != null) {
768                pruneServiceTargets();
769            }
770        }
771
772        @Override
773        public boolean shouldGetResolvedFilter() {
774            return true;
775        }
776
777        @Override
778        public int getCount() {
779            return super.getCount() + getServiceTargetCount() + getCallerTargetCount();
780        }
781
782        @Override
783        public int getUnfilteredCount() {
784            return super.getUnfilteredCount() + getServiceTargetCount() + getCallerTargetCount();
785        }
786
787        public int getCallerTargetCount() {
788            return mCallerTargets.size();
789        }
790
791        public int getServiceTargetCount() {
792            return Math.min(mServiceTargets.size(), MAX_SERVICE_TARGETS);
793        }
794
795        public int getStandardTargetCount() {
796            return super.getCount();
797        }
798
799        public int getPositionTargetType(int position) {
800            int offset = 0;
801
802            final int callerTargetCount = getCallerTargetCount();
803            if (position < callerTargetCount) {
804                return TARGET_CALLER;
805            }
806            offset += callerTargetCount;
807
808            final int serviceTargetCount = getServiceTargetCount();
809            if (position - offset < serviceTargetCount) {
810                return TARGET_SERVICE;
811            }
812            offset += serviceTargetCount;
813
814            final int standardTargetCount = super.getCount();
815            if (position - offset < standardTargetCount) {
816                return TARGET_STANDARD;
817            }
818
819            return TARGET_BAD;
820        }
821
822        @Override
823        public TargetInfo getItem(int position) {
824            return targetInfoForPosition(position, true);
825        }
826
827        @Override
828        public TargetInfo targetInfoForPosition(int position, boolean filtered) {
829            int offset = 0;
830
831            final int callerTargetCount = getCallerTargetCount();
832            if (position < callerTargetCount) {
833                return mCallerTargets.get(position);
834            }
835            offset += callerTargetCount;
836
837            final int serviceTargetCount = getServiceTargetCount();
838            if (position - offset < serviceTargetCount) {
839                return mServiceTargets.get(position - offset);
840            }
841            offset += serviceTargetCount;
842
843            return filtered ? super.getItem(position - offset)
844                    : getDisplayInfoAt(position - offset);
845        }
846
847        public void addServiceResults(DisplayResolveInfo origTarget, List<ChooserTarget> targets) {
848            if (DEBUG) Log.d(TAG, "addServiceResults " + origTarget + ", " + targets.size()
849                    + " targets");
850            final float parentScore = getScore(origTarget);
851            Collections.sort(targets, mBaseTargetComparator);
852            float lastScore = 0;
853            for (int i = 0, N = targets.size(); i < N; i++) {
854                final ChooserTarget target = targets.get(i);
855                float targetScore = target.getScore();
856                targetScore *= parentScore;
857                targetScore *= mLateFee;
858                if (i > 0 && targetScore >= lastScore) {
859                    // Apply a decay so that the top app can't crowd out everything else.
860                    // This incents ChooserTargetServices to define what's truly better.
861                    targetScore = lastScore * 0.95f;
862                }
863                insertServiceTarget(new ChooserTargetInfo(origTarget, target, targetScore));
864
865                if (DEBUG) {
866                    Log.d(TAG, " => " + target.toString() + " score=" + targetScore
867                            + " base=" + target.getScore()
868                            + " lastScore=" + lastScore
869                            + " parentScore=" + parentScore
870                            + " lateFee=" + mLateFee);
871                }
872
873                lastScore = targetScore;
874            }
875
876            mLateFee *= 0.95f;
877
878            notifyDataSetChanged();
879        }
880
881        private void insertServiceTarget(ChooserTargetInfo chooserTargetInfo) {
882            final float newScore = chooserTargetInfo.getModifiedScore();
883            for (int i = 0, N = mServiceTargets.size(); i < N; i++) {
884                final ChooserTargetInfo serviceTarget = mServiceTargets.get(i);
885                if (newScore > serviceTarget.getModifiedScore()) {
886                    mServiceTargets.add(i, chooserTargetInfo);
887                    return;
888                }
889            }
890            mServiceTargets.add(chooserTargetInfo);
891        }
892
893        private void pruneServiceTargets() {
894            if (DEBUG) Log.d(TAG, "pruneServiceTargets");
895            for (int i = mServiceTargets.size() - 1; i >= 0; i--) {
896                final ChooserTargetInfo cti = mServiceTargets.get(i);
897                if (!hasResolvedTarget(cti.getResolveInfo())) {
898                    if (DEBUG) Log.d(TAG, " => " + i + " " + cti);
899                    mServiceTargets.remove(i);
900                }
901            }
902        }
903    }
904
905    static class BaseChooserTargetComparator implements Comparator<ChooserTarget> {
906        @Override
907        public int compare(ChooserTarget lhs, ChooserTarget rhs) {
908            // Descending order
909            return (int) Math.signum(lhs.getScore() - rhs.getScore());
910        }
911    }
912
913    static class RowScale {
914        private static final int DURATION = 400;
915
916        float mScale;
917        ChooserRowAdapter mAdapter;
918        private final ObjectAnimator mAnimator;
919
920        public static final FloatProperty<RowScale> PROPERTY =
921                new FloatProperty<RowScale>("scale") {
922            @Override
923            public void setValue(RowScale object, float value) {
924                object.mScale = value;
925                object.mAdapter.notifyDataSetChanged();
926            }
927
928            @Override
929            public Float get(RowScale object) {
930                return object.mScale;
931            }
932        };
933
934        public RowScale(@NonNull ChooserRowAdapter adapter, float from, float to) {
935            mAdapter = adapter;
936            mScale = from;
937            if (from == to) {
938                mAnimator = null;
939                return;
940            }
941
942            mAnimator = ObjectAnimator.ofFloat(this, PROPERTY, from, to).setDuration(DURATION);
943        }
944
945        public RowScale setInterpolator(Interpolator interpolator) {
946            if (mAnimator != null) {
947                mAnimator.setInterpolator(interpolator);
948            }
949            return this;
950        }
951
952        public float get() {
953            return mScale;
954        }
955
956        public void startAnimation() {
957            if (mAnimator != null) {
958                mAnimator.start();
959            }
960        }
961
962        public void cancelAnimation() {
963            if (mAnimator != null) {
964                mAnimator.cancel();
965            }
966        }
967    }
968
969    class ChooserRowAdapter extends BaseAdapter {
970        private ChooserListAdapter mChooserListAdapter;
971        private final LayoutInflater mLayoutInflater;
972        private final int mColumnCount = 4;
973        private RowScale[] mServiceTargetScale;
974        private final Interpolator mInterpolator;
975
976        public ChooserRowAdapter(ChooserListAdapter wrappedAdapter) {
977            mChooserListAdapter = wrappedAdapter;
978            mLayoutInflater = LayoutInflater.from(ChooserActivity.this);
979
980            mInterpolator = AnimationUtils.loadInterpolator(ChooserActivity.this,
981                    android.R.interpolator.decelerate_quint);
982
983            wrappedAdapter.registerDataSetObserver(new DataSetObserver() {
984                @Override
985                public void onChanged() {
986                    super.onChanged();
987                    final int rcount = getServiceTargetRowCount();
988                    if (mServiceTargetScale == null
989                            || mServiceTargetScale.length != rcount) {
990                        RowScale[] old = mServiceTargetScale;
991                        int oldRCount = old != null ? old.length : 0;
992                        mServiceTargetScale = new RowScale[rcount];
993                        if (old != null && rcount > 0) {
994                            System.arraycopy(old, 0, mServiceTargetScale, 0,
995                                    Math.min(old.length, rcount));
996                        }
997
998                        for (int i = rcount; i < oldRCount; i++) {
999                            old[i].cancelAnimation();
1000                        }
1001
1002                        for (int i = oldRCount; i < rcount; i++) {
1003                            final RowScale rs = new RowScale(ChooserRowAdapter.this, 0.f, 1.f)
1004                                    .setInterpolator(mInterpolator);
1005                            mServiceTargetScale[i] = rs;
1006                            rs.startAnimation();
1007                        }
1008                    }
1009
1010                    notifyDataSetChanged();
1011                }
1012
1013                @Override
1014                public void onInvalidated() {
1015                    super.onInvalidated();
1016                    notifyDataSetInvalidated();
1017                    if (mServiceTargetScale != null) {
1018                        for (RowScale rs : mServiceTargetScale) {
1019                            rs.cancelAnimation();
1020                        }
1021                    }
1022                }
1023            });
1024        }
1025
1026        private float getRowScale(int rowPosition) {
1027            final int start = getCallerTargetRowCount();
1028            final int end = start + getServiceTargetRowCount();
1029            if (rowPosition >= start && rowPosition < end) {
1030                return mServiceTargetScale[rowPosition - start].get();
1031            }
1032            return 1.f;
1033        }
1034
1035        @Override
1036        public int getCount() {
1037            return (int) (
1038                    getCallerTargetRowCount()
1039                    + getServiceTargetRowCount()
1040                    + Math.ceil((float) mChooserListAdapter.getStandardTargetCount() / mColumnCount)
1041            );
1042        }
1043
1044        public int getCallerTargetRowCount() {
1045            return (int) Math.ceil(
1046                    (float) mChooserListAdapter.getCallerTargetCount() / mColumnCount);
1047        }
1048
1049        public int getServiceTargetRowCount() {
1050            return (int) Math.ceil(
1051                    (float) mChooserListAdapter.getServiceTargetCount() / mColumnCount);
1052        }
1053
1054        @Override
1055        public Object getItem(int position) {
1056            // We have nothing useful to return here.
1057            return position;
1058        }
1059
1060        @Override
1061        public long getItemId(int position) {
1062            return position;
1063        }
1064
1065        @Override
1066        public View getView(int position, View convertView, ViewGroup parent) {
1067            final RowViewHolder holder;
1068            if (convertView == null) {
1069                holder = createViewHolder(parent);
1070            } else {
1071                holder = (RowViewHolder) convertView.getTag();
1072            }
1073            bindViewHolder(position, holder);
1074
1075            return holder.row;
1076        }
1077
1078        RowViewHolder createViewHolder(ViewGroup parent) {
1079            final ViewGroup row = (ViewGroup) mLayoutInflater.inflate(R.layout.chooser_row,
1080                    parent, false);
1081            final RowViewHolder holder = new RowViewHolder(row, mColumnCount);
1082            final int spec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
1083
1084            for (int i = 0; i < mColumnCount; i++) {
1085                final View v = mChooserListAdapter.createView(row);
1086                v.setOnClickListener(new OnClickListener() {
1087                    @Override
1088                    public void onClick(View v) {
1089                        startSelected(holder.itemIndex, false, true);
1090                    }
1091                });
1092                v.setOnLongClickListener(new OnLongClickListener() {
1093                    @Override
1094                    public boolean onLongClick(View v) {
1095                        showAppDetails(
1096                                mChooserListAdapter.resolveInfoForPosition(holder.itemIndex, true));
1097                        return true;
1098                    }
1099                });
1100                row.addView(v);
1101                holder.cells[i] = v;
1102
1103                // Force height to be a given so we don't have visual disruption during scaling.
1104                LayoutParams lp = v.getLayoutParams();
1105                v.measure(spec, spec);
1106                if (lp == null) {
1107                    lp = new LayoutParams(LayoutParams.MATCH_PARENT, v.getMeasuredHeight());
1108                    row.setLayoutParams(lp);
1109                } else {
1110                    lp.height = v.getMeasuredHeight();
1111                }
1112            }
1113
1114            // Pre-measure so we can scale later.
1115            holder.measure();
1116            LayoutParams lp = row.getLayoutParams();
1117            if (lp == null) {
1118                lp = new LayoutParams(LayoutParams.MATCH_PARENT, holder.measuredRowHeight);
1119                row.setLayoutParams(lp);
1120            } else {
1121                lp.height = holder.measuredRowHeight;
1122            }
1123            row.setTag(holder);
1124            return holder;
1125        }
1126
1127        void bindViewHolder(int rowPosition, RowViewHolder holder) {
1128            final int start = getFirstRowPosition(rowPosition);
1129            final int startType = mChooserListAdapter.getPositionTargetType(start);
1130
1131            int end = start + mColumnCount - 1;
1132            while (mChooserListAdapter.getPositionTargetType(end) != startType && end >= start) {
1133                end--;
1134            }
1135
1136            if (startType == ChooserListAdapter.TARGET_SERVICE) {
1137                holder.row.setBackgroundColor(
1138                        getColor(R.color.chooser_service_row_background_color));
1139            } else {
1140                holder.row.setBackgroundColor(Color.TRANSPARENT);
1141            }
1142
1143            final int oldHeight = holder.row.getLayoutParams().height;
1144            holder.row.getLayoutParams().height = Math.max(1,
1145                    (int) (holder.measuredRowHeight * getRowScale(rowPosition)));
1146            if (holder.row.getLayoutParams().height != oldHeight) {
1147                holder.row.requestLayout();
1148            }
1149
1150            for (int i = 0; i < mColumnCount; i++) {
1151                final View v = holder.cells[i];
1152                if (start + i <= end) {
1153                    v.setVisibility(View.VISIBLE);
1154                    holder.itemIndex = start + i;
1155                    mChooserListAdapter.bindView(holder.itemIndex, v);
1156                } else {
1157                    v.setVisibility(View.GONE);
1158                }
1159            }
1160        }
1161
1162        int getFirstRowPosition(int row) {
1163            final int callerCount = mChooserListAdapter.getCallerTargetCount();
1164            final int callerRows = (int) Math.ceil((float) callerCount / mColumnCount);
1165
1166            if (row < callerRows) {
1167                return row * mColumnCount;
1168            }
1169
1170            final int serviceCount = mChooserListAdapter.getServiceTargetCount();
1171            final int serviceRows = (int) Math.ceil((float) serviceCount / mColumnCount);
1172
1173            if (row < callerRows + serviceRows) {
1174                return callerCount + (row - callerRows) * mColumnCount;
1175            }
1176
1177            return callerCount + serviceCount
1178                    + (row - callerRows - serviceRows) * mColumnCount;
1179        }
1180    }
1181
1182    static class RowViewHolder {
1183        final View[] cells;
1184        final ViewGroup row;
1185        int measuredRowHeight;
1186        int itemIndex;
1187
1188        public RowViewHolder(ViewGroup row, int cellCount) {
1189            this.row = row;
1190            this.cells = new View[cellCount];
1191        }
1192
1193        public void measure() {
1194            final int spec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
1195            row.measure(spec, spec);
1196            measuredRowHeight = row.getMeasuredHeight();
1197        }
1198    }
1199
1200    static class ChooserTargetServiceConnection implements ServiceConnection {
1201        private final DisplayResolveInfo mOriginalTarget;
1202        private ComponentName mConnectedComponent;
1203        private ChooserActivity mChooserActivity;
1204        private final Object mLock = new Object();
1205
1206        private final IChooserTargetResult mChooserTargetResult = new IChooserTargetResult.Stub() {
1207            @Override
1208            public void sendResult(List<ChooserTarget> targets) throws RemoteException {
1209                synchronized (mLock) {
1210                    if (mChooserActivity == null) {
1211                        Log.e(TAG, "destroyed ChooserTargetServiceConnection received result from "
1212                                + mConnectedComponent + "; ignoring...");
1213                        return;
1214                    }
1215                    mChooserActivity.filterServiceTargets(
1216                            mOriginalTarget.getResolveInfo().activityInfo.packageName, targets);
1217                    final Message msg = Message.obtain();
1218                    msg.what = CHOOSER_TARGET_SERVICE_RESULT;
1219                    msg.obj = new ServiceResultInfo(mOriginalTarget, targets,
1220                            ChooserTargetServiceConnection.this);
1221                    mChooserActivity.mChooserHandler.sendMessage(msg);
1222                }
1223            }
1224        };
1225
1226        public ChooserTargetServiceConnection(ChooserActivity chooserActivity,
1227                DisplayResolveInfo dri) {
1228            mChooserActivity = chooserActivity;
1229            mOriginalTarget = dri;
1230        }
1231
1232        @Override
1233        public void onServiceConnected(ComponentName name, IBinder service) {
1234            if (DEBUG) Log.d(TAG, "onServiceConnected: " + name);
1235            synchronized (mLock) {
1236                if (mChooserActivity == null) {
1237                    Log.e(TAG, "destroyed ChooserTargetServiceConnection got onServiceConnected");
1238                    return;
1239                }
1240
1241                final IChooserTargetService icts = IChooserTargetService.Stub.asInterface(service);
1242                try {
1243                    icts.getChooserTargets(mOriginalTarget.getResolvedComponentName(),
1244                            mOriginalTarget.getResolveInfo().filter, mChooserTargetResult);
1245                } catch (RemoteException e) {
1246                    Log.e(TAG, "Querying ChooserTargetService " + name + " failed.", e);
1247                    mChooserActivity.unbindService(this);
1248                    destroy();
1249                    mChooserActivity.mServiceConnections.remove(this);
1250                }
1251            }
1252        }
1253
1254        @Override
1255        public void onServiceDisconnected(ComponentName name) {
1256            if (DEBUG) Log.d(TAG, "onServiceDisconnected: " + name);
1257            synchronized (mLock) {
1258                if (mChooserActivity == null) {
1259                    Log.e(TAG,
1260                            "destroyed ChooserTargetServiceConnection got onServiceDisconnected");
1261                    return;
1262                }
1263
1264                mChooserActivity.unbindService(this);
1265                destroy();
1266                mChooserActivity.mServiceConnections.remove(this);
1267                if (mChooserActivity.mServiceConnections.isEmpty()) {
1268                    mChooserActivity.mChooserHandler.removeMessages(
1269                            CHOOSER_TARGET_SERVICE_WATCHDOG_TIMEOUT);
1270                    mChooserActivity.sendVoiceChoicesIfNeeded();
1271                }
1272                mConnectedComponent = null;
1273            }
1274        }
1275
1276        public void destroy() {
1277            synchronized (mLock) {
1278                mChooserActivity = null;
1279            }
1280        }
1281
1282        @Override
1283        public String toString() {
1284            return "ChooserTargetServiceConnection{service="
1285                    + mConnectedComponent + ", activity="
1286                    + mOriginalTarget.getResolveInfo().activityInfo.toString() + "}";
1287        }
1288    }
1289
1290    static class ServiceResultInfo {
1291        public final DisplayResolveInfo originalTarget;
1292        public final List<ChooserTarget> resultTargets;
1293        public final ChooserTargetServiceConnection connection;
1294
1295        public ServiceResultInfo(DisplayResolveInfo ot, List<ChooserTarget> rt,
1296                ChooserTargetServiceConnection c) {
1297            originalTarget = ot;
1298            resultTargets = rt;
1299            connection = c;
1300        }
1301    }
1302
1303    static class RefinementResultReceiver extends ResultReceiver {
1304        private ChooserActivity mChooserActivity;
1305        private TargetInfo mSelectedTarget;
1306
1307        public RefinementResultReceiver(ChooserActivity host, TargetInfo target,
1308                Handler handler) {
1309            super(handler);
1310            mChooserActivity = host;
1311            mSelectedTarget = target;
1312        }
1313
1314        @Override
1315        protected void onReceiveResult(int resultCode, Bundle resultData) {
1316            if (mChooserActivity == null) {
1317                Log.e(TAG, "Destroyed RefinementResultReceiver received a result");
1318                return;
1319            }
1320            if (resultData == null) {
1321                Log.e(TAG, "RefinementResultReceiver received null resultData");
1322                return;
1323            }
1324
1325            switch (resultCode) {
1326                case RESULT_CANCELED:
1327                    mChooserActivity.onRefinementCanceled();
1328                    break;
1329                case RESULT_OK:
1330                    Parcelable intentParcelable = resultData.getParcelable(Intent.EXTRA_INTENT);
1331                    if (intentParcelable instanceof Intent) {
1332                        mChooserActivity.onRefinementResult(mSelectedTarget,
1333                                (Intent) intentParcelable);
1334                    } else {
1335                        Log.e(TAG, "RefinementResultReceiver received RESULT_OK but no Intent"
1336                                + " in resultData with key Intent.EXTRA_INTENT");
1337                    }
1338                    break;
1339                default:
1340                    Log.w(TAG, "Unknown result code " + resultCode
1341                            + " sent to RefinementResultReceiver");
1342                    break;
1343            }
1344        }
1345
1346        public void destroy() {
1347            mChooserActivity = null;
1348            mSelectedTarget = null;
1349        }
1350    }
1351
1352    class OffsetDataSetObserver extends DataSetObserver {
1353        private final AbsListView mListView;
1354        private int mCachedViewType = -1;
1355        private View mCachedView;
1356
1357        public OffsetDataSetObserver(AbsListView listView) {
1358            mListView = listView;
1359        }
1360
1361        @Override
1362        public void onChanged() {
1363            if (mResolverDrawerLayout == null) {
1364                return;
1365            }
1366
1367            final int chooserTargetRows = mChooserRowAdapter.getServiceTargetRowCount();
1368            int offset = 0;
1369            for (int i = 0; i < chooserTargetRows; i++)  {
1370                final int pos = mChooserRowAdapter.getCallerTargetRowCount() + i;
1371                final int vt = mChooserRowAdapter.getItemViewType(pos);
1372                if (vt != mCachedViewType) {
1373                    mCachedView = null;
1374                }
1375                final View v = mChooserRowAdapter.getView(pos, mCachedView, mListView);
1376                int height = ((RowViewHolder) (v.getTag())).measuredRowHeight;
1377
1378                offset += (int) (height * mChooserRowAdapter.getRowScale(pos) * chooserTargetRows);
1379
1380                if (vt >= 0) {
1381                    mCachedViewType = vt;
1382                    mCachedView = v;
1383                } else {
1384                    mCachedViewType = -1;
1385                }
1386            }
1387
1388            mResolverDrawerLayout.setCollapsibleHeightReserved(offset);
1389        }
1390    }
1391}
1392