SystemUI 开发总结

2019-07-03 本文已影响6人大利猫

SystemUI 开发总结

后续：SystemUI 能否脱离对系统源码依赖？

SystemUI 有哪内容

从表面上看，我们看到的状态栏、通知栏、下拉菜单、导航栏、锁屏、最近任务、低电提示等系统页面都是 SystemUI 的。SystemUI，在源码目录中位于： framework/base/packages 目录下，可见 SystemUI 和 framework 是关联的， SystemUI 依赖了很多内部 API ，系统资源， SystemUI 编译是要依赖系统源码的。

SystemUI 也是一个应用，不过这个应用特殊之处在于他没有启动图标、也没有入口 Activity 。他的入口程序是一个服务:SystemUIService。这个服务会被系统服务拉起来，这个服务起来， SystemUI 应用进程就创建起来了，具体启动过程后面会分析。除了 SystemUIService ， SystemUI 还有很多服务，例如：负责锁屏的KeyguardService、负责最近任务的 RecentsSystemUserService、负责壁纸的 ImageWallpaper 、负责截屏的TakeScreenshotService 等。

系统移植、UI 改造

如果要做系统移植， SystemUI 改造这块的资料还是挺少，大部分情况下都是啃源码，连蒙带猜的修改，然后再编译出来验证。通常我们会从布局着手看看哪个布局长得像就着手去改，不过这块完全是可以沉淀一下经验出来让后人去节省时间的。这里我也不再赘述了，有人已经梳理过了，我借花献佛吧：https://blog.csdn.net/azhengye/article/details/50419409。

架构关系

在系统服务中，有一个服务是专门为 SystemUI 的状态栏服务的，这个服务就是 StatusbarManagerService （简称：SMS），和这个服务关系比较密切的服务是 WindowManagerService（简称：WMS）， SMS 主要管控的是状态栏、导航栏，例如：我们可以设置全屏、沉浸式状态栏都是 SMS 在起作用。

初次开发 SystemUI 有哪些弯路（环境上的坑）

失败方案1

IDE独立编译 SystemUI ，把 SystemUI 所依赖的系统 jar 都拷贝带 IDE 下，使用 provided 方式依赖。在 6.0 以下版本还勉强可行， 8.0 以后就基本不可能了， 8.0 以后 SystemUI 合入了锁屏模块，依赖了太多的系统资源，编译不过是一个问题，就算编译过了，所依赖的系统资源 ID 也会不一致。经过 1~2 两天的尝试，这个方案失败了。

失败方案2

使用 Google 源码编译，然后在源码中修改 SystemUI , 将编译的 SystemUI 安装到 MTK 系统的版子上。发现安装到 MTK 的板子以后跑不起来，原因是某些服务启动不了，同时也存在资源 ID 不一致的问题。经过 2~3 天的这条这个方案失败了。

最终方案

最终不得不麻烦系统同学，帮忙提供源码：在 MTK 源码中编译。

为了提高效率，使用一台昨晚编译机，另一台作为编辑机，通过 ssh 搭建通道配合完成开发、编译、安装三个流程。

SystemUI 是如何启动的？

前面介绍过 SystemUIService 是 SystemUI 的入库程序。 SystemUIService 是在服务进程中启动的，我们来看下源码：

SystemServer.java 中 SystemServer 是 zygote 进程起来的启动的第一个服务，然后在这个服务的 run 方法方法中会一次启动 Android 系统服务。

private void run() {
    
         // ... 省略一堆代码
         startBootstrapServices();
         startCoreServices();
         startOtherServices();
         // ... 省略一堆代码
    
    }

 其中 AMS 是在 startOtherServices() 这个方法中启动的：

private void startOtherServices() {
    
         // ... 省略一堆代码
         mActivityManagerService = mSystemServiceManager.startService(
         ActivityManagerService.Lifecycle.class).getService();
         // ... 省略一堆代码
         mActivityManagerService.systemReady(() -> {
             
             // ... 省略一堆代码
             try {
                startSystemUi(context, windowManagerF);
             } catch (Throwable e) {
                reportWtf("starting System UI", e);
             } 
             // ... 省略一堆代码
         });
    
    }

在 AMS 启动启动完成之后，会回调一个 systemReady() 传递进去的方法，在其中调用 startSystemUi() 方法启动了 SystemUI ：

