【安卓12源码】WMS的作用及其启动流程

最新推荐文章于 2024-07-24 21:35:56 发布
最新推荐文章于 2024-07-24 21:35:56 发布
阅读量2.3k 收藏 14
点赞数 2
分类专栏： 安卓源码解析 文章标签： android 安卓源码 framework wms 图形系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40587575/article/details/131671365
版权

 一、WMS 的作用

WMS 在 Android 系统的地位，它作为中间层，连接了上层的 View 框架和下层的 SurfaceFingler。

  • WMS 主要职责
  • 窗口管理：负责启动、添加、删除窗口，管理窗口大小、层级，核心成员有：WindowContainer、RootWindowContainer、DisplayContent、TaskStack、Task、AppWindowToken、WindowState；
  • 窗口动画：由其子系统 WindowAnimator 管理；
  • 输入系统中转站：通过对窗口的触摸从而产生触摸事件，由 InputMethodService（IMS）对触摸事件进行处理，它会寻找一个最合适的窗口处理触摸反馈信息；
  • Surface 管理：为每个窗口分配一块 Surface，用于绘制要显示的内容。

  •  WMS重要的类

  • WMS继承于IWindowManager.Stub,作为Binder服务端
  • 成员变量mSessions保存所有的Session对象，Session继承于IWindowSession.Stub，作为Binder服务端.Session的创建在 WindowState 的attach方法中：mSession.windowAddedLocked
  • 成员变量mPolicy，实例是PhoneWindowManager，用于实现各种窗口相关的策略
  • 成员变量mWindowMap,保存所有的WindowState对象;以IBinder为key, 是IWindow的Bp端;
  • 每个窗口都对应一个WindowState对象, 该对象的成员变量mClient用于跟应用端交互,成员变量mToken用于跟AMS交互,WindowState的attach方法与SurfaceFlinger通信。
  • WindowManager与WindowManagerService通过Session进行通信，具体的实现由WMS处理。
  • WindowManager实现类是WindowManagerImpl ；
  • WindowManagerImpl 中成员变量 mParentWindow （Window）,mGlobal (WindowManagerGlobal)

AMS,WMS之间数据是对应的,通过token值可以在AMS,WMS,应用程序之后来唯一确定一组Window,token是关联着一组窗口的，可能有多个WindowState的token值是相同的. 

二、WMS 的启动流程

wms 是运行在systemsever 系统进程的，在启动system  进程的时候，去初始化了 WMS

/frameworks/base/services/java/com/android/server/SystemServer.java

    private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
        t.traceBegin("startOtherServices");

        WindowManagerService wm = null;

            t.traceBegin("StartInputManagerService");

// wms与 InputManagerService 息息相关，创建 InputManagerService 对象
            inputManager = new InputManagerService(context);
            t.traceEnd();

            t.traceBegin("StartWindowManagerService");
            // WMS needs sensor service ready
            mSystemServiceManager.startBootPhase(t, SystemService.PHASE_WAIT_FOR_SENSOR_SERVICE);

// 1. 创建 WindowManagerService 对象
            wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore,
                    new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager);

// 将 WindowManagerService 和 InputManagerService 添加到服务中
            ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,
                    DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);
            ServiceManager.addService(Context.INPUT_SERVICE, inputManager,
                    /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);

// 2. wms 与 ams 关联
            mActivityManagerService.setWindowManager(wm);

// 3. 初始化完成
            wm.onInitReady();

// 4. InputManagerService 设置回调，并启动 InputManagerService 
            inputManager.setWindowManagerCallbacks(wm.getInputManagerCallback());
            inputManager.start();

// 5. 调用 displayReady 方法
            wm.displayReady();

// 6. 系统准备完毕，调用 systemReady
            wm.systemReady();

        final Configuration config = wm.computeNewConfiguration(DEFAULT_DISPLAY);

1. 创建 WindowManagerService 对象

WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore,
                    new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager);

    public static WindowManagerService main(final Context context, final InputManagerService im,
            final boolean showBootMsgs, final boolean onlyCore, WindowManagerPolicy policy,
            ActivityTaskManagerService atm) {

// policy 是值是 new PhoneWindowManager()，继承了 WindowManagerPolicy
        return main(context, im, showBootMsgs, onlyCore, policy, atm,

// 一个Supplier可以通过lambda表达式、方法引用或默认构造函数来实例化。
// Supplier在Java 8中被引入，属于java.util.function包
// transactionFactory 为 SurfaceControl.Transaction::new，创建 Transaction 对象
// 通过get 可以获取到对象 Transaction
                new DisplayWindowSettingsProvider(), SurfaceControl.Transaction::new, Surface::new,
                SurfaceControl.Builder::new);
    }


