从 AIDL 到 AMS:app 是怎么摸到系统服务的

Android AMS原理分析 AMS(ActivityManagerService)本质上就是一个AIDL,通过他调用系统的底层服务,加载Activity、Service四大组件。 系统版本:Android10.0(29) 各个版本具体的执行过程可能存在差异,但是总体的流程还是一样的,都是需要两次AIDL,来和系统进行交互。 下面就来分析代码执行流程 startActivity(new Intent(MainActivity.this,MainActivity.class)); 从上面这行代码开始:下面是依次执行的流程图 其中有 两 阅读详情

这篇文章记录一下对于AIDL 的理解和总结。 我自己最早有个误解:context.getSystemService(ACTIVITY_SERVICE) 拿到的那个 ActivityManager,就是 AMS 的 Binder 代理。

但其实不是。中间还隔着一层。而恰好是这一层,解释了为什么 Google 敢每个版本都大改 AMS 的接口,却不会把所有 app 都搞崩。

要说清楚这件事,得先看 AIDL 到底生成了什么。

一、AIDL 生成的三件套

写一个 IFoo.aidl:

interface IFoo {
    int doSomething(int arg);
}

编译期 aidl 工具生成一个 IFoo.java,一个文件里塞了三样东西。

public interface IFoo extends android.os.IInterface {

    int doSomething(int arg) throws RemoteException;

    // ① 服务端基类
    public static abstract class Stub extends Binder implements IFoo {
        private static final String DESCRIPTOR = "com.example.IFoo";
        static final int TRANSACTION_doSomething = FIRST_CALL_TRANSACTION + 0;

        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        public static IFoo asInterface(IBinder obj) {
            if (obj == null) return null;
            IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (iin != null && iin instanceof IFoo) {
                return (IFoo) iin;              // 同进程,直接给实现对象
            }
            return new Stub.Proxy(obj);         // 跨进程,包一层代理
        }

