备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

Android热插拔事件处理详解

2016-08-21 3153
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 一、Android热插拔事件处理流程图 Android热插拔事件处理流程如下图所示：   二、组成 1. NetlinkManager:        全称是NetlinkManager.cpp位于Android 4.x 源码位置/system/vold/NetlinkManager.cpp。该类的主要通过引用NetlinkHandler类中的onEv

一、Android热插拔事件处理流程图

Android热插拔事件处理流程如下图所示：

 

二、组成

1. NetlinkManager:
       全称是NetlinkManager.cpp位于Android 4.x 源码位置/system/vold/NetlinkManager.cpp。该类的主要通过引用NetlinkHandler类中的onEvent()方法来接收来自内核的事件消息，NetlinkHandler位于/system/vold/NetlinkHandler.cpp。

2. VolumeManager:
      全称是VolumeManager.cpp位于Android 4.x源码位置/system/vold/VolumeManager.cpp。该类的主要作用是接收经过NetlinkManager处理过后的事件消息。因为我们这里是SD的挂载，因此经过NetlinkManager处理过后的消息会分为五种，分别是：block,switch,usb_composite,battery,power_supply。这里SD卡挂载的事件是block。

3. DirectVolume:
       位于/system/vold/DirectVolume.cpp。该类的是一个工具类，主要负责对传入的事件进行进一步的处理，block事件又可以分为：Add,Removed,Change,Noaction这四种。后文通过介绍Add事件展开。

4. Volume:
       位于/system/vold/Volume.cpp，该类是负责SD卡挂载的主要类。Volume.cpp主要负责检查SD卡格式，以及对复合要求的SD卡进行挂载，并通过Socket将消息SD卡挂载的消息传递给NativeDaemonConnector。

5. CommandListener:
     该类位于位于/system/vold/CommandListener.cpp。通过vold socket与NativeDaemonConnector通信。

6. NativeDaemonConnector:
     该类位于frameworks/base/services/java/com.android.server/NativeDaemonConnector.java。该类用于接收来自Volume.cpp 发来的SD卡挂载消息并向上传递。

7.  MountService:
      位于frameworks/base/services/java/com.android.server/MountService.java。MountService是一个服务类，该服务是系统服务，提供对外部存储设备的管理、查询等。在外部存储设备状态发生变化的时候，该类会发出相应的通知给上层应用。在Android系统中这是一个非常重要的类。

8. StorageManaer:
     位于frameworks/base/core/java/andriod/os/storage/StorageManager.java。在该类的说明中有提到，该类是系统存储服务的接口。在系统设置中，有Storage相关项，同时Setting也注册了该类的监听器。而StorageManager又将自己的监听器注册到了MountService中，因此该类主要用于上层应用获取SD卡状态。

三、典型流程描述 (SD卡挂载流程)

        整个过程从Kernel检测到SD卡插入事件开始，之前的一些硬件中断的触发以及driver的加载这里并不叙述，一直到SD卡挂载消息更新到“Android——系统设置——存储”一项中。
       1.    Kernel发出SD卡插入uevent。
       2.    NetlinkHandler::onEvent()接收内核发出的uevent并进行解析。
       3.    VolumeManager::handlBlockEvent()处理经过第二步处理后的事件。
       4.    接下来调用DirectVolume:: handleBlockEvent()。
              在该方法中主要有两点需要注意：
              第一，程序首先会遍历mPath容器，寻找与event对应的sysfs_path是否存在与mPath容器中。
              第二，针对event中的action有4种处理方式：Add,Removed,Change,Noaction 。
              例如：在Add action中会有如下操作(因为我们这里所讲的是SD卡的挂载流程，因此以Add来说明),首先创建设备节点，其次对disk和partition两种格式的设备分别进行处理。SD卡属于disk类型。
       5.    经过上一步之后会调用DirectVolume::handleDiskAdded()方法，在该方法中会广播disk insert消息。
       6.    SocketListener::runListener会接收DirectVolume::handleDiskAdded()广播的消息。该方法主要完成对event中数据的获取，通过Socket。(PS:这里的SocketListener.cpp位于Android源码/system/core/libsysutils/src/中，后文的FramworkListener.cpp也是，之前自己找了很久 T_T)
       7.    调用FrameworkListener::onDataAvailable()方法处理接收到的消息内容。
       8.    FrameworkListener::dispatchCommand()该方法用于分发指令。
       9.    在FrameworkListener::dispatchCommand()方法中，通过runCommand()方法去调用相应的指令。
      10.   在/system/vold/CommandListener.cpp中有runCommand()的具体实现。在该类中可以找到这个方法：CommandListener::VolumeCmd::runCommand()，从字面意思上来看这个方法就是对Volume分发指令的解析。该方法中会执行“mount”函数：vm->mountVolume(arg[2])。
     11.    mountVolume(arg[2])在VolumeManager::mountVolume()中实现，在该方法中调用v->mountVol()。
     12.    mountVol()方法在Volume::mountVol()中实现，该函数是真正的挂载函数。(在该方法中，后续的处理都在该方法中，在Mount过程中会广播相应的消息给上层，通过setState()函数。)
     13.    setState(Volume::Checking);广播给上层，正在检查SD卡，为挂载做准备。
     14.    Fat::check();SD卡检查方法，检查SD卡是否是FAT格式。
     15.    Fat::doMount()挂载SD卡。
     至此，SD的挂载已算初步完成，接下来应该将SD卡挂载后的消息发送给上层，在13中也提到过，在挂载以及检查的过程中其实也有发送消息给上层的。
     16.    MountService的构造函数中会开启监听线程，用于监听来自vold的socket信息。
              Thread thread = new Thread(mConnector,VOLD_TAG); thread.start();
     17.    mConnector是NativeDaemonConnector的对象，NativeDaemonConnector继承了Runnable并Override了run方法。在run方法中通过一个while(true)调用ListenToSocket()方法来实现实时监听。
     18.    在ListenToSocket()中，首先建立与Vold通信的Socket Server端，然后调用MountService中的onDaemonConnected()方法。(PS:Java与Native通信可以通过JNI，那么Native与Java通信就需要通过Socket来实现了。Android中Native与Frameworks通信  这篇文章中有简介，感兴趣的朋友可以参考一下)
     19.    onDaemonConnected()方法是在接口INativeDaemonConnectorCallbacks中定义的，MountService实现了该接口并Override了onDaemonConnected()方法。该方法开启一个线程用于更新外置存储设备的状态，主要更新状态的方法也在其中实现。
     20.    然后回到ListenToSocket中，通过inputStream来获取Vold传递来的event，并存放在队列中。
     21.    然后这些event会在onDaemonConnected()通过队列的”队列.take()”方法取出。并根据不同的event调用updatePublicVolumeState()方法，在该方法中调用packageManagerService中的updateExteralState()方法来更新存储设备的状态。(注：这里不太理解packageManagerService中的unloadAllContainers(args)方法)
     22.    更新是通过packageHelper.getMountService().finishMediaUpdate()方法来实现的。
     23.    在updatePublicVolumeState()方法中，更新后会执行如下代码：
              bl.mListener.onStorageStateChanged();
              在Android源码/packages/apps/Settings/src/com.android.settings.deviceinfo/Memory.java代码中，实现了StorageEventListener 的匿名内部类，并Override了onStorageStateChanged();方法。因此在updatePublicVolumeState()中调用onStorageStateChanged();方法后，Memory.java中也会收到。在Memory.java中收到以后会在Setting界面进行更新,系统设置——存储中会更新SD卡的状态。从而SD卡的挂载从底层到达了上层。 

 四、Vold