static final void startSystemUi(Context context, WindowManagerService windowManager) {
        Intent intent = new Intent();
        intent.setComponent(new ComponentName("com.android.systemui",
                    "com.android.systemui.SystemUIService"));
        intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
        //Slog.d(TAG, "Starting service: " + intent);
        context.startServiceAsUser(intent, UserHandle.SYSTEM);
        windowManager.onSystemUiStarted();
    }

SystemUIService 逻辑也是相当简单，启动之后主要调用 SystemUIApplication 的 startServicesIfNeeded()|

@Override
public void onCreate() {
    super.onCreate();
    ((SystemUIApplication) 
   getApplication()).startServicesIfNeeded();

    // For debugging RescueParty
    if (Build.IS_DEBUGGABLE && 
        SystemProperties.getBoolean("debug.crash_sysui", false)) {
        throw new RuntimeException();
     }
 }

在 SystemUIApplication 中启动了 SystemUI 的各个 UI 模块：

public void startServicesIfNeeded() {
        startServicesIfNeeded(SERVICES);
    }

例如： SERVICES 包含了状态栏、电量、画中画、锁屏等。

通知视图是如何夸进程显示的？

跨进程通讯的基础是 IPC ，通知服务（NotificationManagerService, 简称 NMS）也不离开 IPC ，核心架构还是 IPC 架构。

消息通道

应用做作为通知的发送端，需要调用 NMS ，发通知。例如：

String channelId = "channel_1";
          String tag = "ailabs";
          int id = 10086;
          int importance = NotificationManager.IMPORTANCE_LOW;
          NotificationChannel channel = new NotificationChannel(channelId, "123", importance);
          NotificationManager manager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
          manager.createNotificationChannel(channel);
          Notification notification = new Notification.Builder(MainActivity.this, channelId)
                  .setCategory(Notification.CATEGORY_MESSAGE)
                  .setSmallIcon(R.mipmap.ic_launcher)
                  .setContentTitle("This is a content title")
                  .setContentText("This is a content text")
                  .setAutoCancel(true)
                  .build();
           // 通知栏要显示的视图布局
          RemoteViews remoteViews = new RemoteViews(getPackageName(), R.layout.layout_remoteviews);                 
          notification.contentView = remoteViews;
          manager.notify(tag, id , notification);

SystemUI 作为通知的接收放需要注册监听器 INotificationListener 是监听通通知的一个 AIDL 接口，
NotificationListenerService 是一个监听管理服务，他的内部类 NotificationListenerWrapper 实现了
INotificationListener 接口。例如：