        @Override
        public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
                throws RemoteException {
            switch (code) {
                case TRANSACTION_doSomething: {
                    data.enforceInterface(DESCRIPTOR);
                    int _arg0 = data.readInt();
                    int _result = this.doSomething(_arg0);   // 调自己
                    reply.writeNoException();
                    reply.writeInt(_result);
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        // ② 客户端代理
        private static class Proxy implements IFoo {
            private IBinder mRemote;
            Proxy(IBinder remote) { mRemote = remote; }

            @Override
            public int doSomething(int arg) throws RemoteException {
                Parcel data = Parcel.obtain();
                Parcel reply = Parcel.obtain();
                int _result;
                try {
                    data.writeInterfaceToken(DESCRIPTOR);
                    data.writeInt(arg);
                    mRemote.transact(TRANSACTION_doSomething, data, reply, 0);
                    reply.readException();
                    _result = reply.readInt();
                } finally {
                    reply.recycle();
                    data.recycle();
                }
                return _result;
            }
        }
    }
}

③ 是你自己写的实现,继承 Stub:

public class FooService extends IFoo.Stub {
    @Override
    public int doSomething(int arg) {
        return arg * 2;     // 真逻辑在这
    }
}

机制本身没什么玄学:Proxy 把参数塞进 Parcel 发出去,Stub 在对端把 Parcel 拆开、按 code 找到对应方法、把返回值塞回 reply。transact 最后那个 flags 参数默认是 0,表示同步等待;AIDL 里方法声明成 oneway 时才会变成 FLAG_ONEWAY,发完就返回。

读这段代码有两个地方特别容易说错。

Stub 不转发给别人,它分发给自己

onTransact 里 switch 完 code 之后调的是 this.doSomething(_arg0),this 就是 Stub 自己。Stub 是 abstract 的,doSomething 在这里没有实现体,实现落在你写的子类上。

所以 Stub 的职责就三件事:解包 Parcel、按 code 分发到自己的抽象方法、把结果打包进 reply。它不认识任何别的 service,也不负责路由。“Stub 根据 code 调用不同的 service” 这个说法是错的——同一个 Stub 从头到尾只服务一个实现对象。

asInterface 有一条同进程短路

Stub 的构造函数里调了 attachInterface(this, DESCRIPTOR),把自己和描述符绑在了一起。于是:

  • 如果 obj 是本进程的 Binder 对象,queryLocalInterface(DESCRIPTOR) 描述符对得上,直接把实现对象还给你
  • 如果 obj 是 BinderProxy(跨进程拿到的句柄),queryLocalInterface 恒返回 null,这才走 new Stub.Proxy(obj)

这不是什么可以忽略的优化细节,它会改变你对调用栈的判断。同一行 IFoo.Stub.asInterface(b).doSomething(1),在 app 进程里是一次完整的跨进程 transact,在服务自己所在的进程里就是一次普通虚方法调用——连 Parcel.obtain() 都不会发生。后面讲 AMS 的时候这一点还会再咬一次。

顺便提一句容易踩的坑:Binder 的事务缓冲区每个进程只有 1MB 左右,而且是整个进程所有并发事务共享的。往 AIDL 方法里传大 Bitmap 或者几万条记录的 List,TransactionTooLargeException 就是这么来的。

二、AMS 这条链上多了一层门面

现在回到开头那个误解。ActivityManager 和 ActivityManagerService 之间,完整的层次是这样:

App 代码
   │  context.getSystemService(ACTIVITY_SERVICE)
   ▼
android.app.ActivityManager                        门面(facade),公开 SDK
   │  内部调 ActivityManager.getService()
   ▼
IActivityManager                                   AIDL 接口,@hide
   │
IActivityManager.Stub.Proxy                        真正的客户端代理
   │
 ═══ Binder 驱动 ═══  跨进程
   │
IActivityManager.Stub.onTransact()
   ▼
ActivityManagerService extends IActivityManager.Stub       system_server 里的实现

ActivityManager 不是 Proxy,它是 Proxy 外面的一层壳。

为什么要多这一层

IActivityManager 是 @hide 的,不在 SDK 里。它的方法签名几乎每个版本都在变——加参数、改类型、拆方法。如果 app 直接面对它,Android 的每次大版本升级都会是一场屠杀。

门面挡在前面之后,ActivityManager 的公开方法签名可以保持稳定,底下的 AIDL 随便改。除此之外门面还承担一些杂活:参数校验、常量定义、本地缓存,以及若干根本不需要 IPC 的便利方法。

历史包袱

IActivityManager 在 Android 8.0 之前根本不是 AIDL,是手写的:

  • ActivityManagerNative extends Binder implements IActivityManager——手写的 Stub,onTransact 是一个几百行的巨型 switch
  • ActivityManagerProxy implements IActivityManager——手写的 Proxy
  • 拿代理走 ActivityManagerNative.getDefault()

8.0 改成了 AIDL 自动生成,ActivityManagerNative 被删掉,获取代理的入口搬到了 ActivityManager.getService()。所以看老文章或者老项目里的 ActivityManagerNative.getDefault(),那是 7.x 及以前的写法。

三、两条完全不同的获取路径

这是我认为最容易混的地方:门面对象和 Proxy,走的是两条毫不相干的路。

路径 A:拿门面 —— 走 Context

ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
ContextImpl.getSystemService(name)
  → SystemServiceRegistry.getSystemService(this, name)
      → 静态 Map SYSTEM_SERVICE_FETCHERS.get(name)
          → CachedServiceFetcher.getService(ctx)
              → new ActivityManager(ctx.getOuterContext(), handler)

SystemServiceRegistry 在类静态初始化阶段就把几十个 Manager 的构造方式注册进一张表:

registerService(Context.ACTIVITY_SERVICE, ActivityManager.class,
        new CachedServiceFetcher<ActivityManager>() {
    @Override
    public ActivityManager createService(ContextImpl ctx) {
        return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());
    }
});

Fetcher 有几种,决定了实例的生命周期:

  • CachedServiceFetcher——按 ContextImpl 缓存,存在 ctx.mServiceCache 数组里。同一个 Activity 里反复 getSystemService 拿到的是同一个对象,但换一个 Context 就是另一个实例
  • StaticServiceFetcher——进程级单例,不需要 Context
  • StaticApplicationContextServiceFetcher——进程级单例,但构造时要 Application Context

这也顺带解释了一个常见问题:为什么有些 Manager 用 Activity Context 和用 Application Context 行为不一样。答案取决于它注册时用的是哪种 fetcher。

路径 B:拿 Proxy —— 不走 Context

// android.app.ActivityManager
private static final Singleton<IActivityManager> IActivityManagerSingleton =
        new Singleton<IActivityManager>() {
    @Override
    protected IActivityManager create() {
        final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
        return IActivityManager.Stub.asInterface(b);
    }
};

public static IActivityManager getService() {
    return IActivityManagerSingleton.get();
}

注意这是 static 方法、进程级单例,跟 Context 一点关系没有。门面类只是恰好把它封在自己身上,概念上两者是独立的。

所以对"这个 manager 是通过 context 获取的对吗"这个问题,准确的答案是:门面对象是,底下的 Proxy 不是。

ServiceManager 这一跳怎么自举

这里有个鸡生蛋的问题:要找 AMS 得问 servicemanager,那 servicemanager 自己的 Binder 从哪来?

ServiceManager.getService("activity")
  → getIServiceManager()
      → ServiceManagerNative.asInterface(BinderInternal.getContextObject())
                                          └─ native 方法,固定返回 handle = 0

BinderInternal.getContextObject() 落到 native 是 ProcessState::getContextObject(),最终 getStrongProxyForHandle(0)。handle 0 是全系统约定死的 servicemanager,不需要查询,这是整个 Binder 体系的引导点。

ServiceManager 里还有个 sCache。AMS 在 bindApplication 的时候会顺手把几个常用服务的 binder 一起塞给新进程,ActivityThread.handleBindApplication 调 ServiceManager.initServiceCache() 填进去,省掉冷启动时的几次 IPC。

而 AMS 能被查到,是因为 system_server 主动登记过。登记的位置不在构造函数里,而在 setSystemProcess():

// ActivityManagerService.setSystemProcess()
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
        DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);

这个方法由 SystemServer.startBootstrapServices() 在 AMS 构造完之后调用。

四、完整链路串一遍

① system_server 启动
     AMS = new ActivityManagerService()            // extends IActivityManager.Stub
     AMS.setSystemProcess()
       → ServiceManager.addService("activity", AMS)

② App:  context.getSystemService(ACTIVITY_SERVICE)
     SystemServiceRegistry → new ActivityManager(ctx)      // 门面,按 Context 缓存

③ App:  am.getRunningAppProcesses()
     ActivityManager.getService()                          // 首次调用
       → ServiceManager.getService("activity")
           → handle 0(servicemanager)→ 返回 AMS 的 binder 句柄
       → IActivityManager.Stub.asInterface(b)
           → queryLocalInterface() == null(跨进程)
           → new IActivityManager.Stub.Proxy(b)            // 代理在这一刻诞生

④ Proxy.getRunningAppProcesses()
     writeInterfaceToken + 写参数
     mRemote.transact(code, data, reply, 0)
       ═══ Binder 驱动 ═══
     system_server 的 Binder 线程池
       → AMS.onTransact(code, ...)                         // 继承自 Stub
       → switch(code) → AMS.getRunningAppProcesses()        // 真实现
     结果写进 reply,原路返回

五、几个容易踩的点

在 system_server 里拿到的不是 Proxy

承接前面那条同进程短路。ActivityManager.getService() 在 system_server 自己进程里调用时,queryLocalInterface() 命中,返回的就是 AMS 对象本身。

同一行代码在 app 里是 IPC、在 system_server 里是普通方法调用。调 debug 的时候看到的调用栈会完全不一样,知道这件事能省很多困惑。

framework 内部大多绕过门面

门面类主要是给 app 开发者用的。framework 自己(ActivityThread、Instrumentation、ContextImpl)基本都是直接拿 Proxy。startActivity 就是典型:

Activity.startActivity()
  → Instrumentation.execStartActivity()
      → ActivityTaskManager.getService().startActivity(...)

这里还藏着一个版本变化:Android 10 把 AMS 拆了。Activity、窗口、任务栈相关的逻辑搬到了 ActivityTaskManagerService,对应 IActivityTaskManager;AMS 留下进程管理、广播、ContentProvider、内存。所以现在 startActivity 的对端是 ATMS 不是 AMS,看老文章里画的 AMS.startActivity 已经不准了。

反方向也有一套 Stub

AMS 要回调 app 的时候,走的是 IApplicationThread。实现类 ActivityThread.ApplicationThread extends IApplicationThread.Stub,住在 app 进程里。

所以 app 既是 Binder 的 client 也是 server,这套机制是对称的。AMS 持有每个 app 进程的 IApplicationThread 代理,app 持有 AMS 的 IActivityManager 代理。

这里要纠正一个过时的说法。Android 9 之前,IApplicationThread 上是一堆细粒度方法:scheduleLaunchActivity、scheduleResumeActivity、scheduleStopActivity……Android 9 重构成了事务模式:

// 现在只有这一个入口
void scheduleTransaction(ClientTransaction transaction);

server 侧把若干 ClientTransactionItem(回调)和一个 ActivityLifecycleItem(目标生命周期状态)打包成一个 ClientTransaction,由 ClientLifecycleManager 一次性发过去;app 侧 ActivityThread.scheduleTransaction() 收到后丢一个 EXECUTE_TRANSACTION 消息到主线程队列,再由 TransactionExecutor 逐项执行。

好处是生命周期切换变成了一次 IPC 加一个状态机,而不是多次 IPC 互相竞争。读 Android 9 之后的源码,如果还在找 scheduleLaunchActivity,是找不到的。

不是所有 Manager 都包着 Binder 代理

这条链条讲完容易产生一个印象:Manager 背后一定有个远端服务。其实不一定。

