protected void (ListView l,View v,int position,long id) {
  Intent intent = intentForPosition(position);
  startActivity(intent);
}

public void startActivity(Intent intent) {
  this.startActivity(intent,null); 
}


public void startActivity(Intent intent,@Nullable Bundle options) {
  if (options != null) {
    startActivityForResult(intent,-1,options);
  } else {
    // Note we want to go through this call for compatibility with
    // applications that may have overridden the method.
    startActivityForResult(intent,-1);
  }
}

public void startActivityForResult(@RequiresPermission Intent intent,int requestCode) {
  startActivityForResult(intent,requestCode,null);
}

public void startActivityForResult(@RequiresPermission Intent intent,int requestCode,
 @Nullable Bundle options) {
  if (mParent == null) {
    options = transferSpringboardActivityOptions(options);
    // 关键代码
    Instrumentation.ActivityResult ar =
      mInstrumentation.execStartActivity(
      this,mMainThread.getApplicationThread(),mToken,this,
      intent,options);
    //
    if (ar != null) {
      mMainThread.sendActivityResult(
        mToken,mEmbeddedID,ar.getResultCode(),
        ar.getResultData());
    }
    if (requestCode >= 0) {
      mStartedActivity = true;
    }

    cancelInputsAndStartExitTransition(options);
    // TODO Consider clearing/flushing other event sources and events for child windows.
  } else {
    if (options != null) {
      mParent.startActivityFromChild(this,intent,options);
    } else {
      // Note we want to go through this method for compatibility with
      // existing applications that may have overridden it.
      mParent.startActivityFromChild(this,requestCode);
    }
  }
}

public void startActivityFromChild(@NonNull Activity child,@RequiresPermission Intent intent,@Nullable Bundle options) {
  options = transferSpringboardActivityOptions(options);
  Instrumentation.ActivityResult ar =
    mInstrumentation.execStartActivity(
    this,child,
    intent,options);
  if (ar != null) {
    mMainThread.sendActivityResult(
      mToken,child.mEmbeddedID,
      ar.getResultCode(),ar.getResultData());
  }
  cancelInputsAndStartExitTransition(options);
}

public ActivityResult execStartActivity(
 Context who,IBinder contextThread,IBinder token,Activity target,
 Intent intent,Bundle options) {
  IApplicationThread whoThread = (IApplicationThread) contextThread;
  Uri referrer = target != null ? target.onProvideReferrer() : null;
  if (referrer != null) {
    intent.putExtra(Intent.EXTRA_REFERRER,referrer);
  }
  if (mActivityMonitors != null) {
    synchronized (mSync) {
      final int N = mActivityMonitors.size();
      for (int i=0; i<N; i++) { // 通过ActivityMonitor对启动的activity进行检查
        final ActivityMonitor am = mActivityMonitors.get(i);
        ActivityResult result = null;
        if (am.ignoreMatchingSpecificIntents()) {
          result = am.onStartActivity(intent);
        }
        if (result != null) {
          am.mHits++;
          return result;
        } else if (am.match(who,null,intent)) {
          am.mHits++;
          if (am.isBlocking()) {
            return requestCode >= 0 ? am.getResult() : null;
          }
          break;
        }
      }
    }
  }
  try {
    intent.migrateExtraStreamToClipData();
    intent.prepareToLeaveProcess(who);
    
    // 通过binder将处理从launcher进程切换到ActivityManagerService
    int result = ActivityManager.getService()
      .startActivity(whoThread,who.getBasePackageName(),
                     intent.resolveTypeIfNeeded(who.getContentResolver()),
                     token,target != null ? target.mEmbeddedID : null,
                     requestCode,0,options);
    checkStartActivityResult(result,intent);
  } catch (RemoteException e) {
    throw new RuntimeException("Failure from system",e);
  }
  return null;
}

public final int startActivity(IApplicationThread caller,String callingPackage,String resolvedType,IBinder resultTo,String resultWho,
 int startFlags,ProfilerInfo profilerInfo,Bundle bOptions) {
  return startActivityAsUser(caller,callingPackage,resolvedType,resultTo,
                             resultWho,startFlags,profilerInfo,bOptions,
                             UserHandle.getCallingUserId());
}

public final int startActivityAsUser(IApplicationThread caller,Bundle bOptions,int userId) {
  enforceNotIsolatedCaller("startActivity"); // 验证CallingUid
  userId = mUserController.handleIncomingUser(Binder.getCallingPid(),Binder.getCallingUid(),
                                              userId,false,ALLOW_FULL_ONLY,"startActivity",null);
  // TODO: Switch to user app stacks here.
  return mActivityStarter.startActivityMayWait(caller,
                                               resolvedType,resultWho,
                                               profilerInfo,userId,"startActivityAsUser");
}

// Collect information about the target of the Intent.
ActivityInfo aInfo = mSupervisor.resolveActivity(intent,rInfo,profilerInfo);

ActivityStackSupervisor.ActivityContainer container = 													(ActivityStackSupervisor.ActivityContainer)iContainer;
final ActivityStack stack;
if (container == null || container.mStack.isOnHomeDisplay()) {
  stack = mSupervisor.mFocusedStack;
} else {
  stack = container.mStack;
}

int res = startActivityLocked(caller,ephemeralIntent,
                              aInfo,voiceSession,voiceInteractor,
                              resultTo,callingPid,
                              callingUid,realCallingPid,realCallingUid,
                              options,ignoreTargetSecurity,componentSpecified,outRecord,container,
                              inTask,reason);