1. Vold简介

     Vold的全称是volume daemon。主要负责系统对大容量存储设备(USB/SD)的挂载/卸载任务，它是一个守护进程，该进程支持这些存储外设的热插拔。自Android 2.2开始，Vold升级为vold 2.0，配置文件路径在Android 4.0之后变为/etc/vold.fstab。

2.Vold工作流程

    Vold的工作流程大致可以分为三个部分:创建监听、引导、事件处理。

     (1)创建监听

     创建监听指的是创建监听链接，一方面用于监听来自内核的uevent，另一方面用于监听来自上层的控制命令，这些命令包括控制SD卡的挂载与卸载，这里所说的链接也就是socket。在Android 系统启动的时候，init进程会去解析init.rc文件，在该文件中，有如下代码：

Service vold /system/bin/vold
             Socket vold stream 0660 root mount
             Iprio be 2

     这样系统会在启动的时候创建与上层通信的socket，此socket name为"vold"。

      在Android 4.0源码/system/vold路径下的main.cpp<NetlinkManager::start():socket(PF_NETLINK,SOCK_DGRAM,NETLINK_KOBJECT_UEVENT) >中创建了与内核通信的socket。在main.cpp中通过实例化VolumeManager和NetlinkManager时创建。

     (2)引导

     Vold进程启动时候会对现有的外部存储设备进行检查。首先加载并解析vold.fstab，并检查挂载点是否已被挂载。然后执行SD卡的挂载，最后处理USB大容量存储。因为系统是按行解析的，通过查看vold.fstab可以很清楚的知道这一点。
vold.fatab中最重要的语句：

dev_mount sdcard /mnt/sdcard auto /devices/platform/rk29_sdmmc.0/mmc_host/mmc0
dev_mount       <lable>     <mount_point>           <part>                   <sysfs_path…>
挂载命令            标签                挂载点              第几个分区              设备的sysfs paths
注：
       第几个分区：如果为auto则表示第1个分区。
       参数之间不能有空格，只能以tab为间隔(注意：这里为了对齐因此采用空格隔开，如果自行修改vold.fstab之后加以空格的话系统会识别不到的)。
       如果vold.fstab解析无误，VolueManager将创建DirectVolume，若vold.fstab解析不存在或者打开失败，Vold将会读取Linux内核中的参数，此时如果参数中存在SDCARD(也就是SD的默认路径)，VolumeManager则会创建AutoVolume，如果不存在这个默认路径那么就不会创建。

     (3)事件处理

     通过对两个socket的监听，完成对事件的处理以及对上层应用的响应。

       a) Kernel发出uevent
       NetlinkManager检测到kernel发出的uevent，解析后调用NetlinkHandler::onEvent()方法。该方法会分别处理不同的事件，这里重要的事件有：
       “block”事件主要指Volume的mount、unmount、createAsec等。由VolumeManager的handleBlockEvent(evt)来处理，根据多态性最终将会调用AutoVolume或者DirectVolume的handleBlockEvent方法来处理。
       “switch”事件主要指Volume的connet、disconnet等。根据相关操作，改变设备参数(设备类型、挂载点等)通过CommandListener告知FrameWork层。

       b) FrameWork发出控制命令
       与a)相反，CommandListener检测到FrameWork层的命令(MountService发出的命令)调用VolumeManager的函数，VolumeManager找出对应的Volume，调用Volume函数去挂载/卸载操作。而Volume类中的相关操作最终通过调用Linux函数完成。

五、Vold用户态

1. NetlinkManager

    NetlinkManager负责与Kernel交互，通过PF_NETLINK来现。

    Vlod启动代码如下(/system/vold/main.cpp)：   

   

