Android應用程序啟動過程

參考一
參考二

啟動流程
第一步Launcher.startActivitySafely()

說明:在Android系統中,應用程序是由Launcher啟動起來的,其實,Launcher本身也是一個應用程序,其它的應用程序安裝后,就會Launcher的界面上出現一個相應的圖標,點擊這個圖標時,Launcher就會對應的應用程序啟動起來。

/** 
* Default launcher application. 
*/  
public final class Launcher extends Activity  
        implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {  
  
    ......  
  
    /** 
    * Launches the intent referred by the clicked shortcut. 
    * 
    * @param v The view representing the clicked shortcut. 
    */  
    public void onClick(View v) {  
        Object tag = v.getTag();  
        if (tag instanceof ShortcutInfo) {  
            // Open shortcut  
            final Intent intent = ((ShortcutInfo) tag).intent;  
            int[] pos = new int[2];  
            v.getLocationOnScreen(pos);  
            intent.setSourceBounds(new Rect(pos[0], pos[1],  
                pos[0] + v.getWidth(), pos[1] + v.getHeight()));  
            startActivitySafely(intent, tag);  
        } else if (tag instanceof FolderInfo) {  
            ......  
        } else if (v == mHandleView) {  
            ......  
        }  
    }  
  
    void startActivitySafely(Intent intent, Object tag) {  
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
        try {  
            startActivity(intent);  
        } catch (ActivityNotFoundException e) {  
            ......  
        } catch (SecurityException e) {  
            ......  
        }  
    }  
  
    ......  
  
}  
第二步:Activity.startActivity()
public class Activity extends ContextThemeWrapper  
        implements LayoutInflater.Factory,  
        Window.Callback, KeyEvent.Callback,  
        OnCreateContextMenuListener, ComponentCallbacks {  
  
    ......  
  
    @Override  
    public void startActivity(Intent intent) {  
        startActivityForResult(intent, -1);  
    }  
  
    ......  
  
}  
第三步:Activtiy.startActivityForResult()

說明:
(1)mMainThread也是Activity類的成員變量,它的類型是ActivityThread,它代表的是應用程序的主線程。
(2)通過mMainThread.getApplicationThread獲得它里面的ApplicationThread成員變量,它是一個Binder對象,后面我們會看到,ActivityManagerService會使用它來和ActivityThread來進行進程間通信。
(3)這里的mMainThread代表的是Launcher應用程序運行的進程。
(4)mToken也是Activity類的成員變量,它是一個Binder對象的遠程接口。