/** @hide */
        protected class NotificationListenerWrapper extends INotificationListener.Stub {
            @Override
            public void onNotificationPosted(IStatusBarNotificationHolder sbnHolder,
                    NotificationRankingUpdate update) {
                     // 接收通知
                      ....
                     省略了很多代码
            }
    
            @Override
            public void onNotificationRemoved(IStatusBarNotificationHolder sbnHolder,
                    NotificationRankingUpdate update, NotificationStats stats, int reason) {
                    // 删除通知
                          ....
                     // 省略了很多代码
            }

这个通知监听需要向 NMS 注册：

@SystemApi
          public void registerAsSystemService(Context context, ComponentName componentName,
                  int currentUser) throws RemoteException {
              if (mWrapper == null) {
                  mWrapper = new NotificationListenerWrapper();
              }
              mSystemContext = context;
              INotificationManager noMan = getNotificationInterface();
              mHandler = new MyHandler(context.getMainLooper());
              mCurrentUser = currentUser;
              noMan.registerListener(mWrapper, componentName, currentUser);
          }

 以上是 Android 为我们提供的通知接收管理服务类， SystemUI 有个NotificationListenerWithPlugins 类继承了 NotificationListenerService

类。并在 SystemUI 进程起来的时候调用 registerAsSystemService() 方法完成了注册：

NotificationListenerWithPlugins mNotificationListener = new NotificationListenerWithPlugins();
    mNotificationListener.registerAsSystemService();

这样通道就建立起来了。

消息传递过程，大家可以按照这个思路器走读源码

RemoteViews

以上只是讲解了应用怎么把一个消息传递到 SystemUI , 理解 IPC 通讯的不难理解。而神奇之处在于显示的视图布局明明是定义在一个应用中，为何能跨进程显示到 SystemUI 进程中呢？

发送通知，传递的通知实体是 Notification 的实例， Notification 实现了 Parcelable 接口。 Notification 有个 RemoteViews 的成员变量

RemoteViews remoteViews = new RemoteViews(getPackageName(), R.layout.layout_remoteviews); notification.contentView = remoteViews;

RemoteViews 也实现了 Parcelable 接口，主要是封装了通知栏要展示的视图信息，例如，应用包名、布局ID。我们都知道实现了 Parcelable 这个接口就可以在 IPC 通道上夸进程传递。 RemoteView 支持的布局类型也是有限的，例如在 8.0 上仅支持如下类型：

android.widget.AdapterViewFlipper
*android.widget.FrameLayout
android.widget.GridLayout
android.widget.GridView
android.widget.LinearLayout
android.widget.ListView
android.widget.RelativeLayout
android.widget.StackView
android.widget.ViewFlipper

RemoteView 携带了视图信息，进程间传递的并不是真实的视图对象，而主要是布局的 id ，那么显示在通知栏上的视图对象又是如何创建出来的呢？

通知视图创建

在通知的接收端创建的，上文说过 NotificationManagerService 内部类 NotificationListenerWrapper 监听通知消息，在收到消息之后就在里面解析消息，并创建视图了。

protected class NotificationListenerWrapper extends INotificationListener.Stub {
          
          @Override
          public void onNotificationPosted(IStatusBarNotificationHolder sbnHolder,
                  NotificationRankingUpdate update) {
              StatusBarNotification sbn;
              try {
                  sbn = sbnHolder.get();
              } catch (RemoteException e) {
                  Log.w(TAG, "onNotificationPosted: Error receiving StatusBarNotification", e);
                  return;
              }
  
              try {
                  // convert icon metadata to legacy format for older clients
                  createLegacyIconExtras(sbn.getNotification());
                  // 创建视图
                  maybePopulateRemoteViews(sbn.getNotification());
                  
                  maybePopulatePeople(sbn.getNotification());
              } catch (IllegalArgumentException e) {
                  // warn and drop corrupt notification
                  Log.w(TAG, "onNotificationPosted: can't rebuild notification from " +
                          sbn.getPackageName());
                  sbn = null;
              }
  
              // ... 省略代码
  
          }
  
          @Override
          public void onNotificationRemoved(IStatusBarNotificationHolder sbnHolder,
                  NotificationRankingUpdate update, NotificationStats stats, int reason) {
              StatusBarNotification sbn;
              //... 省略代码
  
          }
      }

  在 maybePopulateRemoteViews  这个方法中会去检查布局是否要加载， **其实我们比较好奇的是布局资源在应用进程中，

SystemUI 如何加载远程进程的布局资源？**
有两个关键的信息：包名、布局ID。知道了包名 SystemUI 进程是有权限创建对应包名的上下文对象的，进而可以拿到对应应用的
资源管理器，然后就可以加载布局资源创建对象了。 maybePopulateRemoteViews 方法跟踪下去，会走到 RemoteViews 的

private View inflateView(Context context, RemoteViews rv, ViewGroup parent) {
         // RemoteViews may be built by an application installed in another
         // user. So build a context that loads resources from that user but
         // still returns the current users userId so settings like data / time formats
         // are loaded without requiring cross user persmissions.
         final Context contextForResources = getContextForResources(context);
         Context inflationContext = new RemoteViewsContextWrapper(context, contextForResources);
 
         // If mApplyThemeResId is not given, Theme.DeviceDefault will be used.
         if (mApplyThemeResId != 0) {
             inflationContext = new ContextThemeWrapper(inflationContext, mApplyThemeResId);
         }
         LayoutInflater inflater = (LayoutInflater)
                 context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
 
         // Clone inflater so we load resources from correct context and
         // we don't add a filter to the static version returned by getSystemService.
         inflater = inflater.cloneInContext(inflationContext);
         inflater.setFilter(this);
         View v = inflater.inflate(rv.getLayoutId(), parent, false);
         v.setTagInternal(R.id.widget_frame, rv.getLayoutId());
         return v;
     }

其中 getContextForResources 中的 context 对象就是通过应用包名创建的上下文对象，创建过程：

private static ApplicationInfo getApplicationInfo(String packageName, int userId) {
          if (packageName == null) {
              return null;
          }
  
          // Get the application for the passed in package and user.
          Application application = ActivityThread.currentApplication();
          if (application == null) {
              throw new IllegalStateException("Cannot create remote views out of an aplication.");
          }
  
          ApplicationInfo applicationInfo = application.getApplicationInfo();
          if (UserHandle.getUserId(applicationInfo.uid) != userId
                  || !applicationInfo.packageName.equals(packageName)) {
              try {
                  Context context = application.getBaseContext().createPackageContextAsUser(
                          packageName, 0, new UserHandle(userId));
                  applicationInfo = context.getApplicationInfo();
              } catch (NameNotFoundException nnfe) {
                  throw new IllegalArgumentException("No such package " + packageName);
              }
          }
  
          return applicationInfo;
    }

只有 SystemUI 才能接收通知吗？

答案是否定的，只要有权限注册通知监听的应用都可以。具体权限是： <uses-permission android:name="android.permission.STATUS_BAR_SERVICE"/>
只要应用有这个权限就可以注册通知监听了，这个权限只有系统应用才能申请，也就是说，只要是系统应用都可以监听并显示通知的。可以写一个简单的 demo 测试一下：
一、申请权限
<uses-permission android:name="android.permission.STATUS_BAR_SERVICE"/>
二、在布局中定义一个容器来装远程通知视图

...
     <FrameLayout
         android:layout_width="match_parent"
         android:layout_height="92px"
         android:id="@+id/notification">
 
     </FrameLayout>
     ...

 三、注册监听并处理通知显示逻辑。

protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        final ViewGroup notificationContainer = findViewById(R.id.notification);
        NotificationListenerService listenerService = new NotificationListenerService() {
            @SuppressLint("LongLogTag")
            @Override
            public void onNotificationPosted(StatusBarNotification sbn) {
                super.onNotificationPosted(sbn);
                Log.d("NotificationListenerService", "onNotificationPosted" + sbn);
                if (sbn.getNotification().contentView != null) {
                    View view =  sbn.getNotification().contentView.apply(MainActivity.this, null);
                    notificationContainer.addView(view);
                    view.setVisibility(View.VISIBLE);
                    Log.d("NotificationListenerService", "add contentView");
                }

                if (sbn.getNotification().bigContentView != null) {
                    View view =  sbn.getNotification().bigContentView.apply(MainActivity.this, null);
                    notificationContainer.addView(view);
                    view.setVisibility(View.VISIBLE);
                    Log.d("NotificationListenerService", "add bigContentView");
                }

                if (sbn.getNotification().headsUpContentView != null) {
                    sbn.getNotification().headsUpContentView.apply(MainActivity.this, null);
                    Log.d("NotificationListenerService", "add headsUpContentView");
                }

            }
            @SuppressLint("LongLogTag")
            @Override
            public void onNotificationRemoved(StatusBarNotification sbn) {
                super.onNotificationRemoved(sbn);
                Log.d("NotificationListenerService", "onNotificationRemoved" + sbn);
            }

            @SuppressLint("LongLogTag")
            @Override
            public void onListenerConnected() {
                super.onListenerConnected();
                Log.d("NotificationListenerService", "onNotificationRemoved");
            }

            @Override
            public void onListenerDisconnected() {
                super.onListenerDisconnected();
            }
        };

    // 调用注册方法 registerAsSystemService 不是公开的 API 反射

try {
            Method method =
                    NotificationListenerService.class.getMethod("registerAsSystemService", Context.class, ComponentName.class, int.class);

            method.setAccessible(true);
            method.invoke(listenerService, this,
                    new ComponentName(getPackageName(), getClass().getCanonicalName()),
                    -1);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

运行起来后，注册成功，然后任意应用发通知，这里就能显示出来了。

应用窗口的 flag 是如何状态栏？

通常我们这样添加窗口属性，例如设置 flag 让 SystemUI 状态栏支持绘制背景：

Window window = activity.getWindow();
        window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);

我们都知道 Android 系统为我们提供的 window 实现类是 PhoneWindow （不清楚的可以参考文章：https://www.jianshu.com/p/b4c23dee9206）， flag 其实被仅仅是 WindowManager.LayoutParams 的一个标记而已。

public void setFlags(int flags, int mask) {
        final WindowManager.LayoutParams attrs = getAttributes();
        attrs.flags = (attrs.flags&~mask) | (flags&mask);
        mForcedWindowFlags |= mask;
        dispatchWindowAttributesChanged(attrs);
    }

所有窗口的 View 和 LayoutParams 最终会被添加到 WindowManagerService 中，WindowManagerService 会记录着窗口信息，包括 flag 属性。（View、Window 和 ViewRootImpl 的关系：参考：https://www.jianshu.com/p/47421ec56795）
每次窗口布局、焦点发生变化的时候，都会去重新计算当前窗口的属性，包括 flag。

public int addWindow(Session session, IWindow client, int seq,
            WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
            Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
            InputChannel outInputChannel) {
            //...省略一堆代码
            // 计算属性
            mPolicy.adjustWindowParamsLw(win.mAttrs);
            //...省略一堆代码
            updateFocusedWindowLocked(UPDATE_FOCUS_WILL_ASSIGN_LAYERS,
                                    false /*updateInputWindows*/);
        }

mPolicy 是 PhoneWindowManager 的一个实例， adjustWindowParamsLw 主要是根据窗口的属性来决定接下来要展示什么样的
SystemUI。例如：

@Override
      public void adjustWindowParamsLw(WindowManager.LayoutParams attrs) {
          // 省略一堆代码
          if ((attrs.flags & FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS) != 0
                  || forceWindowDrawsStatusBarBackground
                          && attrs.height == MATCH_PARENT && attrs.width == MATCH_PARENT) {
              attrs.subtreeSystemUiVisibility |= View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
          }
      }

接下来，会调用 PhoneWindowManager 的 focusChangedLw()，在这里调用了更新 SystemUI 样式的方法 updateSystemUiVisibilityLw。

@Override
      public int focusChangedLw(WindowState lastFocus, WindowState newFocus) {
          mFocusedWindow = newFocus;
          if ((updateSystemUiVisibilityLw()&SYSTEM_UI_CHANGING_LAYOUT) != 0) {
              // If the navigation bar has been hidden or shown, we need to do another
              // layout pass to update that window.
              return FINISH_LAYOUT_REDO_LAYOUT;
          }
          return 0;
      }

private int updateSystemUiVisibilityLw() {
          
          mHandler.post(new Runnable() {
                  @Override
                  public void run() {
                      StatusBarManagerInternal statusbar = getStatusBarManagerInternal();
                      if (statusbar != null) {
                          statusbar.setSystemUiVisibility(visibility, fullscreenVisibility,
                                  dockedVisibility, 0xffffffff, fullscreenStackBounds,
                                  dockedStackBounds, win.toString());
                          statusbar.topAppWindowChanged(needsMenu);
                      }
                  }
              });
          return diff;
      }

statusbar 就是 StatusbarManagerService 的一个实例。在 SystemUI 的启动过程中， SystemUI 会向 StatusbarManagerService
服务注册一个回调，专门用来接收 StatusbarManagerService 的调用，这个回调器就是 CommandQueue。

public void setSystemUiVisibility(int vis, int fullscreenStackVis, int dockedStackVis,
              int mask, Rect fullscreenStackBounds, Rect dockedStackBounds) {
          synchronized (mLock) {
              // Don't coalesce these, since it might have one time flags set such as
              // STATUS_BAR_UNHIDE which might get lost.
              SomeArgs args = SomeArgs.obtain();
              args.argi1 = vis;
              args.argi2 = fullscreenStackVis;
              args.argi3 = dockedStackVis;
              args.argi4 = mask;
              args.arg1 = fullscreenStackBounds;
              args.arg2 = dockedStackBounds;
              mHandler.obtainMessage(MSG_SET_SYSTEMUI_VISIBILITY, args).sendToTarget();
          }
      }

CommandQueue 收到调用之后就会将消息发送到 SystemUI 的视图，视图再根据收到的 vis 属性改变样式。

SystemUI 开发总结

SystemUI 开发总结

SystemUI 有哪内容

系统移植、UI 改造

架构关系

初次开发 SystemUI 有哪些弯路（环境上的坑）

失败方案1

失败方案2

最终方案

SystemUI 是如何启动的？

通知视图是如何夸进程显示的？

消息通道

RemoteViews

通知视图创建

只有 SystemUI 才能接收通知吗？

应用窗口的 flag 是如何状态栏？

猜你喜欢

热点阅读

SystemUI 开发总结

SystemUI 开发总结

SystemUI 有哪内容

系统移植 、UI 改造

架构关系

初次开发 SystemUI 有哪些弯路 （环境上的坑）

失败方案1

失败方案2

最终方案

SystemUI 是如何启动的？

通知视图是如何夸进程显示的？

消息通道

RemoteViews

通知视图创建

只有 SystemUI 才能接收通知吗？

应用窗口的 flag 是如何状态栏？

猜你喜欢

热点阅读

系统移植、UI 改造

初次开发 SystemUI 有哪些弯路（环境上的坑）