ProcessRecord callerApp = null;
if (caller != null) {
  callerApp = mService.getRecordForAppLocked(caller);
  if (callerApp != null) {
    callingPid = callerApp.pid;
    callingUid = callerApp.info.uid;

ActivityRecord sourceRecord = null;
ActivityRecord resultRecord = null;
if (resultTo != null) { // 接收返回结果
  sourceRecord = mSupervisor.isInAnyStackLocked(resultTo); // 拿到sourceRecord
  if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
                            "Will send result to " + resultTo + " " + sourceRecord);
  if (sourceRecord != null) {
    if (requestCode >= 0 && !sourceRecord.finishing) { // sourceRecord非结束状态
      resultRecord = sourceRecord;
    }
  }
}

boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent,aInfo,callingUid,callerApp,resultRecord,resultStack,options);

abort |= !mService.mIntentFirewall.checkStartActivity(intent,aInfo.applicationInfo);

ActivityRecord r = new ActivityRecord(mService,mService.getGlobalConfiguration(),voiceSession != null,mSupervisor,options,sourceRecord);

if (!mService.checkAppSwitchAllowedLocked(callingPid,
                    realCallingPid,"Activity start")) {
    PendingActivityLaunch pal =  new PendingActivityLaunch(r,
                                   sourceRecord,stack,callerApp);
    mPendingActivityLaunches.add(pal);
    ActivityOptions.abort(options);
    return ActivityManager.START_SWITCHES_CANCELED;
}

result = startActivityUnchecked(r,sourceRecord,
                    startFlags,doResume,inTask,outActivity);

// We'll invoke onUserLeaving before onPause only if the launching
// activity did not explicitly state that this is an automated launch.
mSupervisor.mUserLeaving = (mLaunchFlags & FLAG_ACTIVITY_NO_USER_ACTION) == 0;

if (mSourceRecord == null && mInTask != null && mInTask.getStack() != null) {
    final Intent baseIntent = mInTask.getBaseIntent();
    final ActivityRecord root = mInTask.getRootActivity();

if (mInTask == null) {
    if (mSourceRecord == null) {
        // This activity is not being started from another... in this
        // case we -always- start a new task.
        if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0 && mInTask == null) {
            Slog.w(TAG,"startActivity called from non-Activity context; forcing " +
                   "Intent.FLAG_ACTIVITY_NEW_TASK for: " + mIntent);
            mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
        }
    } else if (mSourceRecord.launchMode == LAUNCH_SINGLE_INSTANCE) {
        // The original activity who is starting us is running as a single
        // instance... this new activity it is starting must go on its
        // own task.
        mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
    } else if (mLaunchSingleInstance || mLaunchSingleTask) {
        // The activity being started is a single instance... it always
        // gets launched into its own task.
        mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
    }
}

private void computeSourceStack() {
    if (mSourceRecord == null) {
        mSourceStack = null;
        return;
    }
    if (!mSourceRecord.finishing) {
        mSourceStack = mSourceRecord.getStack();
        return;
    }

    // If the source is finishing,we can't further count it as our source. This is because the
    // task it is associated with may now be empty and on its way out,so we don't want to
    // blindly throw it in to that task. Instead we will take the NEW_TASK flow and try to find
    // a task for it. But save the task information so it can be used when creating the new task.
    if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0) {
        Slog.w(TAG,"startActivity called from finishing " + mSourceRecord
               + "; forcing " + "Intent.FLAG_ACTIVITY_NEW_TASK for: " + mIntent);
        mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
        mNewTaskInfo = mSourceRecord.info;

        // It is not guaranteed that the source record will have a task associated with it. For,
        // example,if this method is being called for processing a pending activity launch,it
        // is possible that the activity has been removed from the task after the launch was
        // enqueued.
        final TaskRecord sourceTask = mSourceRecord.getTask();
        mNewTaskIntent = sourceTask != null ? sourceTask.intent : null;
    }
    mSourceRecord = null;
    mSourceStack = null;
}

ActivityRecord reusedActivity = getReusableIntentActivity();

/**
 * Decide whether the new activity should be inserted into an existing task. Returns null
 * if not or an ActivityRecord with the task into which the new activity should be added.
 */
private ActivityRecord getReusableIntentActivity() {
    // We may want to try to place the new activity in to an existing task. We always
    // do this if the target activity is singleTask or singleInstance; we will also do
    // this if NEW_TASK has been requested,and there is not an additional qualifier telling
    // us to still place it in a new task: multi task,always doc mode,or being asked to
    // launch this as a new task behind the current one.
    boolean putIntoExistingTask = ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0 &&
                                   (mLaunchFlags & FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
        || mLaunchSingleInstance || mLaunchSingleTask;
    // If bring to front is requested,and no result is requested and we have not been given
    // an explicit task to launch in to,and we can find a task that was started with this
    // same component,then instead of launching bring that one to the front.
    putIntoExistingTask &= mInTask == null && mStartActivity.resultTo == null;
    ActivityRecord intentActivity = null;
    if (mOptions != null && mOptions.getLaunchTaskId() != -1) {
        final TaskRecord task = mSupervisor.anyTaskForIdLocked(mOptions.getLaunchTaskId());
        intentActivity = task != null ? task.getTopActivity() : null;
    } else if (putIntoExistingTask) {
        if (mLaunchSingleInstance) {
            // There can be one and only one instance of single instance activity in the
            // history,and it is always in its own unique task,so we do a special search.
            intentActivity = mSupervisor.findActivityLocked(mIntent,mStartActivity.info,false);
        } else if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
            // For the launch adjacent case we only want to put the activity in an existing
            // task if the activity already exists in the history.
            intentActivity = mSupervisor.findActivityLocked(mIntent,
                                                            !mLaunchSingleTask);
        } else {
            // Otherwise find the best task to put the activity in.
            intentActivity = mSupervisor.findTaskLocked(mStartActivity,mSourceDisplayId);
        }
    }
    return intentActivity;
}