activity的几个相关类

android  中主要对activity管理的几个相关类。

ActivityRecord:通常的的 我们用的activity都是以继承activity的形式出现，但是在系统中,每个                      activity都是以activity record的形式出现，这个类包涵了 activity的各种信息。

ActivityThread：负责管理并执行主线成中的各种请求。

ActivityManagerService：通过 ActivityManagerNative 类中的代理类 来实现 具体业务的管理者。

ActivityStack: activity的管理及各种状态，一般的activity栈就是说的这个类,同时 还负责一些具体的类的操作 ActivityManagerService 通过调用 ActivityStack 来实习具体的操作，比如activity的开启，关闭，等。

Trace:这个类 主要用来做数据分析，在代码中 ActivityThread 在执行一些人物请求的时候，会调用 Trace中的一些方法来写入和分析数据。

Instrumentation：application instrumentation 的 base. 这个类在应用实例化前开启。他主要用来监听所有系统用应用间的交互。 Instrumentation 通过 instrumentation 标签来进行描述。

通过 onBackPressed 来看一下执行

public void onBackPressed() {
    //2.0 < version < 3.0 没有这个判断  默认直接finis
    if (!mFragments.popBackStackImmediate()) {
        finish() ;
    }
}

public void finish() {
    if (mParent ==  null) {
        int resultCode ;
        Intent resultData ;
        synchronized ( this) {
            resultCode = mResultCode ;
            resultData = mResultData ;
        }
        if ( false) Log.v(TAG ,  "Finishing self: token=" + mToken) ;
        try {
            if (resultData !=  null) {
                resultData.setAllowFds( false) ;
            }

            //同样最终调用的是 ActivityManagerService 中的 finishActivity 方法
            //和startActivity一样 还是先由 ActivityManagerNativen内部实现的一个代理类
            //来实现 远程服务 ActivityManagerService来实现
            if (ActivityManagerNative.getDefault()
                .finishActivity(mToken , resultCode , resultData)) {
                mFinished =  true;
            }
        }  catch (RemoteException e) {
            // Empty
        }
    }  else {
        mParent.finishFromChild( this) ;
    }
}

public final boolean finishActivity(IBinder token , int resultCode , Intent resultData) {
    // Refuse possible leaked file descriptors
    if (resultData !=  null && resultData.hasFileDescriptors() ==  true) {
        throw new IllegalArgumentException( "File descriptors passed in Intent") ;
    }

    synchronized( this) {
        if (mController !=  null) {
            // Find the first activity that is not finishing.
            //找到栈顶下一个 可以恢复的Activity
            ActivityRecord next = mMainStack.topRunningActivityLocked(token ,  0) ;
            if (next !=  null) {
                // ask watcher if this is allowed
                boolean resumeOK =  true;
                try {
                    //判断这个是否可以能恢复
                    resumeOK = mController.activityResuming(next.packageName) ;
                }  catch (RemoteException e) {
                    mController =  null;
                }

                if (!resumeOK) {
                    return false;
                }
            }
        }
        final long origId = Binder.clearCallingIdentity() ;

        //最终的执行者 是 ActivityStack 这个才是具体操作的执行者
       //ActivityManagerService 将具体的任务 分给 ActivityStack去执行
        boolean res = mMainStack.requestFinishActivityLocked(token , resultCode ,
                resultData ,  "app-request") ;
        Binder.restoreCallingIdentity(origId) ;
        return res ;
    }
}

final boolean requestFinishActivityLocked(IBinder token , int resultCode ,
        Intent resultData , String reason) {
    int index = indexOfTokenLocked(token) ;  //判断activity是否存在 存在就去那索引
    if (DEBUG_RESULTS || DEBUG_STATES) Slog.v(
            TAG ,  "Finishing activity @" + index +  ": token=" + token
            +  ", result=" + resultCode +  ", data=" + resultData
            +  ", reason=" + reason) ;
    if (index <  0) {
        return false;
    }
    //拿到相对应的ActivityRecord
    ActivityRecord r = mHistory.get(index) ;

    finishActivityLocked(r , index , resultCode , resultData , reason) ;
    return true;
}