==========
    @VisibleForTesting
    public static WindowManagerService main(final Context context, final InputManagerService im,
            final boolean showBootMsgs, final boolean onlyCore, WindowManagerPolicy policy,
            ActivityTaskManagerService atm, DisplayWindowSettingsProvider
            displayWindowSettingsProvider, Supplier<SurfaceControl.Transaction> transactionFactory,
            Supplier<Surface> surfaceFactory,
            Function<SurfaceSession, SurfaceControl.Builder> surfaceControlFactory) {

// 在 android.display 实例化 wms，所以wms 跑在android.display线程中 
        DisplayThread.getHandler().runWithScissors(() ->
                sInstance = new WindowManagerService(context, im, showBootMsgs, onlyCore, policy,
                        atm, displayWindowSettingsProvider, transactionFactory, surfaceFactory,
                        surfaceControlFactory), 0);
        return sInstance;
    }

PhoneWindowManager,主要是负责窗口管理的各种策略。在 android.display 实例化 wms，所以wms 跑在android.display线程中 

/frameworks/base/services/core/java/com/android/server/DisplayThread.java

// ServiceThread 继承了 HandlerThread 

public final class DisplayThread extends ServiceThread {
    private static DisplayThread sInstance;
    private static Handler sHandler;

    private DisplayThread() {
        // DisplayThread runs important stuff, but these are not as important as things running in
        // AnimationThread. Thus, set the priority to one lower.

// 线程名字为 "android.display"，优先级为 -3
        super("android.display", Process.THREAD_PRIORITY_DISPLAY + 1, false /*allowIo*/);
    }

    private static void ensureThreadLocked() {
        if (sInstance == null) {
            sInstance = new DisplayThread();
            sInstance.start();
            sInstance.getLooper().setTraceTag(Trace.TRACE_TAG_SYSTEM_SERVER);

// 创建handler，looper 为 thread "android.display" 的looper
            sHandler = new Handler(sInstance.getLooper());
        }
    }

// 获取到handler
    public static Handler getHandler() {
        synchronized (DisplayThread.class) {
            ensureThreadLocked();
            return sHandler;
        }
    }

handler 执行 runWithScissors 方法

/frameworks/base/core/java/android/os/Handler.java

    public final boolean runWithScissors(@NonNull Runnable r, long timeout) {
        if (r == null) {
            throw new IllegalArgumentException("runnable must not be null");
        }
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout must be non-negative");
        }

// 当前looper 不相等
        if (Looper.myLooper() == mLooper) {
            r.run();
            return true;
        }

// 将其pos 到 BlockingRunnable
        BlockingRunnable br = new BlockingRunnable(r);
        return br.postAndWait(this, timeout);
    }

===========
        public BlockingRunnable(Runnable task) {
            mTask = task;
        }

        @Override
        public void run() {
            try {
                mTask.run();
            } finally {
                synchronized (this) {
                    mDone = true;
// 执行完则唤醒系统主线程
                    notifyAll();
                }
            }
        }

        public boolean postAndWait(Handler handler, long timeout) {
// 将其增加到消息队列中
            if (!handler.post(this)) {
                return false;
            }

            synchronized (this) {
                if (timeout > 0) {
。。
                } else {
                    while (!mDone) {
                        try {
// 阻塞systemserver 主线程
                            wait();
                        } catch (InterruptedException ex) {
                        }
                    }
                }
            }
            return true;
        }
    }

DisplayThread 给系统使用的共享单例前台线程类，线程名字为 android.display，专门提供给WindowManager, DisplayManager, and InputManager来执行快速响应的实时操作。