[cpp]  view plain copy
  1. int main() {  
  2.   
  3.     VolumeManager *vm;  
  4.     CommandListener *cl;  
  5.     NetlinkManager *nm;  
  6.   
  7.     SLOGI("Vold 2.1 (the revenge) firing up");  
  8.   
  9.     mkdir("/dev/block/vold", 0755);  
  10.   
  11.     /* Create our singleton managers */  
  12.     if (!(vm = VolumeManager::Instance())) {  
  13.         SLOGE("Unable to create VolumeManager");  
  14.         exit(1);  
  15.     };  
  16.   
  17.     if (!(nm = NetlinkManager::Instance())) {  
  18.         SLOGE("Unable to create NetlinkManager");  
  19.         exit(1);  
  20.     };  
  21.   
  22.   
  23.     cl = new CommandListener();  
  24.     vm->setBroadcaster((SocketListener *) cl);  
  25.     nm->setBroadcaster((SocketListener *) cl);  
  26.   
  27.     if (vm->start()) {  
  28.         SLOGE("Unable to start VolumeManager (%s)", strerror(errno));  
  29.         exit(1);  
  30.     }  
  31.   
  32.     /* 解析/etc/vold.fstab文件， 
  33.      读取type， label, mount_point, part 
  34.      1) 构建DirectVolume对象 ：如果part为auto， 则调用dv = new DirectVolume(vm, label, mount_point, -1); 
  35.      2) 添加vold.fstab中定义的某一挂载项对应的sysfs_path到 DirectVolume对象的mPaths容器  dv->addPath(sysfs_path); 
  36.      3) 将这个DirectVolume 对象添加到 VolumeManager对象的容器mVolumes中   vm->addVolume(dv)； 
  37.     */  
  38.     if (process_config(vm)) {  
  39.         SLOGE("Error reading configuration (%s)... continuing anyways", strerror(errno));  
  40.     }  
  41.   
  42.     /*会调用NetlinkManager类的start()方法，它创建PF_NETLINK socket, 
  43.       并开启线程从此socket中读取数据*/  
  44.     if (nm->start()) {  
  45.         SLOGE("Unable to start NetlinkManager (%s)", strerror(errno));  
  46.         exit(1);  
  47.     }  
  48.   
  49. #ifdef USE_USB_MODE_SWITCH  
  50.     SLOGE("Start Misc devices Manager...");  
  51.     MiscManager *mm;  
  52.     if (!(mm = MiscManager::Instance())) {  
  53.         SLOGE("Unable to create MiscManager");  
  54.         exit(1);  
  55.     };  
  56.     mm->setBroadcaster((SocketListener *) cl);  
  57.     if (mm->start()) {  
  58.         SLOGE("Unable to start MiscManager (%s)", strerror(errno));  
  59.         exit(1);  
  60.     }  
  61.     G3Dev* g3 = new G3Dev(mm);  
  62.     g3->handleUsb();  
  63.     mm->addMisc(g3);  
  64. #endif  
  65.     coldboot("/sys/block"); // 冷启动，vold错过了一些uevent,重新触发。向sysfs的uevent文件写入”add\n” 字符也可以触发sysfs事件，相当执行了一次热插拔。  
  66.   
  67. //    coldboot("/sys/class/switch");  
  68.   
  69.     /* 
  70.      * Now that we're up, we can respond to commands 
  71.      */  
  72.     if (cl->startListener()) {  
  73.         SLOGE("Unable to start CommandListener (%s)", strerror(errno));  
  74.         exit(1);  
  75.     }  
  76.   
  77.     // Eventually we'll become the monitoring thread  
  78.     while(1) {  
  79.         sleep(1000);  
  80.     }  
  81.   
  82.     SLOGI("Vold exiting");  
  83.     exit(0);  
  84. }  

 

NetlinkManager的家族关系如下所示：

上图中的虚线为启动是的调用流程。
 (1) class NetlinkManager(在其start函数中创建了NetlinkHandler对象，并把创建的socket作为参数)

 (2)class NetlinkHandler: public NetlinkListener(实现了onEvent)
 (3) class NetlinkListener : public SocketListener (实现了onDataAvailable)
 (4) class SocketListener(实现了runListener，在一个线程中通过select查看哪些socket有数据，通过调用onDataAvailable来读取数据)

 2. NetlinkManager::start()

[cpp]  view plain copy
  1. int NetlinkManager::start() {  
  2.     struct sockaddr_nl nladdr;  
  3.     int sz = 64 * 1024;  
  4.     int on = 1;  
  5.   
  6.     memset(&nladdr, 0, sizeof(nladdr));  
  7.     nladdr.nl_family = AF_NETLINK;  
  8.     nladdr.nl_pid = getpid();  
  9.     nladdr.nl_groups = 0xffffffff;  
  10.     // 创建一个socket用于内核空间和用户空间的异步通信，监控系统的hotplug事件  
  11.     if ((mSock = socket(PF_NETLINK,  
  12.                         SOCK_DGRAM,NETLINK_KOBJECT_UEVENT)) < 0) {  
  13.         SLOGE("Unable to create uevent socket: %s", strerror(errno));  
  14.         return -1;  
  15.     }  
  16.   
  17.     if (setsockopt(mSock, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz)) < 0) {  
  18.         SLOGE("Unable to set uevent socket SO_RECBUFFORCE option: %s", strerror(errno));  
  19.         return -1;  
  20.     }  
  21.   
  22.     if (setsockopt(mSock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on)) < 0) {  
  23.         SLOGE("Unable to set uevent socket SO_PASSCRED option: %s", strerror(errno));  
  24.         return -1;  
  25.     }  
  26.   
  27.     if (bind(mSock, (struct sockaddr *) &nladdr, sizeof(nladdr)) < 0) {  
  28.         SLOGE("Unable to bind uevent socket: %s", strerror(errno));  
  29.         return -1;  
  30.     }  
  31.     // 利用新创建的socket实例化一个NetlinkHandler类对象，NetlinkHandler继承了类NetlinkListener，      
  32.     // NetlinkListener又继承了类SocketListener      
  33.     mHandler = new NetlinkHandler(mSock);  
  34.     if (mHandler->start()) {  //启动NetlinkHandler  
  35.         SLOGE("Unable to start NetlinkHandler: %s", strerror(errno));  
  36.         return -1;  
  37.     }  
  38.     return 0;  
  39. }  



把socket作为参数创建了NetlinkHandler对象，然后启动NetlinkHandler。

