core/java/com/android/internal/app/ChooserActivity.java

   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
  17 package com.android.internal.app;
  18
  19 import android.animation.ObjectAnimator;
  20 import android.annotation.NonNull;
  21 import android.app.Activity;
  22 import android.content.ComponentName;
  23 import android.content.Context;
  24 import android.content.Intent;
  25 import android.content.IntentSender;
  26 import android.content.IntentSender.SendIntentException;
  27 import android.content.ServiceConnection;
  28 import android.content.pm.ActivityInfo;
  29 import android.content.pm.LabeledIntent;
  30 import android.content.pm.PackageManager;
  31 import android.content.pm.PackageManager.NameNotFoundException;
  32 import android.content.pm.ResolveInfo;
  33 import android.database.DataSetObserver;
  34 import android.graphics.Color;
  35 import android.graphics.drawable.Drawable;
  36 import android.graphics.drawable.Icon;
  37 import android.os.Bundle;
  38 import android.os.Handler;
  39 import android.os.IBinder;
  40 import android.os.Message;
  41 import android.os.Parcelable;
  42 import android.os.RemoteException;
  43 import android.os.ResultReceiver;
  44 import android.os.UserHandle;
  45 import android.os.UserManager;
  46 import android.provider.DocumentsContract;
  47 import android.service.chooser.ChooserTarget;
  48 import android.service.chooser.ChooserTargetService;
  49 import android.service.chooser.IChooserTargetResult;
  50 import android.service.chooser.IChooserTargetService;
  51 import android.text.TextUtils;
  52 import android.util.FloatProperty;
  53 import android.util.Log;
  54 import android.util.Slog;
  55 import android.view.LayoutInflater;
  56 import android.view.View;
  57 import android.view.View.MeasureSpec;
  58 import android.view.View.OnClickListener;
  59 import android.view.View.OnLongClickListener;
  60 import android.view.ViewGroup;
  61 import android.view.ViewGroup.LayoutParams;
  62 import android.view.animation.AnimationUtils;
  63 import android.view.animation.Interpolator;
  64 import android.widget.AbsListView;
  65 import android.widget.BaseAdapter;
  66 import android.widget.ListView;
  67 import com.android.internal.R;
  68 import com.android.internal.logging.MetricsLogger;
  69
  70 import java.util.ArrayList;
  71 import java.util.Collections;
  72 import java.util.Comparator;
  73 import java.util.List;
  74
  75 public 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 }