  • ActivityManager → IActivityManager 代理,有 IPC
  • PackageManager(ApplicationPackageManager)→ IPackageManager 代理,有 IPC
  • WindowManager → WindowManagerImpl → WindowManagerGlobal → IWindowManager / IWindowSession,结构更绕
  • LayoutInflater → 纯本地,一个 Binder 都没有

六、版本差异速查

变化版本说明
IActivityManager 从手写改为 AIDL8.0 (API 26)ActivityManagerNative / ActivityManagerProxy 被删,入口改为 ActivityManager.getService()
IApplicationThread 改为事务模式9.0 (API 28)scheduleXxxActivity 系列被 scheduleTransaction(ClientTransaction) 取代
AMS 拆出 ATMS10 (API 29)Activity / 窗口 / 任务栈归 ActivityTaskManagerService,IActivityTaskManager

最后

整件事的结构其实很简单,就是一句话:AIDL 给你 Proxy 和 Stub,Manager 是 Proxy 外面的门面,Proxy 靠 ServiceManager(handle 0)找到对端。

容易绕进去的地方在于三个"看起来是一个东西但不是":

  • ActivityManager 不是 IActivityManager,更不是 ActivityManagerService
  • getSystemService() 给你门面,ServiceManager.getService() 给你句柄,两条路
  • asInterface() 不保证返回代理,同进程时它返回的是实现对象本身

把这三条分清楚,剩下的都是查源码的体力活。


参考

AIDL & Binder机制和原理 而该Bp客户端的实例化流程,首先会先通过Parcel的readStrongBinder实例化一个BpBinder,然后一般会通过调用对应接口类中的asInterface方法将BpBinder转化为一个真正的Bp接口客户端,其实这个转化就是实例化一个Bp客户端,实例化时,会将BpBinder作为构造传参传入Bp客户端中。在C++层面的Binder相关类中,所谓的Bn端就是Binder的服务端,在此例中,Cameraservice的Bn端,显然就是之前AIDL自动生成的BnCameraService。 阅读详情

相关推荐

跨进程通信---AIDL

有过一定工作经验的Android程序员,肯定是听过AIDL的。之前我也是经常听别人讲,最近下功夫去专门看了下,总算自己参照示例写出来一个Demo出来,为了加深印象,总结本篇文章。 AIDL:Android Interface Definition Language,Android接口定义语言。看这名称:是一种语言。我学过java语言、C语言、C++语言,虽然知道每种语言之间有一定的互通之处,但是却也是各有各的规则。AIDL称为一种语言,想来应该有一套完整体系。在来关注 Interface ,接口,我们知道,

u010869159的博客 1952

AMS分析

理解AMS的大前提 Android体系结构 Android系统是基于Linux内核开发的,Android系统的上层与Linux内核是通过系统调用进行通信的。 epoll Android系统启动过程 SystemServer进程会启动大量的服务,这些服务包括三大类:引导服务、核心服务、其他服务。其中,AMS属于引导服务。 启动了AMS后才能启动Launch这个app。 SystemServer /** * The main entry point from zygote. *

yzpbright的博客 2944

Android 进阶——系统启动之Framework 核心ActivitityManagerService服务启动(十)

Framework 核心ActivitityManagerService服务启动

最美不过,心中有梦,身旁有你! 1945

frameworks 之 AMS与ActivityThread交互

frameworks 之 AMS与ActivityThread交互

u011410770的博客 1428

Android Framework学习路线:从Binder到AMS的系统级进阶指南

Android应用开发者的技术成长,往往受限于对底层的理解程度。掌握Android Framework,意味着从调用API升级为理解系统设计,能够真正解决App启动慢、进程被杀、ANR等疑难问题。核心机制如Binder跨进程通信、Handler消息循环、AMS组件调度,构成了整个系统的神经网络与心脏。理解这些原理,不仅有助于精准定位性能瓶颈,还能在混合开发通信、多进程架构等场景中做出更优的技术决策。无论是突破业务开发的天花板,还是应对高级岗位面试中对系统原理的追问,深入学习Framework都是关键路径。本

weixin_34209851的博客 399

保姆级教程:用OpenCV和MediaPipe在Python里实现实时手势识别(附完整代码)

本文提供了一份详细的Python教程,教你如何使用OpenCV和MediaPipe实现实时手势识别系统。从环境配置、手部关键点检测到手势分类算法,逐步讲解如何构建高精度手势识别应用,适用于智能家居控制、PPT操作等场景。教程包含完整代码示例和性能优化技巧,特别适合计算机视觉初学者和开发者实践。

weixin_28677005的博客 332

AMS 启动流程&管理进程&与Binder的关联

App进程] --(Binder IPC)--> [AMS in system_server] --(Binder IPC)--> [Zygote/WMS/PMS]“AMS通过adj值标记进程重要性(如0为前台进程,15为缓存进程),内核根据adj值决定回收顺序。“AMS是启动流程的中枢,负责权限校验、进程创建、生命周期调度,并协调WMS/PMS完成显示。:AMS是Activity启动的“大脑”,负责权限校验、进程创建、生命周期调度和跨进程协调。:当系统内存不足时,内核优先杀死高adj值的进程(如先杀。

斗锋在干嘛的博客 994

研究生课程笔记:软件包在流行病学中的应用(三)——STATA软件

关键词:STATA软件基本操作、STATA对于流行病学研究的实现、STATA对复杂抽样设计样本量计算的实现 一、STATA软件基本操作 这部分网上教程有很多,也可以直接根据stata自带的help功能进行自学,在此只记录课程中提及的功能项。 1. 变量编辑 1.1 赋值:label type(按精度区分) 1) 整型:int(32), short(16), long(32) 2) 实型:flo...

weixin_45463530的博客 2433

Android的AMS相关知识

Android7.0的AMS相关信息   ActivityManager是一个和AMS相关联的类,它主要对运行中的Activity进行管理,这些管理工作并不是由ActivityManager来处理的,而是交由AMS来处理的。ActivityManager中的方法会通过ActivityManagerNative(AMN)的getDefault方法来得到ActivityManagerProxy(AMP),通过AMP就可以和AMN进行通信,而AMN是一个抽象类,它将功能交由它的子类AMS来处理,因此AMP就是AM

gxlgxjhll的博客 839

PT32F030与MT6826S SPI通讯实战:从硬件连接到数据交互全流程解析

本文详细解析了PT32F030与MT6826S通过SPI通讯的全流程,包括硬件连接、电路设计、SPI外设初始化配置以及数据交互协议实现。通过实战案例和代码示例,帮助开发者快速掌握PT32F030与MT6826S的SPI通讯技术,实现精准的角度和速度数据采集。

weixin_29189373的博客 421

UsualToolCMS-验证码绕过漏洞复现

本文以UsualToolCMS为靶场,复现了验证码绕过漏洞

小小小屿屿屿的博客 922

【android Framework 探究】浅谈AIDL和Binder

先聊聊binder,本文不是讲binder,android中的binder框架说实话,要从内核-》驱动-》native-》JNI -》Framework-》app层,牵扯的知识点从内核调度,虚拟内存,内存映射,数据结构,线程管理和设计模式,覆盖面太大了,要真正吃透binder需要大量的时间投入,甚至可能走很多弯路,我的建议 对应用开发者,需要熟练掌握AIDL编写方式,理解Binder作者在android框架进程通讯的设计原理,理解常接触的Stub,Proxy这些角色的概念和Parcel序列化传输。 当然.

lucky_tom的专栏 901

记录rk3588 在Linux 6.1内核版本声卡 bug。

rk3588 Audio bug

Yongheng6的博客 856

你真的了解AIDL吗? 附:AIDL 与 Binder 交互全解析

fill:#333;important;important;fill:none;color:#333;color:#333;important;fill:none;fill:#333;height:1em;Server 用户态Binder Driver 内核态Client 用户态replyBC_REPLY唤醒返回返回连接连接业务代码 iFoo.doSomethingIFoo.Proxy AIDL 生成binder_node node 指向 proc。

天行健,君子以自强不息。 230

抖音 webmssdk 签名算法解析:X-Dynosaur / X-Gnarly / X-Bogus 生成原理

它只依赖设备指纹/环境编码与随机数,与 query 内容无关,因此可以独立于 Dynosaur/Gnarly 生成。

猫敷雪 208

基于Qt C++开发一款国产化的福昕风格PDF编辑工具

QString text = QInputDialog::getText(this, "文本批注", "输入批注内容:", QLineEdit::Normal, "", &ok);QString savePath = QFileDialog::getSaveFileName(this, "保存加密PDF", "", "PDF文件 (*.pdf)");QAction* zoomInAct = new QAction(QIcon::fromTheme("zoom-in"), "放大", this);

寒寒豆豆软件公司的博客 239

安卓系统中IServiceConnection.aidl对应的是哪个类?

角色类/接口所在进程作用接口契约定义AMS可以回调的应用进程方法(通知连接状态)Binder 代理系统进程AMS持有的对象,用于回调应用进程具体实现应用进程实现接口,接收AMS的回调最终处理及你写的应用进程执行回调的具体逻辑(调用你的onServiceConnected方法)你想订阅一份杂志(绑定Service你填写了一份订阅单),订阅单上需要留下你的联系方式(一个对象)。杂志社(AMS)收到订阅单,之后每当有新杂志出版(Service已连接)或者杂志停刊了(Service断开。

hnlgzb的专栏 745

第 2 章:PassThrough 直通滤波

通过设置某个维度(如 x、y、z 或 rgb)的取值范围,仅保留该范围内的点,从而达到**点云裁剪(裁边)**或过滤异常值的目的。所有在该范围之外的点会被移除(可选是否保留);点云中包含背景、地面或传感器噪声,需要过滤;通过 z 轴过滤,只保留桌面上方的物体;多轴组合过滤(如同时过滤 x、y、z);可用于地面剔除、车载点云预处理等场景。不支持一次过滤多个字段,可多次调用;仅处理某一层或某一区域的点云数据。原始点云中包含地面、墙面、背景等;在区域裁剪、前景提取中广泛使用;设定一个轴(如z轴);

yumeiguo的博客 342

ContentProvider启动超时:从AMS源码剖析App连锁闪退的根源

本文深入剖析了Android系统中ContentProvider启动超时导致的App连锁闪退问题,通过AMS源码分析揭示了10秒超时机制(CONTENT_PROVIDER_PUBLISH_TIMEOUT)的工作原理。文章详细讲解了stable与unstable引用的关键区别,并提供了安全调用ContentProvider的实战指南和架构层面的预防方案,帮助开发者避免因Provider超时引发的进程连锁崩溃问题。

weixin_30770783的博客 747

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

Android AMS服务

继续来研究Android Framework层相关的一些东东,这里是以Android8.0版本的源码进行梳理的,关注的还是其核心流程,不是彻底分析,了解了核心流程是为了了期其大概的原理。 Android系统启动: 这里具体就不分析代码了,因为重点是来分析AMS相关的代码,这里以流程图的方式来展现一下整个的启动,毕境对于一个组件的启动得要建立在整个Android系统启动基础之上的,另外这块的具体源...

webor2006的博客 187

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

Android应用程序建立与AMS服务之间的通信过程

     Android应用程序建立与AMS服务之间的通信过程 引言   Android四大组件作为Android整个应用层框架的基石,其在Android中的地位是毋庸置疑的。而AMS(这里将ActivityManagerService简称AMS)做为四大组件启动,管理的核心服务却是运行在system_server进程中的,而我们的四大组件的启动和管理,更有甚者我们四大组件所在应用程序的创建都离不开和AMS服务之间的跨进程交互过程。那么这两个进程之间是怎么进行跨进程通信的呢,我想如果对于Android有一

IT先森 4201

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

深入理解Android AMS

在activity的启动过程中会调用Instrumentation的execStartActivity方法: 涉及代码: Instrumentation.java core\java\android\app\Instrumentation.java 这里调用到了ActivityManager的getService方法: ActivityTaskManager.java c...

qq601517284的博客 616

Android 添加自定义系统服务SystemService

Android 系统服务(System Services)是 Android 操作系统的核心组件,运行在系统层面,为应用程序提供底层硬件访问、系统资源管理以及跨应用功能支持。这些服务在后台持续运行,由系统进程(如 system_server)管理,通过模块化设计实现高效的系统控制。常见的AMS,PMS,WMS都属于系统服务。记录一下从app到jni创建系统服务和使用的过程。

拾荒 1213

AIDL简单demo彻底玩转AIDL调用

本文通过一个客户端demo和服务端demo共两个app,使用不超过100行代码,向你展示极简、傻瓜级AIDL使用教程,让你彻底玩转AIDL使用方法。附件包含客户端demo和服务端demo,演示客户端app如何调用服务端app的接口方法。服务端Demo:1:创建AIDL文件比如ICompute.aidl,在该文件创建供别人调用的接口2:build后,ICompute.aidl会自动生成ICompute.java类,新建Service远程服务,继承ICompute类里面的Stub类,实现ICompute.aid

神尐破 1131

【二】车载FrameWork添加系统服务

此时由于类加载的双亲委托机制,app在运行时实际使用的是framework中的EnjoyManager。app中的EnjoyManager仅仅只是为了编译成功编写的空壳。

qq_34178710的博客 1202

Android 10.0 系统服务之ActivityMnagerService-AMS启动流程-[Android取经之路]

[Android取经之路] 的源码都基于Android-Q(10.0) 进行分析 [Android取经之路] 系列文章: 《系统启动篇》 Android系统架构 Android是怎么启动的 Android 10.0系统启动之init进程 Android10.0系统启动之Zygote进程 Android 10.0 系统启动之SystemServer进程 Android 10.0 系统服务之ActivityMnagerService Android10.0系统启动之Launcher(桌面)启动流程 And

纸上得来终觉浅,绝知此事要躬行 2270
上一篇: 不靠 libaums自己如何在 Android 上用 USB 协议把 U 盘读出来
下一篇: Vsync 信号(VSYNC-app、VSYNC-appSf、VSYNC-sf)简析
Yeyu-Lab
博客等级 码龄11年 13粉丝 107原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值