[cpp]  view plain copy
  1. int NetlinkHandler::start() {  
  2.     return this->startListener();  
  3. }  
  4.   
  5. int SocketListener::startListener() {  
  6.   
  7.     if (!mSocketName && mSock == -1) {  
  8.         SLOGE("Failed to start unbound listener");  
  9.         errno = EINVAL;  
  10.         return -1;  
  11.     } else if (mSocketName) {  
  12.         if ((mSock = android_get_control_socket(mSocketName)) < 0) {  
  13.             SLOGE("Obtaining file descriptor socket '%s' failed: %s",  
  14.                  mSocketName, strerror(errno));  
  15.             return -1;  
  16.         }  
  17.     }  
  18.   
  19.     if (mListen && listen(mSock, 4) < 0) {  
  20.         SLOGE("Unable to listen on socket (%s)", strerror(errno));  
  21.         return -1;  
  22.     } else if (!mListen)  
  23.         mClients->push_back(new SocketClient(mSock, false));  
  24.   
  25.     if (pipe(mCtrlPipe)) {  
  26.         SLOGE("pipe failed (%s)", strerror(errno));  
  27.         return -1;  
  28.     }  
  29.   
  30.     if (pthread_create(&mThread, NULL, SocketListener::threadStart, this)) {  
  31.         SLOGE("pthread_create (%s)", strerror(errno));  
  32.         return -1;  
  33.     }  
  34.   
  35.     return 0;  
  36. }  
  37.   
  38. void *SocketListener::threadStart(void *obj) {  
  39.     SocketListener *me = reinterpret_cast<SocketListener *>(obj);  
  40.   
  41.     me->runListener();  
  42.     pthread_exit(NULL);  
  43.     return NULL;  
  44. }  
  45.   
  46. void SocketListener::runListener() {  
  47.   
  48.     SocketClientCollection *pendingList = new SocketClientCollection();  
  49.   
  50.     while(1) { // 死循环，一直监听  
  51.         SocketClientCollection::iterator it;  
  52.         fd_set read_fds;  
  53.         int rc = 0;  
  54.         int max = -1;  
  55.   
  56.         FD_ZERO(&read_fds); //清空文件描述符集read_fds   
  57.   
  58.         if (mListen) {  
  59.             max = mSock;  
  60.             FD_SET(mSock, &read_fds); //添加文件描述符到文件描述符集read_fds  
  61.         }  
  62.   
  63.         FD_SET(mCtrlPipe[0], &read_fds); //添加管道的读取端文件描述符到read_fds  
  64.         if (mCtrlPipe[0] > max)  
  65.             max = mCtrlPipe[0];  
  66.   
  67.         pthread_mutex_lock(&mClientsLock); //对容器mClients的操作需要加锁  
  68.         for (it = mClients->begin(); it != mClients->end(); ++it) {  
  69.             int fd = (*it)->getSocket();  
  70.             FD_SET(fd, &read_fds); ////遍历容器mClients的所有成员，调用内联函数getSocket()获取文件描述符，并添加到文件描述符集read_fds  
  71.             if (fd > max)  
  72.                 max = fd;  
  73.         }  
  74.         pthread_mutex_unlock(&mClientsLock);  
  75.         // 等待文件描述符中某一文件描述符或者说socket有数据到来  
  76.         if ((rc = select(max + 1, &read_fds, NULL, NULL, NULL)) < 0) {  
  77.             if (errno == EINTR)  
  78.                 continue;  
  79.             SLOGE("select failed (%s)", strerror(errno));  
  80.             sleep(1);  
  81.             continue;  
  82.         } else if (!rc)  
  83.             continue;  
  84.   
  85.         if (FD_ISSET(mCtrlPipe[0], &read_fds))  
  86.             break;  
  87.         if (mListen && FD_ISSET(mSock, &read_fds)) { //监听套接字处理  
  88.             struct sockaddr addr;  
  89.             socklen_t alen;  
  90.             int c;  
  91.   
  92.             do {  
  93.                 alen = sizeof(addr);  
  94.                 c = accept(mSock, &addr, &alen); //接收链接请求，建立连接，如果成功c即为建立链接后的数据交换套接字,将其添加到mClient容器  
  95.             } while (c < 0 && errno == EINTR);  
  96.             if (c < 0) {  
  97.                 SLOGE("accept failed (%s)", strerror(errno));  
  98.                 sleep(1);  
  99.                 continue;  
  100.             }  
  101.             pthread_mutex_lock(&mClientsLock);  
  102.             mClients->push_back(new SocketClient(c, true));  
  103.             pthread_mutex_unlock(&mClientsLock);  
  104.         }  
  105.   
  106.         /* Add all active clients to the pending list first */  
  107.         pendingList->clear();  
  108.         pthread_mutex_lock(&mClientsLock);  
  109.         for (it = mClients->begin(); it != mClients->end(); ++it) {  
  110.             int fd = (*it)->getSocket();  
  111.             if (FD_ISSET(fd, &read_fds)) {  
  112.                 pendingList->push_back(*it);  
  113.             }  
  114.         }  
  115.         pthread_mutex_unlock(&mClientsLock);  
  116.   
  117.         /* Process the pending list, since it is owned by the thread, 
  118.          * there is no need to lock it */  
  119.         while (!pendingList->empty()) { //非监听套接字处理  
  120.             /* Pop the first item from the list */  
  121.             it = pendingList->begin();  
  122.             SocketClient* c = *it;  
  123.             pendingList->erase(it);  
  124.             /* Process it, if false is returned and our sockets are 
  125.              * connection-based, remove and destroy it */  
  126.             // ****** onDataAvailable在NetlinkListener中实现*********  
  127.              if (!onDataAvailable(c) && mListen) {  
  128.                 /* Remove the client from our array */  
  129.                 pthread_mutex_lock(&mClientsLock);  
  130.                 for (it = mClients->begin(); it != mClients->end(); ++it) {  
  131.                     if (*it == c) {  
  132.                         mClients->erase(it);  
  133.                         break;  
  134.                     }  
  135.                 }  
  136.                 pthread_mutex_unlock(&mClientsLock);  
  137.                 /* Remove our reference to the client */  
  138.                 c->decRef();  
  139.             }  
  140.         }  
  141.     }  
  142.     delete pendingList;  
  143. }  

          SocketListener::runListener是线程真正执行的函数：mListen成员用来判定是否监听套接字，Netlink套接字属于udp套接字，非监听套接字，该函数的主要功能体现在，如果该套接字有数据到来，就调用函数onDataAvailable读取数据。

3. NetlinkListener::onDataAvailable

[cpp]  view plain copy
  1. bool NetlinkListener::onDataAvailable(SocketClient *cli)  
  2. {  
  3.     int socket = cli->getSocket();  
  4.     ssize_t count;  
  5.       
  6.     // 从socket中读取kernel发送来的uevent消息  
  7.     count = TEMP_FAILURE_RETRY(uevent_kernel_multicast_recv(socket, mBuffer, sizeof(mBuffer)));  
  8.     if (count < 0) {  
  9.         SLOGE("recvmsg failed (%s)", strerror(errno));  
  10.         return false;  
  11.     }  
  12.   
  13.     NetlinkEvent *evt = new NetlinkEvent();  
  14.     if (!evt->decode(mBuffer, count, mFormat)) {  
  15.         SLOGE("Error decoding NetlinkEvent");  
  16.     } else {  
  17.         onEvent(evt); //在NetlinkHandler中实现  
  18.     }  
  19.   
  20.     delete evt;  
  21.     return true;  
  22. }  

4. NetlinkHandler::onEvent

[cpp]  view plain copy
  1. void NetlinkHandler::onEvent(NetlinkEvent *evt) {  
  2.     VolumeManager *vm = VolumeManager::Instance();  
  3.     const char *subsys = evt->getSubsystem();  
  4.   
  5.     if (!subsys) {  
  6.         SLOGW("No subsystem found in netlink event");  
  7.         return;  
  8.     }  
  9.   
  10.     if (!strcmp(subsys, "block")) {  
  11.         if(uEventOnOffFlag)  
  12.         {  
  13.             SLOGW("####netlink event  block ####");  
  14.             evt->dump();     
  15.         }  
  16.         vm->handleBlockEvent(evt);  
  17. #ifdef USE_USB_MODE_SWITCH  
  18.     } else if (!strcmp(subsys, "usb")  
  19.         || !strcmp(subsys, "scsi_device")) {  
  20.          SLOGW("subsystem found in netlink event");  
  21.         MiscManager *mm = MiscManager::Instance();  
  22.         mm->handleEvent(evt);  
  23. #endif  
  24.     }  
  25. }  

 

