frameworks 之 SystemServiceRegistry

frameworks 之触摸事件窗口查找

[1. SystemServiceRegistry 获取服务](#1. SystemServiceRegistry 获取服务)
[2. ServiceFetcher 获取流程](#2. ServiceFetcher 获取流程)
[3. ServiceFetcher 注册](#3. ServiceFetcher 注册)

讲解 SystemServiceRegistry 获取系统服务管理类流程
涉及到的类如下

frameworks/base/core/java/android/app/SystemServiceRegistry.java

1. SystemServiceRegistry 获取服务

通过 context 获取的 getSystemService 服务最终都会调用 SystemServiceRegistry 的getSystemService方法。该方法流程

从 SYSTEM_SERVICE_FETCHERS hashMap 里面通过名称获取对应的 fetcher对象
判断获取回来的 fetcher 对象是否为空，为空则根据是否打印日志返回 null
如果不为空，在调用 getService 方法获取对应的对象
判断是否为空，为空且打印日志则打印，并返回对应的对象

java 复制代码

	public static Object getSystemService(ContextImpl ctx, String name) {
        if (name == null) {
            return null;
        }
        // 从缓存中获取是否为空
        final ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
        if (fetcher == null) {
            if (sEnableServiceNotFoundWtf) {
                Slog.wtf(TAG, "Unknown manager requested: " + name);
            }
            return null;
        }
        // 调用 getService 里面会判断是否有对象 没有将调用对应的 createService 方法
        final Object ret = fetcher.getService(ctx);
        if (sEnableServiceNotFoundWtf && ret == null) {
            // Some services do return null in certain situations, so don't do WTF for them.
            switch (name) {
                case Context.CONTENT_CAPTURE_MANAGER_SERVICE:
                case Context.APP_PREDICTION_SERVICE:
                case Context.INCREMENTAL_SERVICE:
                case Context.ETHERNET_SERVICE:
                    return null;
            }
            Slog.wtf(TAG, "Manager wrapper not available: " + name);
            return null;
        }
        return ret;
    }

2. ServiceFetcher 获取流程

ServiceFetcher 是一个接口类对应实现的类为 CachedServiceFetcher。CachedServiceFetcher 初始化构造方法会通过静态变量 sServiceCacheSize 进行自增，并保存到 mCacheIndex 队列下

java 复制代码

		CachedServiceFetcher() {
            // Note this class must be instantiated only by the static initializer of the
            // outer class (SystemServiceRegistry), which already does the synchronization,
            // so bare access to sServiceCacheSize is okay here.
            // 自增当前注册的数量
            mCacheIndex = sServiceCacheSize++;
        }

查看对应的 getService 方法。该方法主要步骤

从对应的context 获取缓存的数组和缓存的状态
根据初始化的 mCacheIndex获取对应的缓存数组如果有则返回
获取不到将对应的状态设置为没初始化，并将判断是否未初始化，没有的话置为初始化中，并将变量值为 doInitialize
通过调用对应的 createService 方法获取，果找到就将状态置为STATE_READY，否则抛异常接下来循环获取直到状态为 STATE_READY 或者 STATE_NOT_FOUND

java 复制代码

		public final T getService(ContextImpl ctx) {
            // 当前 context 缓存的数组
            final Object[] cache = ctx.mServiceCache;
            // 当前 context对应服务的情况
            final int[] gates = ctx.mServiceInitializationStateArray;
            boolean interrupted = false;

            T ret = null;

            for (;;) {
                boolean doInitialize = false;
                synchronized (cache) {
                    // Return it if we already have a cached instance.
                    // 获取当前 context的下标是否已经缓存，缓存了就直接返回
                    T service = (T) cache[mCacheIndex];
                    if (service != null) {
                        ret = service;
                        break; // exit the for (;;)
                    }

                    // If we get here, there's no cached instance.

                    // Grr... if gate is STATE_READY, then this means we initialized the service
                    // once but someone cleared it.
                    // We start over from STATE_UNINITIALIZED.
                    // Similarly, if the previous attempt returned null, we'll retry again.
                    // 将对应的状态设置为没初始化
                    if (gates[mCacheIndex] == ContextImpl.STATE_READY
                            || gates[mCacheIndex] == ContextImpl.STATE_NOT_FOUND) {
                        gates[mCacheIndex] = ContextImpl.STATE_UNINITIALIZED;
                    }

                    // It's possible for multiple threads to get here at the same time, so
                    // use the "gate" to make sure only the first thread will call createService().

                    // At this point, the gate must be either UNINITIALIZED or INITIALIZING.
                    // 判断是否未初始化，没有的话置为初始化中，并将变量值为 doInitialize
                    if (gates[mCacheIndex] == ContextImpl.STATE_UNINITIALIZED) {
                        doInitialize = true;
                        gates[mCacheIndex] = ContextImpl.STATE_INITIALIZING;
                    }
                }

                if (doInitialize) {
                    // Only the first thread gets here.

                    T service = null;
                    @ServiceInitializationState int newState = ContextImpl.STATE_NOT_FOUND;
                    try {
                        // This thread is the first one to get here. Instantiate the service
                        // *without* the cache lock held.
                        // 调用对应的 createService, 如果找到就将状态置为STATE_READY，否则抛异常
                        service = createService(ctx);
                        newState = ContextImpl.STATE_READY;

                    } catch (ServiceNotFoundException e) {
                        onServiceNotFound(e);

                    } finally {
                        synchronized (cache) {
                            // 将状态放到最新的数组里
                            cache[mCacheIndex] = service;
                            gates[mCacheIndex] = newState;
                            cache.notifyAll();
                        }
                    }
                    ret = service;
                    break; // exit the for (;;)
                }
                // The other threads will wait for the first thread to call notifyAll(),
                // and go back to the top and retry.
                synchronized (cache) {
                    // Repeat until the state becomes STATE_READY or STATE_NOT_FOUND.
                    // We can't respond to interrupts here; just like we can't in the "doInitialize"
                    // path, so we remember the interrupt state here and re-interrupt later.
                    // 一直循环，直到状态为 STATE_READY 或者 STATE_NOT_FOUND
                    while (gates[mCacheIndex] < ContextImpl.STATE_READY) {
                        try {
                            // Clear the interrupt state.
                            interrupted |= Thread.interrupted();
                            cache.wait();
                        } catch (InterruptedException e) {
                            // This shouldn't normally happen, but if someone interrupts the
                            // thread, it will.
                            Slog.w(TAG, "getService() interrupted");
                            interrupted = true;
                        }
                    }
                }
            }
            if (interrupted) {
                Thread.currentThread().interrupt();
            }
            return ret;
        }

3. ServiceFetcher 注册

所有的注册对应代码在 SystemServiceRegistry 的静态代码块中，也就是说当SystemServiceRegistry类初始化的时候 ,就会在其静态代码块执行注册。并实现其对应的 createService 方法。

java 复制代码

static {
        //CHECKSTYLE:OFF IndentationCheck
        registerService(Context.ACCESSIBILITY_SERVICE, AccessibilityManager.class,
                new CachedServiceFetcher<AccessibilityManager>() {
            @Override
            public AccessibilityManager createService(ContextImpl ctx) {
                return AccessibilityManager.getInstance(ctx);
            }});
            ......
}

frameworks 之 SystemServiceRegistry

frameworks 之 触摸事件窗口查找

1. SystemServiceRegistry 获取服务

2. ServiceFetcher 获取流程

3. ServiceFetcher 注册

frameworks 之触摸事件窗口查找