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