5. uevent_kernel_multicast_recv

[cpp]  view plain copy
  1. /** 
  2.  * Like recv(), but checks that messages actually originate from the kernel. 
  3.  */  
  4. ssize_t uevent_kernel_multicast_recv(int socket, void *buffer, size_t length) {  
  5.     struct iovec iov = { buffer, length };  
  6.     struct sockaddr_nl addr;  
  7.     char control[CMSG_SPACE(sizeof(struct ucred))];  
  8.     struct msghdr hdr = {  
  9.         &addr,  
  10.         sizeof(addr),  
  11.         &iov,  
  12.         1,  
  13.         control,  
  14.         sizeof(control),  
  15.         0,  
  16.     };  
  17.   
  18.     ssize_t n = recvmsg(socket, &hdr, 0);  
  19.     if (n <= 0) {  
  20.         return n;  
  21.     }  
  22.   
  23.     if (addr.nl_groups == 0 || addr.nl_pid != 0) {  
  24.         /* ignoring non-kernel or unicast netlink message */  
  25.         goto out;  
  26.     }  
  27.   
  28.     struct cmsghdr *cmsg = CMSG_FIRSTHDR(&hdr);  
  29.     if (cmsg == NULL || cmsg->cmsg_type != SCM_CREDENTIALS) {  
  30.         /* ignoring netlink message with no sender credentials */  
  31.         goto out;  
  32.     }  
  33.   
  34.     struct ucred *cred = (struct ucred *)CMSG_DATA(cmsg);  
  35.     if (cred->uid != 0) {  
  36.         /* ignoring netlink message from non-root user */  
  37.         goto out;  
  38.     }  
  39.   
  40.     return n;  
  41.   
  42. out:  
  43.     /* clear residual potentially malicious data */  
  44.     bzero(buffer, length);  
  45.     errno = EIO;  
  46.     return -1;  
  47. }  


 六、与Vold相关的Kernel态

  • 用户态创建的netlink sock被kernel保存在：nl_table[sk->sk_protocol].mc_list
  • Kernel态创建的netlink sock被kernel保存在：uevent_sock_list，上面的sk->sk_protocol为uevent_sock_list的协议, 二者只有协议一致才可以发送。

1. 创建kernel态sock

  •  在用户态的socket创建方式（/system/vold/NetlinkManager.cpp）：
[cpp]  view plain copy
  1. if ((mSock = socket(PF_NETLINK,  
  2.                     SOCK_DGRAM,NETLINK_KOBJECT_UEVENT)) < 0) {  
  3.     SLOGE("Unable to create uevent socket: %s", strerror(errno));  
  4.     return -1;  
  5. }  
  • 在Kernel的socket创建方式(/kernel/lib/kobject_uevent.c)：
[cpp]  view plain copy
  1. static int uevent_net_init(struct net *net)  
  2. {  
  3.     struct uevent_sock *ue_sk;  
  4.   
  5.     ue_sk = kzalloc(sizeof(*ue_sk), GFP_KERNEL);  
  6.     if (!ue_sk)  
  7.         return -ENOMEM;  
  8.   
  9.     ue_sk->sk = netlink_kernel_create(net, NETLINK_KOBJECT_UEVENT,  
  10.                       1, NULL, NULL, THIS_MODULE);  
  11.     if (!ue_sk->sk) {  
  12.         printk(KERN_ERR  
  13.                "kobject_uevent: unable to create netlink socket!\n");  
  14.         kfree(ue_sk);  
  15.         return -ENODEV;  
  16.     }  
  17.     mutex_lock(&uevent_sock_mutex);  
  18.     list_add_tail(&ue_sk->list, &uevent_sock_list);  
  19.     mutex_unlock(&uevent_sock_mutex);  
  20.     return 0;  
  21. }  

      从上面的代码可知，此sock被创建之后，被增加到全局变量uevent_sock_list列表中，下面的分析围绕此列表进行。

  • netlink_kernel_create函数原型：
[cpp]  view plain copy
  1. struct sock *netlink_kernel_create(struct net *net, int unit, unsigned int groups,  
  2.                          void (*input)(struct sk_buff *skb),  
  3.                          struct mutex *cb_mutex, struct module *module)  

       1) struct net *net:是一个网络名字空间namespace，在不同的名字空间里面可以有自己的转发信息库，有自己的一套net_device等等。默认情况下都是使用init_net这个全局变量

       2) int unit: 表示netlink协议类型，如 NETLINK_KOBJECT_UEVENT

       3)  unsigned int groups: 组类型

       4) void (*input)(struct sk_buff *skb):参数input则为内核模块定义的netlink消息处理函数，当有消息到达这个netlink socket时，该input函数指针就会被调用。函数指针input的参数skb实际上就是函数netlink_kernel_create返回的 struct sock指针，sock实际是socket的一个内核表示数据结构，用户态应用创建的socket在内核中也会有一个struct sock结构来表示。

       5) struct mutex *cb_mutex: 互斥销

       6) struct module *module: 一般为THIS_MODULE

  • struct sock

         用户态socket在kernel中的表示。

2. 相关数据结构

     相关数据结构如下图所示：

3. 发送消息给用户空间

  3.1 发送消息流程图

 

3.2 kobject_uevent_env