final boolean finishActivityLocked(ActivityRecord r , int index ,
        int resultCode , Intent resultData , String reason , boolean immediate) {
    if (r.finishing) {
        Slog.w(TAG ,  "Duplicate finish request for " + r) ;
        return false;
    }

    r.makeFinishing() ;
    EventLog.writeEvent(EventLogTags.AM_FINISH_ACTIVITY ,
            System.identityHashCode(r) ,
            r.task.taskId , r.shortComponentName , reason) ;
    if (index < (mHistory.size()- 1)) {
        ActivityRecord next = mHistory.get(index+ 1) ;
        if (next.task == r.task) {
            if (r.frontOfTask) {
                // The next activity is now the front of the task.
                next.frontOfTask =  true;
            }
            if ((r.intent.getFlags()&Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) !=  0) {
                // If the caller asked that this activity (and all above it)
                // be cleared when the task is reset, don't lose that information,
                // but propagate it up to the next activity.
                next.intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) ;
            }
        }
    }

    //暂停这个类的一些操作，应该是这样的 这个方法没有细看
    r.pauseKeyDispatchingLocked() ;
    if (mMainStack) {
        if (mService.mFocusedActivity == r) {
            mService.setFocusedActivityLocked(topRunningActivityLocked( null)) ;
        }
    }

    finishActivityResultsLocked(r , resultCode , resultData) ;
   
    if (mService.mPendingThumbnails.size() >  0) {
        // There are clients waiting to receive thumbnails so, in case
        // this is an activity that someone is waiting for, add it
        // to the pending list so we can correctly update the clients.
        mService.mCancelledThumbnails.add(r) ;
    }

    //这里传入的是false 先不看这个判断里面的方法
    if (immediate) {  //这里关闭activity
        return  finishCurrentActivityLocked(r , index ,
                FINISH_IMMEDIATELY) ==  null;
    }  else if (mResumedActivity == r) {
        boolean endTask = index <=  0
                || (mHistory.get(index- 1)).task != r.task ;
        if (DEBUG_TRANSITION) Slog.v(TAG ,
                "Prepare close transition: finishing " + r) ;  //这里应该是执行关闭动画
        mService.mWindowManager.prepareAppTransition(endTask
                ? WindowManagerPolicy.TRANSIT_TASK_CLOSE
                : WindowManagerPolicy.TRANSIT_ACTIVITY_CLOSE , false) ;

        // Tell window manager to prepare for this one to be removed.
        mService.mWindowManager.setAppVisibility(r.appToken , false) ;
           
        if (mPausingActivity ==  null) {
            if (DEBUG_PAUSE) Slog.v(TAG ,  "Finish needs to pause: " + r) ;
            if (DEBUG_USER_LEAVING) Slog.v(TAG ,  "finish() => pause with userLeaving=false") ;
            startPausingLocked( false, false) ;
        }

    }  else if (r.state != ActivityState.PAUSING) {
        // If the activity is PAUSING, we will complete the finish once
        // it is done pausing; else we can just directly finish it here.
        if (DEBUG_PAUSE) Slog.v(TAG ,  "Finish not pausing: " + r) ;
        //这里 和 是不是和 true 执行的方法一样
        return  finishCurrentActivityLocked(r , index ,
                FINISH_AFTER_PAUSE) ==  null;
    }  else {
        if (DEBUG_PAUSE) Slog.v(TAG ,  "Finish waiting for pause of: " + r) ;
    }

    return false;
}

private final ActivityRecord finishCurrentActivityLocked(ActivityRecord r ,
        int index , int mode) {
    // First things first: if this activity is currently visible,
    // and the resumed activity is not yet visible, then hold off on
    // finishing until the resumed one becomes visible.
    //如果这个将要显示的activity没有显示,就等待他显示之后执行关闭操作
    if (mode == FINISH_AFTER_VISIBLE && r.nowVisible) {
        if (!mStoppingActivities.contains(r)) {
            mStoppingActivities.add(r) ;
            if (mStoppingActivities.size() >  3) {
                // If we already have a few activities waiting to stop,
                // then give up on things going idle and start clearing
                // them out.
                scheduleIdleLocked() ;
            }  else {
                checkReadyForSleepLocked() ;
            }
        }
        if (DEBUG_STATES) Slog.v(TAG ,  "Moving to STOPPING: " + r
                +  " (finish requested)") ;
        r.state = ActivityState.STOPPING ;
        mService.updateOomAdjLocked() ;
        return r ;
    }

    // make sure the record is cleaned out of other places.
    //将存储的要finish的activiy的信息移除掉
    mStoppingActivities.remove(r) ;
    mGoingToSleepActivities.remove(r) ;
    mWaitingVisibleActivities.remove(r) ;
    if (mResumedActivity == r) {
        mResumedActivity =  null;
    }
    final ActivityState prevState = r.state ;
    if (DEBUG_STATES) Slog.v(TAG ,  "Moving to FINISHING: " + r) ;
    r.state = ActivityState.FINISHING ;

    if (mode == FINISH_IMMEDIATELY
            || prevState == ActivityState.STOPPED
            || prevState == ActivityState.INITIALIZING) {
        // If this activity is already stopped, we can just finish
        // it right now.
        boolean activityRemoved = destroyActivityLocked(r , true, true,  "finish-imm") ;
        if (activityRemoved) {
            resumeTopActivityLocked( null) ;
        }
        return activityRemoved ?  null : r ;
    }  else {
        // Need to go through the full pause cycle to get this
        // activity into the stopped state and then finish it.
        if (localLOGV) Slog.v(TAG ,  "Enqueueing pending finish: " + r) ;
        mFinishingActivities.add(r) ;
        //将resume的activity放到顶部
        resumeTopActivityLocked( null) ;
    }
    return r ;
}

