Android 系统架构 —— 图形渲染的准备

public final class ActivityThread extends ClientTransactionHandler {
    
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ......
        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);
            if (activity != null) {
                ......
                // 给 Activity 绑定数据
                activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor, window, r.configCallback);
                ......
                if (r.isPersistable()) {
                    // 回调 OnCreate()
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
                ......
            }
            ......

        }
        ......
        return activity;
    }
    
}

public class Activity extends ContextThemeWrapper {

    final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window, ActivityConfigCallback activityConfigCallback) {
        ......
        // 1. 构建了 PhoneWindow 对象
        mWindow = new PhoneWindow(this, window, activityConfigCallback);
        ......
        // 2. 给这个 Window 设置了 WindowManager
        mWindow.setWindowManager(
                (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
                mToken, mComponent.flattenToString(),
                (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
        ......
        // 3. 将与这个 Window 绑定的 WindowManager 保存在 mWindowManager 成员变量中
        mWindowManager = mWindow.getWindowManager();
    }
}

public class Window {
    
    public void setWindowManager(WindowManager wm, IBinder appToken, String appName,
            boolean hardwareAccelerated) {
        // 若 wm 为 null, 则当前 Context 在 SystemServiceRegistry 中注册的 WindowManagerImpl 对象
        if (wm == null) {
            wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
        }
        // 通过 WindowManager 的实例创建了一个新的 WindowManager 提供给自己使用
        mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);
    }
    
}

class ContextImpl extends Context {
    
     @Override
    public Object getSystemService(String name) {
        return SystemServiceRegistry.getSystemService(this, name);
    }
    
}

final class SystemServiceRegistry {
    
    // 服务获取器缓存(并非服务对象)
    private static final HashMap<String, ServiceFetcher<?>> SYSTEM_SERVICE_FETCHERS =
            new HashMap<String, ServiceFetcher<?>>();
    
    public static Object getSystemService(ContextImpl ctx, String name) {
        // 1. 通过 SYSTEM_SERVICE_FETCHERS 缓存的服务获取器
        ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
        // 2. 通过服务获取器 fetcher, 获取服务对象
        return fetcher != null ? fetcher.getService(ctx) : null;
    }
}

final class SystemServiceRegistry {

    // 服务名的缓存
    private static final HashMap<Class<?>, String> SYSTEM_SERVICE_NAMES =
            new HashMap<Class<?>, String>();
    // 服务获取器缓存(并非服务对象)
    private static final HashMap<String, ServiceFetcher<?>> SYSTEM_SERVICE_FETCHERS =
            new HashMap<String, ServiceFetcher<?>>();
    
    static {
        ......
        // 注册 WINDOW_SERVICE
        registerService(
            Context.WINDOW_SERVICE,
            WindowManager.class,
            // 注册了一个实例获取器
            new CachedServiceFetcher<WindowManager>() {
                @Override
                public WindowManager createService(ContextImpl ctx) {
                    return new WindowManagerImpl(ctx);
                }
            }
        );
        ......
    }
    
    private static <T> void registerService(String serviceName, Class<T> serviceClass,
            ServiceFetcher<T> serviceFetcher) {
        // 添加到 服务名称 缓存
        SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
        // 添加 服务获取器 的缓存
        SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
    }
    
}

final class SystemServiceRegistry {
    
    // 记录所有注册的缓存服务获取器的数量
    private static int sServiceCacheSize;
    
    static abstract class CachedServiceFetcher<T> implements ServiceFetcher<T> {
    
        // 构建的时候便会为这个 ServiceFetcher 创建一个 CacheIndex 代表其索引值
        private final int mCacheIndex;

        CachedServiceFetcher() {
            mCacheIndex = sServiceCacheSize++;
        }

        @Override
        @SuppressWarnings("unchecked")
        public final T getService(ContextImpl ctx) {
            // 从 ctx 中获取其中服务缓存数组(大小为 sServiceCacheSize)
            final Object[] cache = ctx.mServiceCache;
            // 从 ctx 中获取缓存的服务状态数组(大小为 sServiceCacheSize)
            final int[] gates = ctx.mServiceInitializationStateArray;

            for (;;) {
                boolean doInitialize = false;
                synchronized (cache) {
                    // 1. 尝试从 Context 的缓存中获取这个服务, 
                    // 我们知道这个 Context 是 Activity 创建时构建的一个 ContextImpl 对象
                    // 若是第一次调用 getService, ContextImpl 不存在这个缓存
                    T service = (T) cache[mCacheIndex];
                    if (service != null || gates[mCacheIndex] == ContextImpl.STATE_NOT_FOUND) {
                        // 1.1 若存在, 则直接将这个对象返回给调用方
                        return service;
                    }

                    // 1.2 如果 Context 缓存池中该服务的状态是 STATE_READY, 则说明之前创建过一次, 但实例被恶意清除了
                    if (gates[mCacheIndex] == ContextImpl.STATE_READY) {
                        // 将其置为 UNINITIALIZED 状态
                        gates[mCacheIndex] = ContextImpl.STATE_UNINITIALIZED;
                    }
                    // 1.3 将 doInitialize 置为 true, 状态变更为 INITIALIZING
                    if (gates[mCacheIndex] == ContextImpl.STATE_UNINITIALIZED) {
                        doInitialize = true;
                        gates[mCacheIndex] = ContextImpl.STATE_INITIALIZING;
                    }
                }
                // 2. 创建服务并且缓存到 Context 对象的缓存池中
                if (doInitialize) {
                    T service = null;
                    // 2.1 将这个服务的新状态初始化为 STATE_NOT_FOUND
                    int newState = ContextImpl.STATE_NOT_FOUND;
                    try {
                        // 2.2 这里调用了注册时重写的 createService, 便可拿到这个实例对象了
                        service = createService(ctx);
                        // 2.3 将这个服务的状态初始化为 STATE_READY
                        newState = ContextImpl.STATE_READY;
                    } catch (ServiceNotFoundException e) {
                        ......
                    } finally {
                        // 2.4 在 Context 的服务缓存数组中保存这个服务的缓存
                        synchronized (cache) {
                            cache[mCacheIndex] = service;
                            gates[mCacheIndex] = newState;
                            cache.notifyAll();
                        }
                    }
                    return service;
                }
                ......
            }
        }

        public abstract T createService(ContextImpl ctx) throws ServiceNotFoundException;
    }
}

public class Window {
    
    public void setWindowManager(WindowManager wm, IBinder appToken, String appName,
            boolean hardwareAccelerated) {
        // 如何获取 WindowManger 这里已经分析过了
        if (wm == null) {
            wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
        }
        // 通过 WindowManager 的实例创建了一个新的 WindowManager 提供给自己使用
        mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);
    }
    
}