[cpp]  view plain copy
  1. /** 
  2.  * kobject_uevent_env - send an uevent with environmental data 
  3.  * 
  4.  * @action: action that is happening 
  5.  * @kobj: struct kobject that the action is happening to 
  6.  * @envp_ext: pointer to environmental data 
  7.  * 
  8.  * Returns 0 if kobject_uevent_env() is completed with success or the 
  9.  * corresponding error when it fails. 
  10.  */  
  11. int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,  
  12.                char *envp_ext[])  
  13. {  
  14.     struct kobj_uevent_env *env;  
  15.     const char *action_string = kobject_actions[action];  
  16.     const char *devpath = NULL;  
  17.     const char *subsystem;  
  18.     struct kobject *top_kobj;  
  19.     struct kset *kset;  
  20.     const struct kset_uevent_ops *uevent_ops;  
  21.     u64 seq;  
  22.     int i = 0;  
  23.     int retval = 0;  
  24. #ifdef CONFIG_NET  
  25.     struct uevent_sock *ue_sk;  
  26. #endif  
  27.   
  28.     pr_debug("kobject: '%s' (%p): %s\n",  
  29.          kobject_name(kobj), kobj, __func__);  
  30.   
  31.     /* search the kset we belong to */  
  32.     top_kobj = kobj;  
  33.     while (!top_kobj->kset && top_kobj->parent)  
  34.         top_kobj = top_kobj->parent;  
  35.   
  36.     if (!top_kobj->kset) {  
  37.         pr_debug("kobject: '%s' (%p): %s: attempted to send uevent "  
  38.              "without kset!\n", kobject_name(kobj), kobj,  
  39.              __func__);  
  40.         return -EINVAL;  
  41.     }  
  42.   
  43.     kset = top_kobj->kset;  
  44.     uevent_ops = kset->uevent_ops;  
  45.   
  46.     /* skip the event, if uevent_suppress is set*/  
  47.     if (kobj->uevent_suppress) {  
  48.         pr_debug("kobject: '%s' (%p): %s: uevent_suppress "  
  49.                  "caused the event to drop!\n",  
  50.                  kobject_name(kobj), kobj, __func__);  
  51.         return 0;  
  52.     }  
  53.     /* skip the event, if the filter returns zero. */  
  54.     if (uevent_ops && uevent_ops->filter)  
  55.         if (!uevent_ops->filter(kset, kobj)) {  
  56.             pr_debug("kobject: '%s' (%p): %s: filter function "  
  57.                  "caused the event to drop!\n",  
  58.                  kobject_name(kobj), kobj, __func__);  
  59.             return 0;  
  60.         }  
  61.   
  62.     /* originating subsystem */  
  63.     if (uevent_ops && uevent_ops->name)  
  64.         subsystem = uevent_ops->name(kset, kobj);  
  65.     else  
  66.         subsystem = kobject_name(&kset->kobj);  
  67.     if (!subsystem) {  
  68.         pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the "  
  69.              "event to drop!\n", kobject_name(kobj), kobj,  
  70.              __func__);  
  71.         return 0;  
  72.     }  
  73.   
  74.     /* environment buffer */  
  75.     env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);  
  76.     if (!env)  
  77.         return -ENOMEM;  
  78.   
  79.     /* complete object path */  
  80.     devpath = kobject_get_path(kobj, GFP_KERNEL);  
  81.     if (!devpath) {  
  82.         retval = -ENOENT;  
  83.         goto exit;  
  84.     }  
  85.   
  86.     /* default keys */  
  87.     retval = add_uevent_var(env, "ACTION=%s", action_string);  
  88.     if (retval)  
  89.         goto exit;  
  90.     retval = add_uevent_var(env, "DEVPATH=%s", devpath);  
  91.     if (retval)  
  92.         goto exit;  
  93.     retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);  
  94.     if (retval)  
  95.         goto exit;  
  96.   
  97.     /* keys passed in from the caller */  
  98.     if (envp_ext) {  
  99.         for (i = 0; envp_ext[i]; i++) {  
  100.             retval = add_uevent_var(env, "%s", envp_ext[i]);  
  101.             if (retval)  
  102.                 goto exit;  
  103.         }  
  104.     }  
  105.   
  106.     /* let the kset specific function add its stuff */  
  107.     if (uevent_ops && uevent_ops->uevent) {  
  108.         retval = uevent_ops->uevent(kset, kobj, env);  
  109.         if (retval) {  
  110.             pr_debug("kobject: '%s' (%p): %s: uevent() returned "  
  111.                  "%d\n", kobject_name(kobj), kobj,  
  112.                  __func__, retval);  
  113.             goto exit;  
  114.         }  
  115.     }  
  116.   
  117.     /* 
  118.      * Mark "add" and "remove" events in the object to ensure proper 
  119.      * events to userspace during automatic cleanup. If the object did 
  120.      * send an "add" event, "remove" will automatically generated by 
  121.      * the core, if not already done by the caller. 
  122.      */  
  123.     if (action == KOBJ_ADD)  
  124.         kobj->state_add_uevent_sent = 1;  
  125.     else if (action == KOBJ_REMOVE)  
  126.         kobj->state_remove_uevent_sent = 1;  
  127.   
  128.     /* we will send an event, so request a new sequence number */  
  129.     spin_lock(&sequence_lock);  
  130.     seq = ++uevent_seqnum;  
  131.     spin_unlock(&sequence_lock);  
  132.     retval = add_uevent_var(env, "SEQNUM=%llu", (unsigned long long)seq);  
  133.     if (retval)  
  134.         goto exit;  
  135.   
  136. #if defined(CONFIG_NET)  
  137.     /* send netlink message */  
  138.     mutex_lock(&uevent_sock_mutex);  
  139.     list_for_each_entry(ue_sk, &uevent_sock_list, list) {  
  140.         struct sock *uevent_sock = ue_sk->sk;  
  141.         struct sk_buff *skb;  
  142.         size_t len;  
  143.   
  144.         /* allocate message with the maximum possible size */  
  145.         len = strlen(action_string) + strlen(devpath) + 2;  
  146.         skb = alloc_skb(len + env->buflen, GFP_KERNEL);  
  147.         if (skb) {  
  148.             char *scratch;  
  149.   
  150.             /* add header */  
  151.             scratch = skb_put(skb, len);  
  152.             sprintf(scratch, "%s@%s", action_string, devpath); //action_string+devpath  
  153.   
  154.             /* copy keys to our continuous event payload buffer */  
  155.             for (i = 0; i < env->envp_idx; i++) {  
  156.                 len = strlen(env->envp[i]) + 1;  
  157.                 scratch = skb_put(skb, len);  
  158.                 strcpy(scratch, env->envp[i]);  
  159.             }  
  160.   
  161.             NETLINK_CB(skb).dst_group = 1;  
  162.             retval = netlink_broadcast_filtered(uevent_sock, skb,  
  163.                                 0, 1, GFP_KERNEL,  
  164.                                 kobj_bcast_filter,  
  165.                                 kobj);  
  166.             /* ENOBUFS should be handled in userspace */  
  167.             if (retval == -ENOBUFS)  
  168.                 retval = 0;  
  169.         } else  
  170.             retval = -ENOMEM;  
  171.     }  
  172.     mutex_unlock(&uevent_sock_mutex);  
  173. #endif  
  174.   
  175.     /* call uevent_helper, usually only enabled during early boot */  
  176.     if (uevent_helper[0] && !kobj_usermode_filter(kobj)) {  
  177.         char *argv [3];  
  178.   
  179.         argv [0] = uevent_helper;  
  180.         argv [1] = (char *)subsystem;  
  181.         argv [2] = NULL;  
  182.         retval = add_uevent_var(env, "HOME=/");  
  183.         if (retval)  
  184.             goto exit;  
  185.         retval = add_uevent_var(env,  
  186.                     "PATH=/sbin:/bin:/usr/sbin:/usr/bin");  
  187.         if (retval)  
  188.             goto exit;  
  189.   
  190.         retval = call_usermodehelper(argv[0], argv,  
  191.                          env->envp, UMH_WAIT_EXEC);  
  192.     }  
  193.   
  194. exit:  
  195.     kfree(devpath);  
  196.     kfree(env);  
  197.     return retval;  
  198. }  


 