public class Activity extends ContextThemeWrapper  
        implements LayoutInflater.Factory,  
        Window.Callback, KeyEvent.Callback,  
        OnCreateContextMenuListener, ComponentCallbacks {  
  
    ......  
  
    public void startActivityForResult(Intent intent, int requestCode) {  
        if (mParent == null) {  
            Instrumentation.ActivityResult ar =  
                mInstrumentation.execStartActivity(  
                this, mMainThread.getApplicationThread(), mToken, this,  
                intent, requestCode);  
            ......  
        } else {  
            ......  
        }  
  
  
    ......  
  
}  
第四步:Instrumentation.execStartActivity()

(1)Intent.resolveTypeIfNeeded返回這個intent的MIME類型
(2)Instrumentation.checkStartActivityResult():檢查啟動Activity的結果,會拋出各種異常,如Activity沒有注冊。
(3)ActivityManagetNative:繼承IActivityManager接口;相當于Stub(運行在SystemServer進程)
ActivityManagerService:實現了ActivityManagetNative抽象類
ActivityManagerNative.getDefault():返回ActivityMangerProxy;相當于Proxy(運行在應用程序進程)

public class Instrumentation {  
  
    ......  
  
    public ActivityResult execStartActivity(  
    Context who, IBinder contextThread, IBinder token, Activity target,  
    Intent intent, int requestCode) {  
        IApplicationThread whoThread = (IApplicationThread) contextThread;  
        if (mActivityMonitors != null) {  
            ......  
        }  
        try {  
            int result = ActivityManagerNative.getDefault()  
                .startActivity(whoThread, intent,  
                intent.resolveTypeIfNeeded(who.getContentResolver()),  
                null, 0, token, target != null ? target.mEmbeddedID : null,  
                requestCode, false, false);  
            ......  
        } catch (RemoteException e) {  
        }  
        return null;  
    }  
  
    ......  
  
}  
第五步:ActivityManagerNative.getDefalut.startActivity()

參數grantedUriPermissions和resultWho均為null;
參數caller為ApplicationThread類型的Binder實體;
參數resultTo為一個Binder實體的遠程接口,我們先不關注它;
參數grantedMode為0,我們也先不關注它;
參數requestCode為-1;
參數onlyIfNeeded和debug均空false。

class ActivityManagerProxy implements IActivityManager  
{  
  
    ......  
  
    public int startActivity(IApplicationThread caller, Intent intent,  
            String resolvedType, Uri[] grantedUriPermissions, int grantedMode,  
            IBinder resultTo, String resultWho,  
            int requestCode, boolean onlyIfNeeded,  
            boolean debug) throws RemoteException {  
        Parcel data = Parcel.obtain();  
        Parcel reply = Parcel.obtain();  
        data.writeInterfaceToken(IActivityManager.descriptor);  
        data.writeStrongBinder(caller != null ? caller.asBinder() : null);  
        intent.writeToParcel(data, 0);  
        data.writeString(resolvedType);  
        data.writeTypedArray(grantedUriPermissions, 0);  
        data.writeInt(grantedMode);  
        data.writeStrongBinder(resultTo);  
        data.writeString(resultWho);  
        data.writeInt(requestCode);  
        data.writeInt(onlyIfNeeded ? 1 : 0);  
        data.writeInt(debug ? 1 : 0);  
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);  
        reply.readException();  
        int result = reply.readInt();  
        reply.recycle();  
        data.recycle();  
        return result;  
    }  
  
    ......  
  
}  

ActivityManagerProxy和ActivityManagerNative

public abstract class ActivityManagerNative extends Binder implements IActivityManager
{

//從類聲明上,我們可以看到ActivityManagerNative是Binder的一個子類,而且實現了IActivityManager接口
 static public IActivityManager getDefault() {
        return gDefault.get();
    }

 //通過單例模式獲取一個IActivityManager對象,這個對象通過asInterface(b)獲得
 private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
        protected IActivityManager create() {
            IBinder b = ServiceManager.getService("activity");
            if (false) {
                Log.v("ActivityManager", "default service binder = " + b);
            }
            IActivityManager am = asInterface(b);
            if (false) {
                Log.v("ActivityManager", "default service = " + am);
            }
            return am;
        }
    };
}


//最終返回的還是一個ActivityManagerProxy對象
static public IActivityManager asInterface(IBinder obj) {
        if (obj == null) {
            return null;
        }
        IActivityManager in =
            (IActivityManager)obj.queryLocalInterface(descriptor);
        if (in != null) {
            return in;
        }

     //這里面的Binder類型的obj參數會作為ActivityManagerProxy的成員變量保存為mRemote成員變量,負責進行IPC通信
        return new ActivityManagerProxy(obj);
    }

第六步:ActivityManagerService.startActivity()

(1)將操作轉發給成員變量mMainStack的startActivityMayWait函數,這里的mMainStack的類型為ActivityStack。

public final class ActivityManagerService extends ActivityManagerNative  
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  
    ......  
  
    public final int startActivity(IApplicationThread caller,  
            Intent intent, String resolvedType, Uri[] grantedUriPermissions,  
            int grantedMode, IBinder resultTo,  
            String resultWho, int requestCode, boolean onlyIfNeeded,  
            boolean debug) {  
        return mMainStack.startActivityMayWait(caller, intent, resolvedType,  
            grantedUriPermissions, grantedMode, resultTo, resultWho,  
            requestCode, onlyIfNeeded, debug, null, null);  
    }  
  
  
    ......  
  
}  
第七步: ActivityStack.startActivityMayWait()
public class ActivityStack {  
  
    ......  
  