执行构造函数

    private WindowManagerService(Context context, InputManagerService inputManager,
            boolean showBootMsgs, boolean onlyCore, WindowManagerPolicy policy,
            ActivityTaskManagerService atm, DisplayWindowSettingsProvider
            displayWindowSettingsProvider, Supplier<SurfaceControl.Transaction> transactionFactory,
            Supplier<Surface> surfaceFactory,
            Function<SurfaceSession, SurfaceControl.Builder> surfaceControlFactory) {
        installLock(this, INDEX_WINDOW);

// 锁机制与 atm 一致
        mGlobalLock = atm.getGlobalLock();
// 缓存 AtmS
        mAtmService = atm;
        mContext = context;
。。。
// 是否允许在低电量开启动画
        mAllowAnimationsInLowPowerMode = context.getResources().getBoolean(
                com.android.internal.R.bool.config_allowAnimationsInLowPowerMode);

// 缓存 inputManager
        mInputManager = inputManager; // Must be before createDisplayContentLocked.
        mDisplayManagerInternal = LocalServices.getService(DisplayManagerInternal.class);

        mSurfaceControlFactory = surfaceControlFactory;
        mTransactionFactory = transactionFactory;
        mSurfaceFactory = surfaceFactory;
// 获取 Transaction  对象
        mTransaction = mTransactionFactory.get();

// policy 为：PhoneWindowManager
        mPolicy = policy;
// 创建 WindowAnimator 对象
        mAnimator = new WindowAnimator(this);
// 创建 RootWindowContainer 对象
        mRoot = new RootWindowContainer(this);

        final ContentResolver resolver = context.getContentResolver();
        mUseBLAST = Settings.Global.getInt(resolver,
            Settings.Global.DEVELOPMENT_USE_BLAST_ADAPTER_VR, 1) == 1;

        mSyncEngine = new BLASTSyncEngine(this);

        mWindowPlacerLocked = new WindowSurfacePlacer(this);
// 任务快照控制类
        mTaskSnapshotController = new TaskSnapshotController(this);

        mWindowTracing = WindowTracing.createDefaultAndStartLooper(this,
                Choreographer.getInstance());

        LocalServices.addService(WindowManagerPolicy.class, mPolicy);

        mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE);

// mH 为  final H mH = new H();
        mKeyguardDisableHandler = KeyguardDisableHandler.create(mContext, mPolicy, mH);

        mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
        mPowerManagerInternal = LocalServices.getService(PowerManagerInternal.class);

