Android 系统服务TelecomService启动过程原理分析

由于一直负责的是Android Telephony部分的开发工作,对于通信过程的上层部分Telecom服务以及UI都没有认真研究过。最近恰好碰到一个通话方面的问题,涉及到了Telecom部分,因而就花时间仔细研究了下相关的代码。这里做一个简单的总结。这篇文章,主要以下两个部分的内容:

  • 什么是Telecom服务?其作用是什么?
  • Telecom模块的启动与初始化过程;

接下来一篇文章,主要以实际通话过程为例,分析下telephony收到来电后如何将电话信息发送到Telecom模块以及Telecom是如何处理来电。

什么是Telecom服务

Telecom是Android的一个系统服务,其主要作用是管理Android系统当前的通话,如来电显示,接听电话,挂断电话等功能,在Telephony模块与上层UI之间起到了一个桥梁的作用。比如,Telephony有接收到新的来电时,首先会告知Telecom,然后由Telecom服务通知上层应用来电信息,并显示来电界面。

Telecom服务对外提供了一个接口类TelecomManager,通过其提供的接口,客户端可以查询通话状态,发送通话请求以及添加通话链接等。

从Telecom进程对应的AndroidManifest.xml文件来看,Telecom进程的用户ID跟系统进程用户ID相同,是系统的核心服务。那么,其中android:process="system"这个属性值表示什么意思了?查看官方文档,这个表示Telecom将启动在进程system中,这样可以跟其他进程进行资源共享了(对于Android这个全局进程,就是SystemServer所在的进程)。

android:process

By setting this attribute to a process name that's shared with another application, you can arrange for components of both applications to run in the same process — but only if the two applications also share a user ID and be signed with the same certificate.

If the name assigned to this attribute begins with a colon (‘:'), a new process, private to the application, is created when it's needed. If the process name begins with a lowercase character, a global process of that name is created. A global process can be shared with other applications, reducing resource usage.

 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
      xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
      package="com.android.server.telecom"
      android:versionCode="1"
      android:versionName="1.0.0"
      coreApp="true"
      android:sharedUserId="android.uid.system">

     <application android:label="@string/telecommAppLabel"
        android:icon="@mipmap/ic_launcher_phone"
        android:allowBackup="false"
        android:supportsRtl="true"
        android:process="system"
        android:usesCleartextTraffic="false"
        android:defaultToDeviceProtectedStorage="true"
        android:directBootAware="true">
      ....
      // 包含TelecomService
      <service android:name=".components.TelecomService"
          android:singleUser="true"
          android:process="system">
        <intent-filter>
          <action android:name="android.telecom.ITelecomService" />
        </intent-filter>
      </service>
    ....
    </application>
  </manifest>

代码路径:

/android/applications/sources/services/Telecomm/
/android/frameworks/base/telecomm/

了解了什么是Telecom服务之后,就来看一看Telecom服务是如何启动与初始化的。

Telecom进程的启动与初始化

在SystemServer进程初始化完成启动完系统的核心服务如ActivityManagerService后,就会加载系统其它服务,这其中就包含了一个与Telecom服务启动相关的系统服务专门用于加载Telecom:

 private void startOtherServices() {
    ....
    //启动TelecomLoaderService系统服务,用于加载Telecom
    mSystemServiceManager.startService(TelecomLoaderService.class);
    // 启动telephony注册服务,用于注册监听telephony状态的接口
    telephonyRegistry = new TelephonyRegistry(context);
    ServiceManager.addService("telephony.registry", telephonyRegistry);
  }

调用系统服务管家SystemServiceManager的接口startService创建新的服务,并注册到系统中,最后调用onStart()启动服务。

 public class SystemServiceManager {

    @SuppressWarnings("unchecked")
    public SystemService startService(String className) {
      final Class<SystemService> serviceClass;
      try {
        serviceClass = (Class<SystemService>)Class.forName(className);
      } catch (ClassNotFoundException ex) {
        ....
      }
      return startService(serviceClass);
    }

    // 服务的class文件来创建新的服务对象(服务必须继承SystemService)
    @SuppressWarnings("unchecked")
    public <T extends SystemService> T startService(Class<T> serviceClass) {
      try {
        final String name = serviceClass.getName();
        Slog.i(TAG, "Starting " + name);
        Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);

        // Create the service.
        if (!SystemService.class.isAssignableFrom(serviceClass)) {
          throw new RuntimeException("Failed to create " + name
              + ": service must extend " + SystemService.class.getName());
        }
        final T service;
        try {
          Constructor<T> constructor = serviceClass.getConstructor(Context.class);
          service = constructor.newInstance(mContext);
        } catch (InstantiationException ex) {
          throw new RuntimeException("Failed to create service " + name
              + ": service could not be instantiated", ex);
        }
        ....
        // Register it.
        mServices.add(service);

        // Start it.
        try {
          service.onStart();
        } catch (RuntimeException ex) {
          throw new RuntimeException("Failed to start service " + name
              + ": onStart threw an exception", ex);
        }
        return service;
      } finally {
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
      }
    }
  }