public final class WindowManagerImpl implements WindowManager {
    // 管理 Window 真正的实现
    private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
    // 上下文
    private final Context mContext;
    // 描述 WindowManager 要管理的 Window 
    private final Window mParentWindow;
    
    // 调用了该方法重新创建了一个 WindowManager
    public WindowManagerImpl createLocalWindowManager(Window parentWindow) {
        // 这里创建时的 Context 沿用了当前对象的成员变量
        return new WindowManagerImpl(mContext, parentWindow);
    }

    // Constructor 1
    public WindowManagerImpl(Context context) {
        this(context, null);
    }
    
    // Constructor 2
    private WindowManagerImpl(Context context, Window parentWindow) {
        mContext = context;
        mParentWindow = parentWindow;
    }

}

public class Activity extends ContextThemeWrapper { 
    
    public void setContentView(@LayoutRes int layoutResID) {
        // 获取 Activity.attach 中创建的 PhoneWindow 对象, 调用其 setContentView 
        getWindow().setContentView(layoutResID);
        ......
    }
    
}

public class PhoneWindow extends Window implements MenuBuilder.Callback {
    
    private LayoutInflater mLayoutInflater;
    ViewGroup mContentParent;
 
     @Override
    public void setContentView(int layoutResID) {
        if (mContentParent == null) {
            // 1. 给 Window 填充 DecorView 
            installDecor();
        } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
            ......
        }

        if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
            ......// 处理 Sence 场景动画
        } else {
            // 2. 构建我们搭建的布局填充到 mContentParent 中
            mLayoutInflater.inflate(layoutResID, mContentParent);
        }
        ......
    }
    
}