// 注册低电量观察者
        if (mPowerManagerInternal != null) {
            mPowerManagerInternal.registerLowPowerModeObserver(
                    new PowerManagerInternal.LowPowerModeListener() {
                @Override
                public int getServiceType() {
                    return ServiceType.ANIMATION;
                }

                @Override
                public void onLowPowerModeChanged(PowerSaveState result) {
                    synchronized (mGlobalLock) {
                        final boolean enabled = result.batterySaverEnabled;
                        if (mAnimationsDisabled != enabled && !mAllowAnimationsInLowPowerMode) {
                            mAnimationsDisabled = enabled;
                            dispatchNewAnimatorScaleLocked(null);
                        }
                    }
                }
            });
            mAnimationsDisabled = mPowerManagerInternal
                    .getLowPowerState(ServiceType.ANIMATION).batterySaverEnabled;
        }
        mScreenFrozenLock = mPowerManager.newWakeLock(
                PowerManager.PARTIAL_WAKE_LOCK, "SCREEN_FROZEN");
        mScreenFrozenLock.setReferenceCounted(false);

        mDisplayNotificationController = new DisplayWindowListenerController(this);

        mActivityManager = ActivityManager.getService();
        mActivityTaskManager = ActivityTaskManager.getService();
        mAmInternal = LocalServices.getService(ActivityManagerInternal.class);
        mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
        mAppOps = (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE);
        AppOpsManager.OnOpChangedInternalListener opListener =
                new AppOpsManager.OnOpChangedInternalListener() {
                    @Override public void onOpChanged(int op, String packageName) {
                        updateAppOpsState();
                    }
                };
        mAppOps.startWatchingMode(OP_SYSTEM_ALERT_WINDOW, null, opListener);
        mAppOps.startWatchingMode(AppOpsManager.OP_TOAST_WINDOW, null, opListener);

        mPmInternal = LocalServices.getService(PackageManagerInternal.class);
        mTestUtilityService = LocalServices.getService(TestUtilityService.class);
        final IntentFilter suspendPackagesFilter = new IntentFilter();
        suspendPackagesFilter.addAction(Intent.ACTION_PACKAGES_SUSPENDED);
        suspendPackagesFilter.addAction(Intent.ACTION_PACKAGES_UNSUSPENDED);
        context.registerReceiverAsUser(new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                final String[] affectedPackages =
                        intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
                final boolean suspended =
                        Intent.ACTION_PACKAGES_SUSPENDED.equals(intent.getAction());
                updateHiddenWhileSuspendedState(new ArraySet<>(Arrays.asList(affectedPackages)),
                        suspended);
            }
        }, UserHandle.ALL, suspendPackagesFilter, null, null);

        // Get persisted window scale setting
        mWindowAnimationScaleSetting = Settings.Global.getFloat(resolver,
                Settings.Global.WINDOW_ANIMATION_SCALE, mWindowAnimationScaleSetting);
        mTransitionAnimationScaleSetting = Settings.Global.getFloat(resolver,
                Settings.Global.TRANSITION_ANIMATION_SCALE,
                context.getResources().getFloat(
                        R.dimen.config_appTransitionAnimationDurationScaleDefault));

        setAnimatorDurationScale(Settings.Global.getFloat(resolver,
                Settings.Global.ANIMATOR_DURATION_SCALE, mAnimatorDurationScaleSetting));

        mForceDesktopModeOnExternalDisplays = Settings.Global.getInt(resolver,
                DEVELOPMENT_FORCE_DESKTOP_MODE_ON_EXTERNAL_DISPLAYS, 0) != 0;

        final String displaySettingsPath = Settings.Global.getString(resolver,
                DEVELOPMENT_WM_DISPLAY_SETTINGS_PATH);
        mDisplayWindowSettingsProvider = displayWindowSettingsProvider;
        if (displaySettingsPath != null) {
            mDisplayWindowSettingsProvider.setBaseSettingsFilePath(displaySettingsPath);
        }
        mDisplayWindowSettings = new DisplayWindowSettings(this, mDisplayWindowSettingsProvider);

        IntentFilter filter = new IntentFilter();
        // Track changes to DevicePolicyManager state so we can enable/disable keyguard.
        filter.addAction(ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED);
        mContext.registerReceiverAsUser(mBroadcastReceiver, UserHandle.ALL, filter, null, null);

        mLatencyTracker = LatencyTracker.getInstance(context);

        mSettingsObserver = new SettingsObserver();

        mHoldingScreenWakeLock = mPowerManager.newWakeLock(
                PowerManager.SCREEN_BRIGHT_WAKE_LOCK | PowerManager.ON_AFTER_RELEASE, TAG_WM);
        mHoldingScreenWakeLock.setReferenceCounted(false);

        mSurfaceAnimationRunner = new SurfaceAnimationRunner(mTransactionFactory,
                mPowerManagerInternal);

        mAllowTheaterModeWakeFromLayout = context.getResources().getBoolean(
                com.android.internal.R.bool.config_allowTheaterModeWakeFromWindowLayout);

        mTaskPositioningController = new TaskPositioningController(
                this, mInputManager, mActivityTaskManager, mH.getLooper());
        mDragDropController = new DragDropController(this, mH.getLooper());

        mHighRefreshRateDenylist = HighRefreshRateDenylist.create(context.getResources());

        mConstants = new WindowManagerConstants(this, DeviceConfigInterface.REAL);
        mConstants.start(new HandlerExecutor(mH));

        LocalServices.addService(WindowManagerInternal.class, new LocalService());
        mEmbeddedWindowController = new EmbeddedWindowController(mAtmService);

        mDisplayAreaPolicyProvider = DisplayAreaPolicy.Provider.fromResources(
                mContext.getResources());

        mDisplayHashController = new DisplayHashController(mContext);
        setGlobalShadowSettings();

// anr 控制类，无响应，无焦点等
        mAnrController = new AnrController(this);
        mStartingSurfaceController = new StartingSurfaceController(this);

        mBlurController = new BlurController(mContext, mPowerManager);
    }

mH 为 final H mH = new H() 成员变量，因此WMS后面的消息也是运行在 android.display 线程中的。

2. wms 与 ams 关联

mActivityManagerService.setWindowManager(wm);

/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