[cpp]  view plain copy
  1. /** 
  2.  * kobject_uevent - notify userspace by sending an uevent 
  3.  * 
  4.  * @action: action that is happening 
  5.  * @kobj: struct kobject that the action is happening to 
  6.  * 
  7.  * Returns 0 if kobject_uevent() is completed with success or the 
  8.  * corresponding error when it fails. 
  9.  */  
  10. int kobject_uevent(struct kobject *kobj, enum kobject_action action)  
  11. {  
  12.     return kobject_uevent_env(kobj, action, NULL);  
  13. }  


3.3 netlink_broadcast_filtered

[cpp]  view plain copy
  1. int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 pid,  
  2.     u32 group, gfp_t allocation,  
  3.     int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data),  
  4.     void *filter_data)  
  5. {  
  6.     struct net *net = sock_net(ssk);  
  7.     struct netlink_broadcast_data info;  
  8.     struct hlist_node *node;  
  9.     struct sock *sk;  
  10.   
  11.     skb = netlink_trim(skb, allocation);  
  12.   
  13.     info.exclude_sk = ssk;  
  14.     info.net = net;  
  15.     info.pid = pid;  
  16.     info.group = group;  
  17.     info.failure = 0;  
  18.     info.delivery_failure = 0;  
  19.     info.congested = 0;  
  20.     info.delivered = 0;  
  21.     info.allocation = allocation;  
  22.     info.skb = skb;  
  23.     info.skb2 = NULL;  
  24.     info.tx_filter = filter;  
  25.     info.tx_data = filter_data;  
  26.   
  27.     /* While we sleep in clone, do not allow to change socket list */  
  28.   
  29.     netlink_lock_table();  
  30.          // 向nl_table[ssk->sk_protocol].mc_list中的每个sock发送此netlink消息  
  31.     sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list)  
  32.         do_one_broadcast(sk, &info);   
  33.   
  34.     consume_skb(skb);  
  35.   
  36.     netlink_unlock_table();  
  37.   
  38.     if (info.delivery_failure) {  
  39.         kfree_skb(info.skb2);  
  40.         return -ENOBUFS;  
  41.     } else  
  42.         consume_skb(info.skb2);  
  43.   
  44.     if (info.delivered) {  
  45.         if (info.congested && (allocation & __GFP_WAIT))  
  46.             yield();  
  47.         return 0;  
  48.     }  
  49.     return -ESRCH;  
  50. }  

        static struct netlink_table *nl_table；是全局变量，它维护了用户态创建的所有netlink sock，按协议分类，每种协议一个链表mc_list。它在函数netlink_proto_init中被初始化，向nl_table[sk->sk_protocol].mc_list中增加sock的调用流程如下(kernel/net/netlink/af_netlink.c)：

 


3.4 do_one_broadcast

[cpp]  view plain copy
  1. static inline int do_one_broadcast(struct sock *sk,  
  2.                    struct netlink_broadcast_data *p)  
  3. {  
  4.     struct netlink_sock *nlk = nlk_sk(sk);  
  5.     int val;  
  6.   
  7.     if (p->exclude_sk == sk)  
  8.         goto out;  
  9.   
  10.     if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups ||  
  11.         !test_bit(p->group - 1, nlk->groups))  
  12.         goto out;  
  13.   
  14.     if (!net_eq(sock_net(sk), p->net))  
  15.         goto out;  
  16.   
  17.     if (p->failure) {  
  18.         netlink_overrun(sk);  
  19.         goto out;  
  20.     }  
  21.   
  22.     sock_hold(sk);  
  23.     if (p->skb2 == NULL) {  
  24.         if (skb_shared(p->skb)) {  
  25.             p->skb2 = skb_clone(p->skb, p->allocation);  
  26.         } else {  
  27.             p->skb2 = skb_get(p->skb);  
  28.             /* 
  29.              * skb ownership may have been set when 
  30.              * delivered to a previous socket. 
  31.              */  
  32.             skb_orphan(p->skb2);  
  33.         }  
  34.     }  
  35.     if (p->skb2 == NULL) {  
  36.         netlink_overrun(sk);  
  37.         /* Clone failed. Notify ALL listeners. */  
  38.         p->failure = 1;  
  39.         if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR)  
  40.             p->delivery_failure = 1;  
  41.     } else if (p->tx_filter && p->tx_filter(sk, p->skb2, p->tx_data)) {  
  42.         kfree_skb(p->skb2);  
  43.         p->skb2 = NULL;  
  44.     } else if (sk_filter(sk, p->skb2)) {  
  45.         kfree_skb(p->skb2);  
  46.         p->skb2 = NULL;  
  47.     } else if ((val = netlink_broadcast_deliver(sk, p->skb2)) < 0) {  
  48.         netlink_overrun(sk);  
  49.         if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR)  
  50.             p->delivery_failure = 1;  
  51.     } else {  
  52.         p->congested |= val;  
  53.         p->delivered = 1;  
  54.         p->skb2 = NULL;  
  55.     }  
  56.     sock_put(sk);  
  57.   
  58. out:  
  59.     return 0;  
  60. }  


3.5 netlink_broadcast_deliver

[cpp]  view plain copy
  1. static inline int netlink_broadcast_deliver(struct sock *sk,  
  2.                         struct sk_buff *skb)  
  3. {  
  4.     struct netlink_sock *nlk = nlk_sk(sk);  
  5.   
  6.     if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&  
  7.         !test_bit(0, &nlk->state)) {  
  8.         skb_set_owner_r(skb, sk);  
  9.         skb_queue_tail(&sk->sk_receive_queue, skb);  
  10.         sk->sk_data_ready(sk, skb->len);  
  11.         return atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf;  
  12.     }  
  13.     return -1;  
  14. }  