public class PhoneWindow extends Window implements MenuBuilder.Callback {
    
    private void installDecor() {
        if (mDecor == null) {
            // 1. 创建了 DecorView 的对象
            mDecor = generateDecor(-1);
        } else {
            // 若不为null, 则让 DecorView 直接与当前的 Window 对象绑定
            mDecor.setWindow(this);
        }
        // 2. 构建 mContentParent
        if (mContentParent == null) {
            mContentParent = generateLayout(mDecor);
        }
    }
}

public class PhoneWindow extends Window implements MenuBuilder.Callback {

    protected DecorView generateDecor(int featureId) {
        Context context;
        if (mUseDecorContext) {
            ...... // 创建 DecorView 的Context
        } else {
            context = getContext();
        }
        // 1.1 创建了 DecorView, 可以看到 this 为当前 Window 的实例
        return new DecorView(context, featureId, this, getAttributes());
    }

}

public class PhoneWindow extends Window implements MenuBuilder.Callback {

    public static final int ID_ANDROID_CONTENT = com.android.internal.R.id.content;
    
    protected ViewGroup generateLayout(DecorView decor) {
        ......
        // 1. 找寻 Android 系统提供给 DecorView 的填充布局, 存入 layoutResource 中
        // 这些布局文件中均有一个 ID 为 ID_ANDROID_CONTENT 的 View
        int layoutResource;
        ......
        
        // 2. 将 layoutResource 布局文件解析成 View 添加到了 DecorView 之中
        mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);
        // 3 通过 findViewById 给 contentParent 赋值
        ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);
        
        ......
        return contentParent;
    }
    
    public <T extends View> T findViewById(@IdRes int id) {
        // 通过 DecorView 找寻视图
        return getDecorView().findViewById(id);
    }
}

public class DecorView extends FrameLayout {

   // 若 Window 不需要这个 View, 则为 null
   DecorCaptionView mDecorCaptionView;
   ViewGroup mContentRoot;
   
   void onResourcesLoaded(LayoutInflater inflater, int layoutResource) {
        mDecorCaptionView = createDecorCaptionView(inflater);
        // 1. 根据 layoutResource 创建 root
        final View root = inflater.inflate(layoutResource, null);
        if (mDecorCaptionView != null) {
            ......
        } else {
            ......
            // 2. 添加到 DecorView 中, 作为其子容器
            addView(root, 0, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
        }
        // 3. 赋值给成员变量
        mContentRoot = (ViewGroup) root;
    }
    
}

class WindowState extends WindowContainer<WindowState> implements WindowManagerPolicy.WindowState {
    
    final Session mSession;
    
    void attach() {
        // 调用了 Session.windowAddedLocked 方法
        mSession.windowAddedLocked(mAttrs.packageName);
    }
    
}

class Session extends IWindowSession.Stub implements IBinder.DeathRecipient {
    
    SurfaceSession mSurfaceSession;
    private int mNumWindow = 0;

    void windowAddedLocked(String packageName) {
        mPackageName = packageName;
        if (mSurfaceSession == null) {
            // 这里创建了一个 SurfaceSession 对象
            mSurfaceSession = new SurfaceSession();
            // 添加到 WMS 的缓存中
            mService.mSessions.add(this);
            ......
        }
        // 表示这个 Session 对象所管理的进程中, 又多了一个 Window
        mNumWindow++;
    }
    
}

public final class SurfaceSession {
    // 描述 SurfaceComposerClient 的句柄
    private long mNativeClient;

    public SurfaceSession() {
        // 调用了 nativeCreate 获取了一个句柄值
        mNativeClient = nativeCreate();
    }
    
    private static native long nativeCreate();
}

// frameworks/base/core/jni/android_view_SurfaceSession.cpp
static jlong nativeCreate(JNIEnv* env, jclass clazz) {
    // 可以看到创建了一个 SurfaceComposerClient 的 C++ 对象
    SurfaceComposerClient* client = new SurfaceComposerClient();
    client->incStrong((void*)nativeCreate);// 增加一个强引用
    // 返回给 Java 层一个句柄值
    return reinterpret_cast<jlong>(client);
}