973      public void setWindowManager(WindowManagerService wm) {
974          synchronized (mGlobalLock) {
975              mWindowManager = wm;
// 缓存 RootWindowContainer
976              mRootWindowContainer = wm.mRoot;
977              mTempConfig.setToDefaults();
978              mTempConfig.setLocales(LocaleList.getDefault());
979              mConfigurationSeq = mTempConfig.seq = 1;
980              mRootWindowContainer.onConfigurationChanged(mTempConfig);
981              mLockTaskController.setWindowManager(wm);
982              mTaskSupervisor.setWindowManager(wm);

// RootWindowContainer 设置 WindowManager
983              mRootWindowContainer.setWindowManager(wm);
984          }
985      }

3. 初始化完成 onInitReady

wm.onInitReady();

/frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java

    public void onInitReady() {
        initPolicy();

        // Add ourself to the Watchdog monitors.
        Watchdog.getInstance().addMonitor(this);
        createWatermark();
        showEmulatorDisplayOverlayIfNeeded();
    }

=========
    private void initPolicy() {

// 在ui 线程执行下列函数，"android.ui"
        UiThread.getHandler().runWithScissors(new Runnable() {
            @Override
            public void run() {
                WindowManagerPolicyThread.set(Thread.currentThread(), Looper.myLooper());

// 初始化 PhoneWindowManager
                mPolicy.init(mContext, WindowManagerService.this, WindowManagerService.this);
            }
        }, 0);
    }