文章标签：
云解析DNS
Android开发
C++
存储
容器
Java
数据建模
监控
Linux
关键词：
Android热插拔
code_xzh
目录
相关文章
技术小胖子
|
Android开发
Tegra3 vSMP架构Android运行时CPU热插拔及高低功耗CPU切换
技术小胖子
1491 0
aqi00
|
4天前
|
Linux 编译器 Android开发
FFmpeg开发笔记（九）Linux交叉编译Android的x265库
在Linux环境下，本文指导如何交叉编译x265的so库以适应Android。首先，需安装cmake和下载android-ndk-r21e。接着，下载x265源码，修改crosscompile.cmake的编译器设置。配置x265源码，使用指定的NDK路径，并在配置界面修改相关选项。随后，修改编译规则，编译并安装x265，调整pc描述文件并更新PKG_CONFIG_PATH。最后，修改FFmpeg配置脚本启用x265支持，编译安装FFmpeg，将生成的so文件导入Android工程，调整gradle配置以确保顺利运行。
aqi00
24 1
FFmpeg开发笔记（九）Linux交叉编译Android的x265库
张继群
|
27天前
|
Java Android开发
Android 开发获取通知栏权限时会出现两个应用图标
Android 开发获取通知栏权限时会出现两个应用图标
张继群
14 0
Hdnw
|
1月前
|
XML 缓存 Android开发
Android开发，使用kotlin学习多媒体功能（详细）
Android开发，使用kotlin学习多媒体功能（详细）
Hdnw
103 0
shuj
|
1月前
|
设计模式 人工智能 开发工具
安卓应用开发：构建未来移动体验
【2月更文挑战第17天】 随着智能手机的普及和移动互联网技术的不断进步，安卓应用开发已成为一个热门领域。本文将深入探讨安卓平台的应用开发流程、关键技术以及未来发展趋势。通过分析安卓系统的架构、开发工具和框架，本文旨在为开发者提供全面的技术指导，帮助他们构建高效、创新的移动应用，以满足不断变化的市场需求。
shuj
18 1
shuj
|
1月前
|
机器学习/深度学习 调度 Android开发
安卓应用开发：打造高效通知管理系统
【2月更文挑战第14天】 在移动操作系统中，通知管理是影响用户体验的关键因素之一。本文将探讨如何在安卓平台上构建一个高效的通知管理系统，包括服务、频道和通知的优化策略。我们将讨论最新的安卓开发工具和技术，以及如何通过这些工具提高通知的可见性和用户互动性，同时确保不会对用户造成干扰。
shuj
33 1
请看我回答~
|
1天前
|
数据库 Android开发 开发者
安卓应用开发：构建高效用户界面的策略
【4月更文挑战第24天】 在竞争激烈的移动应用市场中，一个流畅且响应迅速的用户界面(UI)是吸引和保留用户的关键。针对安卓平台，开发者面临着多样化的设备和系统版本，这增加了构建高效UI的复杂性。本文将深入分析安卓平台上构建高效用户界面的最佳实践，包括布局优化、资源管理和绘制性能的考量，旨在为开发者提供实用的技术指南，帮助他们创建更流畅的用户体验。
请看我回答~
5 0
请看我回答~
|
18天前
|
XML 开发工具 Android开发
构建高效的安卓应用：使用Jetpack Compose优化UI开发
【4月更文挑战第7天】 随着Android开发不断进化，开发者面临着提高应用性能与简化UI构建流程的双重挑战。本文将探讨如何使用Jetpack Compose这一现代UI工具包来优化安卓应用的开发流程，并提升用户界面的流畅性与一致性。通过介绍Jetpack Compose的核心概念、与传统方法的区别以及实际集成步骤，我们旨在提供一种高效且可靠的解决方案，以帮助开发者构建响应迅速且用户体验优良的安卓应用。
请看我回答~
19 0
请看我回答~
|
21天前
|
监控 算法 Android开发
安卓应用开发：打造高效启动流程
【4月更文挑战第5天】 在移动应用的世界中，用户的第一印象至关重要。特别是对于安卓应用而言，启动时间是用户体验的关键指标之一。本文将深入探讨如何优化安卓应用的启动流程，从而减少启动时间，提升用户满意度。我们将从分析应用启动流程的各个阶段入手，提出一系列实用的技术策略，包括代码层面的优化、资源加载的管理以及异步初始化等，帮助开发者构建快速响应的安卓应用。
请看我回答~
13 0
aqi00
|
21天前
|
Java Android开发
Android开发之使用OpenGL实现翻书动画
本文讲述了如何使用OpenGL实现更平滑、逼真的电子书翻页动画，以解决传统贝塞尔曲线方法存在的卡顿和阴影问题。作者分享了一个改造后的外国代码示例，提供了从前往后和从后往前的翻页效果动图。文章附带了`GlTurnActivity`的Java代码片段，展示如何加载和显示书籍图片。完整工程代码可在作者的GitHub找到：https://github.com/aqi00/note/tree/master/ExmOpenGL。
aqi00
22 1
Android开发之使用OpenGL实现翻书动画

热门文章

最新文章

  • 1
    我的Android之路(持续更新总结~)
  • 2
    Android实现自定义进度条(源码+解析)
  • 3
    安卓适配性策略：确保应用在不同设备上的兼容性
  • 4
    构建高效Android应用：探究Kotlin与Java的性能差异
  • 5
    安卓安全性指南：保护用户数据免受恶意攻击
  • 6
    安卓多线程和并发处理：提高应用效率
  • 7
    安卓UI/UX设计原则：打造引人入胜的用户体验
  • 8
    Android为什么不能在子线程更新UI
  • 9
    构建高效Android应用：从优化用户体验到提升性能
  • 10
    安卓投屏神器 Scrcpy安 报错ERROR: Could not find any ADB device
  • 1
    构建高效Android应用：Kotlin协程的实践指南
    17
  • 2
    构建高效Android应用：Kotlin与协程的完美融合
    27
  • 3
    【Android平板编程】远程Ubuntu服务器code-server编程写代码
    53
  • 4
    android 使用GSON 序列化对象出现字段被优化问题解决方案
    17
  • 5
    构建高效安卓应用：探究Kotlin与Java的性能对比
    67
  • 6
    构建高效安卓应用：探究Kotlin与Java的性能差异
    19
  • 7
    ADB 下载、安装及使用教程：让你更好地管理 Android 设备
    510
  • 8
    前端分析工具之 Charles 录制 Android/IOS 手机的 https 应用
    58
  • 9
    构建高效的安卓应用：探究Kotlin与Java的性能差异
    20
  • 10
    构建高效Android应用：探究Kotlin与Java的性能差异
    53

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）