在看 ActivityThread这个类

//这个变量是不是看起来非常眼熟 哈哈
final ApplicationThread mAppThread =  new ApplicationThread() ;
final Looper mLooper = Looper.myLooper() ;
final H mH =  new H() ;
final HashMap<IBinder , ActivityClientRecord> mActivities
        =  new HashMap<IBinder , ActivityClientRecord>() ;
// List of new activities (via ActivityRecord.nextIdle) that should
// be reported when next we idle.
ActivityClientRecord mNewActivities =  null;
// Number of activities that are currently visible on-screen.
int mNumVisibleActivities =  0 ;
final HashMap<IBinder , Service> mServices
        =  new HashMap<IBinder , Service>() ;
AppBindData mBoundApplication ;
Profiler mProfiler ;
Configuration mConfiguration ;
Configuration mCompatConfiguration ;
Configuration mResConfiguration ;
CompatibilityInfo mResCompatibilityInfo ;
Application mInitialApplication ;
final ArrayList<Application> mAllApplications
        =  new ArrayList<Application>() ;
// set of instantiated backup agents, keyed by package name
final HashMap<String , BackupAgent> mBackupAgents =  new HashMap<String , BackupAgent>() ;
static final ThreadLocal<ActivityThread> sThreadLocal =  new ThreadLocal<ActivityThread>() ;
Instrumentation mInstrumentation ;
String mInstrumentationAppDir =  null;
String mInstrumentationAppLibraryDir =  null;
String mInstrumentationAppPackage =  null;
String mInstrumentedAppDir =  null;
String mInstrumentedAppLibraryDir =  null;
boolean mSystemThread =  false;
boolean mJitEnabled =  false;

//这个内部类的方法是不是看起来更加的熟悉
private class ApplicationThread  extends ApplicationThreadNative {
    private static final String HEAP_COLUMN =  "%13s %8s %8s %8s %8s %8s %8s" ;
    private static final String ONE_COUNT_COLUMN =  "%21s %8d" ;
    private static final String TWO_COUNT_COLUMNS =  "%21s %8d %21s %8d" ;
    private static final String DB_INFO_FORMAT =  "  %8s %8s %14s %14s  %s" ;

    // Formatting for checkin service - update version if row format changes
    private static final int ACTIVITY_THREAD_CHECKIN_VERSION =  1 ;

    private void updatePendingConfiguration(Configuration config) {
        synchronized (mPackages) {
            if (mPendingConfiguration ==  null ||
                    mPendingConfiguration.isOtherSeqNewer(config)) {
                mPendingConfiguration = config ;
            }
        }
    }


    public final void schedulePauseActivity(IBinder token , boolean finished ,
            boolean userLeaving , int configChanges) {
        queueOrSendMessage(
                finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY ,
                token ,
                (userLeaving ?  1 :  0) ,
                configChanges) ;
    }

    public final void scheduleStopActivity(IBinder token , boolean showWindow ,
            int configChanges) {
       queueOrSendMessage(
            showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE ,
            token ,  0 , configChanges) ;
    }

    public final void scheduleWindowVisibility(IBinder token , boolean showWindow) {
        queueOrSendMessage(
            showWindow ? H.SHOW_WINDOW : H.HIDE_WINDOW ,
            token) ;
    }

    public final void scheduleSleeping(IBinder token , boolean sleeping) {
        queueOrSendMessage(H.SLEEPING , token , sleeping ?  1 :  0) ;
    }

    public final void scheduleResumeActivity(IBinder token , boolean isForward) {
        queueOrSendMessage(H.RESUME_ACTIVITY , token , isForward ?  1 :  0) ;
    }