创建TelecomLoaderService系统服务,将系统默认的SMS应用,拨号应用以及SIM通话管理应用(不知道这个什么鬼)告知PackageManagerService(PMS),以便在适当的时候可以找到应用。

  public class TelecomLoaderService extends SystemService {
    ...
    public TelecomLoaderService(Context context) {
      super(context);
      mContext = context;
      registerDefaultAppProviders();
    }

    @Override
    public void onStart() {
    }

    private void registerDefaultAppProviders() {
      final PackageManagerInternal packageManagerInternal = LocalServices.getService(
          PackageManagerInternal.class);

      // Set a callback for the package manager to query the default sms app.
      packageManagerInternal.setSmsAppPackagesProvider(
          new PackageManagerInternal.PackagesProvider() {
        @Override
        public String[] getPackages(int userId) {
          synchronized (mLock) {
          ....
          ComponentName smsComponent = SmsApplication.getDefaultSmsApplication(
              mContext, true);
          if (smsComponent != null) {
            return new String[]{smsComponent.getPackageName()};
          }
          return null;
        }
      });

      // Set a callback for the package manager to query the default dialer app.
      packageManagerInternal.setDialerAppPackagesProvider(
          new PackageManagerInternal.PackagesProvider() {
        @Override
        public String[] getPackages(int userId) {
          synchronized (mLock) {
          ....
          String packageName = DefaultDialerManager.getDefaultDialerApplication(mContext);
          if (packageName != null) {
            return new String[]{packageName};
          }
          return null;
        }
      });

      // Set a callback for the package manager to query the default sim call manager.
      packageManagerInternal.setSimCallManagerPackagesProvider(
          new PackageManagerInternal.PackagesProvider() {
        @Override
        public String[] getPackages(int userId) {
          synchronized (mLock) {
          ....
          TelecomManager telecomManager =
            (TelecomManager) mContext.getSystemService(Context.TELECOM_SERVICE);
          PhoneAccountHandle phoneAccount = telecomManager.getSimCallManager(userId);
          if (phoneAccount != null) {
            return new String[]{phoneAccount.getComponentName().getPackageName()};
          }
          return null;
        }
      });
    }
  }

到目前,好像Telecom服务并没启动,那么究竟Telecom服务在哪里启动的了?仔细看TelecomLoaderService的源代码,其中有一个onBootPhase的函数,用于SystemServer告知系统服务目前系统启动所处的阶段。这里可以看到,等(ActivityManagerService)AMS启动完成以后,就可以开始连接Telecom服务了:

  • 首先,注册默认应用(SMS/Dialer etc)通知对象,以便这些应用发送变更(如下载了一个第三方的SMS应用时,可以通知系统这一变化);
  • 接着,注册运营商配置变化的广播接收器,如果配置有变化时,系统会收到通知;
  • 绑定TelecomService,并将其注册到系统中。
 public class TelecomLoaderService extends SystemService {

    private static final ComponentName SERVICE_COMPONENT = new ComponentName(
        "com.android.server.telecom",
        "com.android.server.telecom.components.TelecomService");

    private static final String SERVICE_ACTION = "com.android.ITelecomService";

    // 当前系统启动的阶段
    @Override
    public void onBootPhase(int phase) {
      if (phase == PHASE_ACTIVITY_MANAGER_READY) {
        registerDefaultAppNotifier();
        registerCarrierConfigChangedReceiver();
        connectToTelecom();
      }
    }

    //绑定Telecom服务
    private void connectToTelecom() {
      synchronized (mLock) {
        if (mServiceConnection != null) {
          // TODO: Is unbinding worth doing or wait for system to rebind?
          mContext.unbindService(mServiceConnection);
          mServiceConnection = null;
        }

        TelecomServiceConnection serviceConnection = new TelecomServiceConnection();
        Intent intent = new Intent(SERVICE_ACTION);
        intent.setComponent(SERVICE_COMPONENT);
        int flags = Context.BIND_IMPORTANT | Context.BIND_FOREGROUND_SERVICE
            | Context.BIND_AUTO_CREATE;

        // Bind to Telecom and register the service
        if (mContext.bindServiceAsUser(intent, serviceConnection, flags, UserHandle.SYSTEM)) {
          mServiceConnection = serviceConnection;
        }
      }
    }
  }

服务绑定:https://developer.android.com/guide/components/bound-services.html

将服务添加到ServiceManager中,如果Telecom服务连接中断时,则重新连接:

 public class TelecomLoaderService extends SystemService {

    private class TelecomServiceConnection implements ServiceConnection {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
          // Normally, we would listen for death here, but since telecom runs in the same process
          // as this loader (process="system") thats redundant here.
          try {
            service.linkToDeath(new IBinder.DeathRecipient() {
              @Override
              public void binderDied() {
                connectToTelecom();
              }
            }, 0);
            SmsApplication.getDefaultMmsApplication(mContext, false);
            //添加Telecom服务
            ServiceManager.addService(Context.TELECOM_SERVICE, service);
            ....
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
          connectToTelecom();
        }
      }
  }

绑定服务时,调用TelecomService的onBind接口,对整个Telecom系统进行初始化,并返回一个IBinder接口:

 /**
   * Implementation of the ITelecom interface.
   */
  public class TelecomService extends Service implements TelecomSystem.Component {

    @Override
    public IBinder onBind(Intent intent) {
      // 初始化整个Telecom系统
      initializeTelecomSystem(this);
      //返回IBinder接口
      synchronized (getTelecomSystem().getLock()) {
        return getTelecomSystem().getTelecomServiceImpl().getBinder();
      }
    }

  }

Telecom系统初始化,主要工作是新建一个TelecomSystem的类,在这个类中,会对整个Telecom服务的相关类都初始化:

 static void initializeTelecomSystem(Context context) {
      if (TelecomSystem.getInstance() == null) {

        final NotificationManager notificationManager =
            (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        // 用于获取联系人
        contactInfoHelper = new ContactInfoHelper(context);
        // 新建一个单例模式的对象
        TelecomSystem.setInstance(new TelecomSystem(....));
      }
      ....
    }
  }

构造一个单例TelecomSystem对象:

  public TelecomSystem(
        Context context,
        /* 用户未接来电通知类(不包括已接或者拒绝的电话) */
        MissedCallNotifierImplFactory missedCallNotifierImplFactory,
        /* 查询来电信息 */
        CallerInfoAsyncQueryFactory callerInfoAsyncQueryFactory,
        /* 耳机接入状态监听 */
        HeadsetMediaButtonFactory headsetMediaButtonFactory,
        /* 距离传感器管理 */
        ProximitySensorManagerFactory proximitySensorManagerFactory,
        /* 通话时电话管理 */
        InCallWakeLockControllerFactory inCallWakeLockControllerFactory,
        /* 音频服务管理 */
        AudioServiceFactory audioServiceFactory,
        /* 蓝牙设备管理 */
        BluetoothPhoneServiceImplFactory bluetoothPhoneServiceImplFactory,
        BluetoothVoIPServiceImplFactory bluetoothVoIPServiceImplFactory,
        /* 查询所有超时信息 */
        Timeouts.Adapter timeoutsAdapter,
        /* 响铃播放 */
        AsyncRingtonePlayer asyncRingtonePlayer,
        /* 电话号码帮助类 */
        PhoneNumberUtilsAdapter phoneNumberUtilsAdapter,
        /* 通话时阻断通知 */
        InterruptionFilterProxy interruptionFilterProxy) {
      mContext = context.getApplicationContext();
      // 初始化telecom相关的feature
      TelecomFeature.makeFeature(mContext);
      // 初始化telecom的数据库
      TelecomSystemDB.initialize(mContext);
      // 创建一个PhoneAccount注册管理类
      mPhoneAccountRegistrar = new PhoneAccountRegistrar(mContext);
      ....
      // 初始化通话管家,正是它负责与上层UI的交互
      mCallsManager = new CallsManager(
          mContext, mLock, mContactsAsyncHelper,
          callerInfoAsyncQueryFactory, mMissedCallNotifier,
          mPhoneAccountRegistrar, headsetMediaButtonFactory,
          proximitySensorManagerFactory, inCallWakeLockControllerFactory,
          audioServiceFactory, bluetoothManager,
          wiredHeadsetManager, systemStateProvider,
          defaultDialerAdapter, timeoutsAdapter,AsyncRingtonePlayer,
          phoneNumberUtilsAdapter, interruptionFilterProxy);

      CallsManager.initialize(mCallsManager);
      // 注册需要接收的广播
      mContext.registerReceiver(mUserSwitchedReceiver, USER_SWITCHED_FILTER);
      mContext.registerReceiver(mUserStartingReceiver, USER_STARTING_FILTER);
      mContext.registerReceiver(mFeatureChangedReceiver, FEATURE_CHANGED_FILTER);
      mContext.registerReceiver(mEmergencyReceiver, EMERGENCY_STATE_CHANGED);
      ....
      // 所有来电与去电的处理中转站
      mCallIntentProcessor = new CallIntentProcessor(mContext, mCallsManager);
      // 创建一个TelecomServiceImpl用于调用TelecomService的接口
      mTelecomServiceImpl = new TelecomServiceImpl(
          mContext, mCallsManager, mPhoneAccountRegistrar,
          new CallIntentProcessor.AdapterImpl(),
          new UserCallIntentProcessorFactory() {
            @Override
            public UserCallIntentProcessor create(Context context, UserHandle userHandle) {
              return new UserCallIntentProcessor(context, userHandle);
            }
          },
          defaultDialerAdapter,
          new TelecomServiceImpl.SubscriptionManagerAdapterImpl(),
          mLock);
      // 执行特定的初始化操作
      initialize(mContext);
    }
  }

Android Telephony中的PhoneAccount到底起到个什么作用了?按照源码中的说明来理解,PhoneAccount表示了不同的接听或者拨打电话的方式,比如用户可以通过SIM卡来拨打电话,也可以拨打视频电话,抑或一个紧急通话,甚至可以通过telephony内部的接口来实现拨号,而Android正是通过PhoneAccount来区分这几种通话方式的。与之相对应的一个类PhoneAccountHandle则是用于表示哪一个用户正在使用通话服务。

至此整个Telecom服务就启动完成了,这样Telecom服务就可以处理来电或者去电了。在接下来的一篇文章里,将分析下来电是如何在Telecom中传递与处理,然后发送到上层UI界面的。

到此这篇关于Android 系统服务TelecomService启动过程原理分析的文章就介绍到这了,更多相关Android 系统服务TelecomService启动内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

展开阅读全文

-->
$.get("https://blog.csdn.net/wang2119/article/uvc/58164251");

(0)

相关推荐

  • Android中获得正在运行的程序和系统服务的方法

    ActivityManager.RunningAppProcessInfo类与获取正在运行的应用程序 每一个应用程序都会运行在它独立的进程里,但是为了节省资源或者这些应用程序是为了完成某一共同工作,它们 也可能会运行在一个进程里. 知识点介绍: ActivityManager.RunningAppProcessInfo类 说明: 封装了正在运行的进程信息 常用字段: int   pid    进程ID int   uid    进程所在的用户ID String   processName 进程名

  • Android 添加系统服务的方法详解

    一.前言 系统服务是Android中非常重要的一部分, 像ActivityManagerService, PackageManagerService, WindowManagerService, 这些系统服务都是Framework层的关键服务, 本篇文章主要讲一下如何基于Android源码添加一个系统服务的完整流程, 除了添加基本系统服务, 其中还包含添加JNI部分代码和App通过AIDL调用的演示Demo, 调用包含App调用服务端, 也包含服务端回调App, 也就是完成一个简单的双向通信.

  • Android 系统服务TelecomService启动过程原理分析

    由于一直负责的是Android Telephony部分的开发工作,对于通信过程的上层部分Telecom服务以及UI都没有认真研究过.最近恰好碰到一个通话方面的问题,涉及到了Telecom部分,因而就花时间仔细研究了下相关的代码.这里做一个简单的总结.这篇文章,主要以下两个部分的内容: 什么是Telecom服务?其作用是什么? Telecom模块的启动与初始化过程: 接下来一篇文章,主要以实际通话过程为例,分析下telephony收到来电后如何将电话信息发送到Telecom模块以及Telecom是

  • 分析Android Activity的启动过程

    分析Android Activity的启动过程 对于Android Activity 的启动过程,我在Android源码中读了好久的源码,以下是我整理出来的Activity启动过程和大家分享下: Activity作为Android的四大组件之一,也是最基本的组件,负责与用户交互的所有功能.Activity的启动过程也并非一件神秘的事情,接下来就简单的从源码的角度分析一下Activity的启动过程. 根Activity一般就是指我们项目中的MainActivity,代表了一个android应用程序

  • SpringBoot启动过程逐步分析讲解

    springboot启动是通过一个main方法启动的,代码如下 @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } 从该方法我们一路跟进去,进入SpringApplication的构造函数,我们可以看到如下代码primarySources,为我们从run方法塞进来的

  • Android系统进程间通信(IPC)机制Binder中的Server启动过程源代码分析

    在前面一篇文章Android系统进程间通信(IPC)机制Binder中的Server和Client获得Service Manager接口之路中,介绍了在Android系统中Binder进程间通信机制中的Server角色是如何获得Service Manager远程接口的,即defaultServiceManager函数的实现.Server获得了Service Manager远程接口之后,就要把自己的Service添加到Service Manager中去,然后把自己启动起来,等待Client的请求.

  • Android Service启动过程完整分析

    刚开始学习Service的时候以为它是一个线程的封装,也可以执行耗时操作.其实不然,Service是运行在主线程的.直接执行耗时操作是会阻塞主线程的.长时间就直接ANR了. 我们知道Service可以执行一些后台任务,是后台任务不是耗时的任务,后台和耗时是有区别的喔. 这样就很容易想到音乐播放器,天气预报这些应用是要用到Service的.当然如果要在Service中执行耗时操作的话,开个线程就可以了. 关于Service的运行状态有两种,启动状态和绑定状态,两种状态可以一起. 启动一个Servi

  • SpringBoot整个启动过程的分析

    前言 前一篇分析了SpringBoot如何启动以及内置web容器,这篇我们一起看一下SpringBoot的整个启动过程,废话不多说,正文开始. 正文 一.SpringBoot的启动类是**application,以注解@SpringBootApplication注明. @SpringBootApplication public class CmsApplication { public static void main(String[] args) { SpringApplication.run

  • 详解Android中的ActivityThread和APP启动过程

    ActiviryThread ActivityThread的初始化 ActivityThread即Android的主线程,也就是UI线程,ActivityThread的main方法是一个APP的真正入口,MainLooper在它的main方法中被创建. //ActivityThread的main方法 public static void main(String[] args) { ... Looper.prepareMainLooper(); ActivityThread thread = ne

  • Android系统进程间通信(IPC)机制Binder中的Client获得Server远程接口过程源代码分析

    在上一篇文章中,我们分析了Android系统进程间通信机制Binder中的Server在启动过程使用Service Manager的addService接口把自己添加到Service Manager守护过程中接受管理.在这一篇文章中,我们将深入到Binder驱动程序源代码去分析Client是如何通过Service Manager的getService接口中来获得Server远程接口的.Client只有获得了Server的远程接口之后,才能进一步调用Server提供的服务. 这里,我们仍然是通过A

  • 通过实例解析android Activity启动过程

    注:只是说明启动activity的过程(ActivityThread如何与ActivityManagerService简称AmS进行进程间通信调用全过程),不解析android从zygote(受精卵)到整个系统服务的启动 具体来讲,启动activity的方式有以下几种: 在应用程序中startActivity()或startActivityForResult()方法启动指定activity 在HOME(桌面)程序中单击应用图标,启动新的activity 按"BACK"键结束当前acti

  • Android ANR原理分析

    目录 卡顿原理 卡顿监控 ANR原理 卡顿原理 主线程有耗时操作会导致卡顿,卡顿超过阀值,触发ANR. 应用进程启动时候,Zygote会反射调用ActivityThread的main方法,启动loop循环. ActivityThread(api29) public static void main(String[] args) { Looper.prepareMainLooper(); ... Looper.loop(); throw new RuntimeException("Main thr

随机推荐