    final int startActivityMayWait(IApplicationThread caller,  
            Intent intent, String resolvedType, Uri[] grantedUriPermissions,  
            int grantedMode, IBinder resultTo,  
            String resultWho, int requestCode, boolean onlyIfNeeded,  
            boolean debug, WaitResult outResult, Configuration config) {  
  
        ......  
  
        boolean componentSpecified = intent.getComponent() != null;  
  
        // Don't modify the client's object!  
        intent = new Intent(intent);  
  
        // Collect information about the target of the Intent.  
        ActivityInfo aInfo;  
        try {  
            ResolveInfo rInfo =  
                AppGlobals.getPackageManager().resolveIntent(  
                intent, resolvedType,  
                PackageManager.MATCH_DEFAULT_ONLY  
                | ActivityManagerService.STOCK_PM_FLAGS);  
            aInfo = rInfo != null ? rInfo.activityInfo : null;  
        } catch (RemoteException e) {  
            ......  
        }  
  
        if (aInfo != null) {  
            // Store the found target back into the intent, because now that  
            // we have it we never want to do this again.  For example, if the  
            // user navigates back to this point in the history, we should  
            // always restart the exact same activity.  
            intent.setComponent(new ComponentName(  
                aInfo.applicationInfo.packageName, aInfo.name));  
            ......  
        }  
  
        synchronized (mService) {  
            int callingPid;  
            int callingUid;  
            if (caller == null) {  
                ......  
            } else {  
                callingPid = callingUid = -1;  
            }  
  
            mConfigWillChange = config != null  
                && mService.mConfiguration.diff(config) != 0;  
  
            ......  
  
            if (mMainStack && aInfo != null &&  
                (aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {  
                    
                      ......  
  
            }  
  
            int res = startActivityLocked(caller, intent, resolvedType,  
                grantedUriPermissions, grantedMode, aInfo,  
                resultTo, resultWho, requestCode, callingPid, callingUid,  
                onlyIfNeeded, componentSpecified);  
  
            if (mConfigWillChange && mMainStack) {  
                ......  
            }  
  
            ......  
  
            if (outResult != null) {  
                ......  
            }  
  
            return res;  
        }  
  
    }  
  
    ......  
  
}  
第六步:在ActivityStack和ActivitySupervisior之間來回調用方法
第七步:ActivityStackSupervisor.realStartActivityLocked()
第八步:AppliactionThreadProxy.scheduleLauchActivity()(SystemServer進程+Binder通信過程)

過程:通過Handler H發送一條消息給 H處理。
說明:
AppliactionThread:繼承AppliactionThreadNative;ActivityThread的內部類,負責ActivityThread和AMS之間的通信;相當于Stub實現類
ApplicationThreadProxy:實現IApplicationThread;相當于Proxy;
AAppliactionThreadNative:相當于Stub;實現IApplicationThread。

第九步:ActivityThread.handleLaunchActivity()

過程:調用ActivityThread.performLauchActivity()

第十步:ActivityThread.performLauchActivity()

(1)從ActivityClientRecord中獲取待啟動的Activity的組件信息
(2)通過Instrumentation的newActivity方法使用類加載器創建Activity對象
(3)通過LoadedApk的makeApplication方法來嘗試創建Application對象。
(4)創建ContextImpl對象,并通過Activity的attach方法來完成一些重要數據的初始化。
(5)調用Activity的onCreate方法

總結

一. Launcher通過Binder進程間通信機制通知ActivityManagerService,它要啟動一個Activity;
二. ActivityManagerService通過Binder進程間通信機制通知Launcher進入Paused狀態;
三. Launcher通過Binder進程間通信機制通知ActivityManagerService,它已經準備就緒進入Paused狀態,于是ActivityManagerService就創建一個新的進程,用來啟動一個ActivityThread實例,即將要啟動的Activity就是在這個ActivityThread實例中運行;
四. ActivityThread通過Binder進程間通信機制將一個ApplicationThread類型的Binder對象傳遞給ActivityManagerService,以便以后ActivityManagerService能夠通過這個Binder對象和它進行通信;
五. ActivityManagerService通過Binder進程間通信機制通知ActivityThread,現在一切準備就緒,它可以真正執行Activity的啟動操作了。

最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。

推薦閱讀更多精彩內容