    public final void scheduleSendResult(IBinder token , List<ResultInfo> results) {
        ResultData res =  new ResultData() ;
        res.token = token ;
        res.results = results ;
        queueOrSendMessage(H.SEND_RESULT , res) ;
    }

private void queueOrSendMessage( int what , Object obj , int arg1 , int arg2) {
    synchronized ( this) {
        if (DEBUG_MESSAGES) Slog.v(
            TAG ,  "SCHEDULE " + what +  " " + mH.codeToString(what)
            +  ": " + arg1 +  " / " + obj) ;
        Message msg = Message.obtain() ;
        msg.what = what ;
        msg.obj = obj ;
        msg.arg1 = arg1 ;
        msg.arg2 = arg2 ;
        mH.sendMessage(msg) ;
    }
}

private class H  extends Handler {
    public static final int LAUNCH_ACTIVITY         =  100 ;
    public static final int PAUSE_ACTIVITY          =  101 ;
    public static final int PAUSE_ACTIVITY_FINISHING=  102 ;
    public static final int STOP_ACTIVITY_SHOW      =  103 ;
    public static final int STOP_ACTIVITY_HIDE      =  104 ;
    public static final int SHOW_WINDOW             =  105 ;
    public static final int HIDE_WINDOW             =  106 ;
    public static final int RESUME_ACTIVITY         =  107 ;
    public static final int SEND_RESULT             =  108 ;
    public static final int DESTROY_ACTIVITY        =  109 ;
    public static final int BIND_APPLICATION        =  110 ;
    public static final int EXIT_APPLICATION        =  111 ;
    public static final int NEW_INTENT              =  112 ;
    public static final int RECEIVER                =  113 ;
    public static final int CREATE_SERVICE          =  114 ;
    public static final int SERVICE_ARGS            =  115 ;
    public static final int STOP_SERVICE            =  116 ;
    public static final int REQUEST_THUMBNAIL       =  117 ;
    public static final int CONFIGURATION_CHANGED   =  118 ;
    public static final int CLEAN_UP_CONTEXT        =  119 ;
    public static final int GC_WHEN_IDLE            =  120 ;
    public static final int BIND_SERVICE            =  121 ;
    public static final int UNBIND_SERVICE          =  122 ;
    public static final int DUMP_SERVICE            =  123 ;
    public static final int LOW_MEMORY              =  124 ;
    public static final int ACTIVITY_CONFIGURATION_CHANGED =  125 ;
    public static final int RELAUNCH_ACTIVITY       =  126 ;
    public static final int PROFILER_CONTROL        =  127 ;
    public static final int CREATE_BACKUP_AGENT     =  128 ;
    public static final int DESTROY_BACKUP_AGENT    =  129 ;
    public static final int SUICIDE                 =  130 ;
    public static final int REMOVE_PROVIDER         =  131 ;
    public static final int ENABLE_JIT              =  132 ;
    public static final int DISPATCH_PACKAGE_BROADCAST =  133 ;
    public static final int SCHEDULE_CRASH          =  134 ;
    public static final int DUMP_HEAP               =  135 ;
    public static final int DUMP_ACTIVITY           =  136 ;
    public static final int SLEEPING                =  137 ;
    public static final int SET_CORE_SETTINGS       =  138 ;
    public static final int UPDATE_PACKAGE_COMPATIBILITY_INFO =  139 ;
    public static final int TRIM_MEMORY             =  140 ;
    public static final int DUMP_PROVIDER           =  141 ;
    public static final int UNSTABLE_PROVIDER_DIED  =  142 ;

public void handleMessage(Message msg) {
    if (DEBUG_MESSAGES) Slog.v(TAG ,  ">>> handling: " + codeToString(msg.what)) ;
    switch (msg.what) {
        case LAUNCH_ACTIVITY: {
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER ,  "activityStart") ;
            ActivityClientRecord r = (ActivityClientRecord)msg.obj ;

            r.packageInfo = getPackageInfoNoCheck(
                    r.activityInfo.applicationInfo , r.compatInfo) ;
            handleLaunchActivity(r , null) ;
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER) ;
        }  break;
        case RELAUNCH_ACTIVITY: {
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER ,  "activityRestart") ;
            ActivityClientRecord r = (ActivityClientRecord)msg.obj ;
            handleRelaunchActivity(r) ;
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER) ;
        }  break;
        case PAUSE_ACTIVITY:
            // Trace 是不是出现了 
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER ,  "activityPause") ;
            handlePauseActivity((IBinder)msg.obj , false, msg.arg1 !=  0 , msg.arg2) ;
            maybeSnapshot() ;
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER) ;
            break;

private void handlePauseActivity(IBinder token , boolean finished ,
        boolean userLeaving , int configChanges) {
    ActivityClientRecord r = mActivities.get(token) ;
    if (r !=  null) {
        //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
        if (userLeaving) {
            performUserLeavingActivity(r) ;
        }

        r.activity.mConfigChangeFlags |= configChanges ;
        performPauseActivity(token , finished , r.isPreHoneycomb()) ;

        // Make sure any pending writes are now committed.
        if (r.isPreHoneycomb()) {
            QueuedWork.waitToFinish() ;
        }
       
        // Tell the activity manager we have paused.
        try {
            //最终结果 又走向了 ActivityManagerService
            ActivityManagerNative.getDefault().activityPaused(token) ;
        }  catch (RemoteException ex) {
        }
    }
}

只是简单粗略的来一个分析， 有时间  这几个类 还是要详细的看一下 其中还包含了好几个设计模式。