// 初始化 PhoneWindowManager

 /frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.java

    public void init(Context context, IWindowManager windowManager,
            WindowManagerFuncs windowManagerFuncs) {
        mContext = context;
        mWindowManager = windowManager;
        mWindowManagerFuncs = windowManagerFuncs;
        mWindowManagerInternal = LocalServices.getService(WindowManagerInternal.class);
        mActivityManagerInternal = LocalServices.getService(ActivityManagerInternal.class);
        mActivityTaskManagerInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
        mInputManagerInternal = LocalServices.getService(InputManagerInternal.class);
        mDreamManagerInternal = LocalServices.getService(DreamManagerInternal.class);
        mPowerManagerInternal = LocalServices.getService(PowerManagerInternal.class);
        mAppOpsManager = mContext.getSystemService(AppOpsManager.class);
        mDisplayManager = mContext.getSystemService(DisplayManager.class);
        mDisplayManagerInternal = LocalServices.getService(DisplayManagerInternal.class);
        mPackageManager = mContext.getPackageManager();
        mHasFeatureWatch = mPackageManager.hasSystemFeature(FEATURE_WATCH);
        mHasFeatureLeanback = mPackageManager.hasSystemFeature(FEATURE_LEANBACK);
        mHasFeatureAuto = mPackageManager.hasSystemFeature(FEATURE_AUTOMOTIVE);
        mHasFeatureHdmiCec = mPackageManager.hasSystemFeature(FEATURE_HDMI_CEC);
        mAccessibilityShortcutController =
                new AccessibilityShortcutController(mContext, new Handler(), mCurrentUserId);
        mLogger = new MetricsLogger();

        mScreenOffSleepTokenAcquirer = mActivityTaskManagerInternal
                .createSleepTokenAcquirer("ScreenOff");

        Resources res = mContext.getResources();
        mWakeOnDpadKeyPress =
                res.getBoolean(com.android.internal.R.bool.config_wakeOnDpadKeyPress);
        mWakeOnAssistKeyPress =
                res.getBoolean(com.android.internal.R.bool.config_wakeOnAssistKeyPress);
        mWakeOnBackKeyPress =
                res.getBoolean(com.android.internal.R.bool.config_wakeOnBackKeyPress);

        // Init display burn-in protection
        boolean burnInProtectionEnabled = context.getResources().getBoolean(
                com.android.internal.R.bool.config_enableBurnInProtection);
        // Allow a system property to override this. Used by developer settings.
        boolean burnInProtectionDevMode =
                SystemProperties.getBoolean("persist.debug.force_burn_in", false);
        if (burnInProtectionEnabled || burnInProtectionDevMode) {
            final int minHorizontal;
            final int maxHorizontal;
            final int minVertical;
            final int maxVertical;
            final int maxRadius;
            if (burnInProtectionDevMode) {
                minHorizontal = -8;
                maxHorizontal = 8;
                minVertical = -8;
                maxVertical = -4;
                maxRadius = (isRoundWindow()) ? 6 : -1;
            } else {
....

// handler是跑在ui 线程
        mHandler = new PolicyHandler();

4. InputManagerService 设置回调，并启动 InputManagerService 

            inputManager.setWindowManagerCallbacks(wm.getInputManagerCallback());
            inputManager.start();

    public InputManagerCallback getInputManagerCallback() {
        return mInputManagerCallback;
    }

// mInputManagerCallback 的值为对象 InputManagerCallback(this)
    final InputManagerCallback mInputManagerCallback = new InputManagerCallback(this);

setWindowManagerCallbacks 设置回调

/frameworks/base/services/core/java/com/android/server/input/InputManagerService.java

    public void setWindowManagerCallbacks(WindowManagerCallbacks callbacks) {

// 保证只有一个 callback
        if (mWindowManagerCallbacks != null) {
            unregisterLidSwitchCallbackInternal(mWindowManagerCallbacks);
        }
        mWindowManagerCallbacks = callbacks;
        registerLidSwitchCallbackInternal(mWindowManagerCallbacks);
    }

========
    void registerLidSwitchCallbackInternal(@NonNull LidSwitchCallback callback) {
        synchronized (mLidSwitchLock) {

// 将 callback 保存到 mLidSwitchCallbacks
            mLidSwitchCallbacks.add(callback);

            // Skip triggering the initial callback if the system is not yet ready as the switch
            // state will be reported as KEY_STATE_UNKNOWN. The callback will be triggered in
            // systemRunning().
            if (mSystemReady) {
                boolean lidOpen = getSwitchState(-1 /* deviceId */, InputDevice.SOURCE_ANY, SW_LID)
                        == KEY_STATE_UP;
                callback.notifyLidSwitchChanged(0 /* whenNanos */, lidOpen);
            }
        }
    }

然后启动inputmanagerservice

    public void start() {
        Slog.i(TAG, "Starting input manager");
        nativeStart(mPtr);

5. 调用 displayReady 方法

          wm.displayReady();

    public void displayReady() {
        synchronized (mGlobalLock) {
            if (mMaxUiWidth > 0) {
                mRoot.forAllDisplays(displayContent -> displayContent.setMaxUiWidth(mMaxUiWidth));
            }
            applyForcedPropertiesForDefaultDisplay();
            mAnimator.ready();
            mDisplayReady = true;
            // Reconfigure all displays to make sure that forced properties and
            // DisplayWindowSettings are applied.
            mRoot.forAllDisplays(DisplayContent::reconfigureDisplayLocked);
            mIsTouchDevice = mContext.getPackageManager().hasSystemFeature(
                    PackageManager.FEATURE_TOUCHSCREEN);
            mIsFakeTouchDevice = mContext.getPackageManager().hasSystemFeature(
                    PackageManager.FEATURE_FAKETOUCH);
        }

        try {
            mActivityTaskManager.updateConfiguration(null);
        } catch (RemoteException e) {
        }
    }

6. 系统准备完毕，调用 systemReady


           wm.systemReady();

    public void systemReady() {
        mSystemReady = true;

// 调用 PhoneWindowManager.java 的 systemReady
        mPolicy.systemReady();
        mRoot.forAllDisplayPolicies(DisplayPolicy::systemReady);
// 快照控制类
        mTaskSnapshotController.systemReady();
        mHasWideColorGamutSupport = queryWideColorGamutSupport();
        mHasHdrSupport = queryHdrSupport();
// ui线程执行 loadSettings
        UiThread.getHandler().post(mSettingsObserver::loadSettings);

 整个启动过程有3个线程，systemserver主线程，”android.display”,”android.ui”,整个过程采用阻塞的方式（利用runWithScissors）执行，WMS.mH的Looper运行在”android.display”进程。

参考：

WMS启动流程分析 | Skytoby

WMS—启动过程 - Gityuan博客 | 袁辉辉的技术博客

Android渲染(一)_系统服务WMS启动过程(基于Android10) - 掘金


 

蜘蛛侠不会飞
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
WMS管理系统源码 Java仓库管理系统源码
05-24
WMS管理系统源码 Java仓库管理系统源码 架构：SpringMVC+Hibernat+Minidao（类Mybatis）+Easyui（UI库）+ Jquery + Boostrap +Ehcache + Redis + Ztree等基础架构 功能： 1、主要功能 计费配置、仓库配置、基础...
【Android】WMS（四）WMS职责
每天不是在写bug就是在写bug的路上
06-09 1857
wms职责
2024年安卓最全Android R WindowManagerService模块(1) WMS整体架构及启动过程，2024年最新面试官很吊
2401_84561420的博客
05-06 993
首先是一个知识清单：（对于现在的Android及移动互联网来说，我们需要掌握的技术）泛型原理丶反射原理丶Java虚拟机原理丶线程池原理丶注解原理丶注解原理丶序列化Activity知识体系（Activity的生命周期丶Activity的任务栈丶Activity的启动模式丶View源码丶Fragment内核相关丶service原理等）代码框架结构优化（数据结构丶排序算法丶设计模式）APP性能优化（用户体验优化丶适配丶代码调优）热修复丶热升级丶Hook技术丶IOC架构设计。
Android14 WMS启动流程
Android系统优化
10-28 1016
在 Android 系统中，从设计的角度来看，窗口管理系统是基于 C/S 模式的。整个窗口系统分为服务端和客户端两大部分，客户端负责请求创建窗口和使用窗口，服务端完成窗口的维护，窗口显示等。WMS 在 Android 系统的地位，它作为中间层，连接了上层的 View 框架和下层的 SurfaceFingler。
【安卓源码】SurfaceFlinger 启动及其与应用通信
mike_jun的博客
03-19 1244
surfaceflinger 的makefile 文件init进程就可以解析 "surfaceflinger.rc" ，启动 SurfaceFlinger 服务进程，执行 main 方法，启动surfaceflinger 进程：基本操作如下：调用的是 SurfaceFlingerFactory 头文件创建了消息队列 mFactory.createMessageQueueDefaultFactory 头文件创建独占智能指针 MessageQueue代码路径为如下：方法解析。
【Android Framework系列】第7章 WMS原理
Yvan
07-17 1973
简称WMS，是系统的核心服务，主要分为四大部分，分别是窗口管理窗口动画输入系统中转站和Surface管理。1.窗口管理：WMS是窗口的管理者，负责窗口的启动，添加和删除，另外窗口的大小也是由WMS管理的，管理窗口的核心成员有DisplayContent，WindowToken和WindowState。窗口的显示顺序、尺寸、位置， 最终都会反馈SurfaceFlinger。
Android源码探究：Activity启动流程完全解析
蓝天白云梦的csdn博客
05-07 1633
概述 本文主要内容是从源码角度进行Activity启动流程的分析。由于整个启动的过程非常长并且代码非常多，同时受限于笔者的水平，所以本文不会细致到解释每一行的代码的具体作用，只能抽取处关键部分的代码就主体流程进行分析，如有错误之处，希望批评指出。 行文脉络 由于本文会非常长，为了方便读者的理解，首先给出笔者的行文脉络。本文主要沿着：在应用程序1的Activity A内打开另一个应用程序2的Acti...
Android应用启动过程详解
陆业聪
04-01 1386
本文探讨了Android应用启动过程及其涉及的系统组件和底层框架。通过理解这些关键步骤和原理，开发者可以优化应用性能和用户体验。
Android---系统启动流程
qq_44950283的博客
03-10 2031
1. init 根据 init.rc 运行 app_process，并携带“-zygote" 和"-startSystemServer"参数。2. AndroidRuntime.cpp::start() 里将启动 JavaVM，并且注册所有 framework 相关的系统 JNI 接口3. 第一次进入 Java 世界，运行 ZygoteInit.java::main() 函数初始化 Zygote，并创建 Socket 的 Server 端。
Android应用启动流程分析
11-16 884
1 前言 网上看过很多Activity启动过程的源码解析，很多文章会贴上一大段代码，然后从startActivity()函数开始深究整个源码的调用栈。个人感觉这类文章代码细节太多，反而容易迷失在源码调用之中，从而忽略了Activity启动过程的本质。所以本文就简单地定性地对Activity启动过程进行描述，不会贴上大篇幅的源码，同时梳理一下相关的经典问题。也是对以前的所学做一个复习总结。 2 冷启动与热启动 Activity启动过程中，一般会牵涉到应用启动的流程。应用启动又分为冷启动和热启动。 冷启
Android14 WMS-窗口添加流程(二)-Server端
weixin_41028555的博客
06-03 1028
Android14 WMS-窗口添加流程(一)-Client端-CSDN博客本文接着上文"Android14 WMS-窗口添加流程(一)-Client端"往下讲。也就是WindowManagerService#addWindow流程。目录一. WindowManagerService#addWindow标志1：mPolicy.checkAddPermission标志2：getDisplayContentOrCreate标志3： mWindowMap二：窗口类型检查三：新建WindowToken标志1 Win
WMS源码　包含VUE前端源码、后端java spring restful api 源码
10-28
《WMS系统源码解析：前端VUE与后端Java Spring RESTful API的结合》 在信息化管理领域，仓库管理系统（Warehouse Management System，简称WMS）扮演着至关重要的角色，它帮助企业实现库存精细化管理，提高运营效率...
Java版WMS系统源码 WMS源码 包含部署文档+部署视频
11-11
Java版WMS系统源码 WMS源码 包含全部源码+部署文档+部署视频 技术框架：SpringBoot2.0.0 + Mybatis1.3.2 + Shiro + swagger-ui + jpa + lombok + Vue2 + Mysql5.7 运行环境：jdk8 + IntelliJ IDEA + maven + 宝塔...
JAVA版WMS仓储管理系统源码 物流仓库管理系统源码
07-06
JAVA版WMS仓储管理系统源码 物流仓库管理系统源码 源码介绍： 基于JAVA开发的物流仓库管理系统（支持自营和第三方），包含PDA端和WEB端。 WMS在经过多家公司上线运行后，为了降低物流仓储企业的信息化成本...
java jsp 仓库管理系统 wms 源码 源代码 程序 PC+Android 包含PDA端和WEB端.zip
05-08
java jsp仓库管理系统 PC+Android 1、适用范围：第三方物流仓储企业，自营仓储等。...系统(WMS),计费管理系统(BMS),现场作业系 统(RF),第三方接口模块 4、接口支持：已经对接：SAP ECC,SAP HANA数据 库。
Android Kotlin：协程
qq_40853919的博客
07-23 725
1）协程是什么？2）协程和线程的关系？3）协程如何使用？切线程是什么4）挂起函数是什么？5）withContext和lanuch的区别在哪里？6）Defualt、IO和Main的区别。
47、PHP实现机器人的运动范围
weixin_44010641的博客
07-24 809
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。
【Android】广播机制
最新发布
2301_79977698的博客
07-24 765
在Android中，广播（Broadcast）是一种消息，任何应用程序都可以发送广播消息，任何应用程序也都可以接收广播消息。广播通常用于通知应用程序某些事件的发生，比如系统启动、电量低、网络状态改变等。Broadcast Receiver（广播接收器）：用于接收广播消息并响应这些消息的组件。Intent（意图）：用于传递广播消息的数据结构。标准广播（Normal Broadcast）是完全异步的，所有接收器几乎同时接收广播，并且接收顺序是不确定的。
wms 源码 net
09-21
WMS（Warehouse Management System，仓库管理系统）是一种用于管理仓库运营的软件系统，旨在优化仓库内的流程、提高效率、降低成本。WMS源码net是指使用WMS系统的源代码基于.NET框架进行开发的情况。 .NET（.NET Framework）是由微软开发的软件框架，提供了一个平台，使开发人员能够构建和运行各种类型的应用程序。使用.NET框架进行WMS系统的开发，可以充分利用.NET的优势，如面向对象的编程、可扩展性和跨平台性。 WMS源码net的开发过程通常包括以下步骤： 1. 需求分析：了解用户的需求和业务流程。通过与仓库管理人员的沟通和调研，确定系统的功能和架构设计。 2. 数据库设计：根据需求分析的结果，设计数据库模型。定义仓库管理所需的实体和关系，如货物、仓库、入库出库等。 3. 功能开发：根据需求设计，使用.NET框架编写代码。这包括实现基本业务功能，如订单管理、货物跟踪、库存管理等。 4. 用户界面开发：设计用户友好的界面，使用户能够方便地操作系统。使用.NET的GUI组件进行界面设计和开发。 5. 系统测试：对开发的系统进行测试，包括单元测试和集成测试。确保系统的功能正常运行，满足用户需求。 6. 部署和维护：将开发好的系统部署到生产环境中。定期维护和更新系统，以确保其安全性和可用性。 总的来说，WMS源码net是基于.NET框架进行开发的仓库管理系统的源代码。通过使用.NET的优势，如面向对象编程和可扩展性，可以构建高效、可靠的WMS系统，以提升仓库运营效率。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值