莆田市网站建设_网站建设公司_内容更新_seo优化

Framework 架构概览

Android Framework 实际上分为两个主要部分：

┌─────────────────────────────────────────────┐ │ 应用层 (Application) │ │ Java/Kotlin 应用代码 │ └──────────────────┬──────────────────────────┘ │ ┌─────────────────────────────────────────────┐ │ Java Framework 层 │ │ (Application Framework - Java 部分) │ │ - 提供 Java API │ │ - 应用组件管理 │ │ - 系统服务的 Java 接口 │ └──────────────────┬──────────────────────────┘ │ JNI (Java Native Interface) ┌─────────────────────────────────────────────┐ │ Framework Native 层 │ │ (Application Framework - C++ 部分) │ │ - 核心系统服务实现 │ │ - 性能关键代码 │ │ - 硬件交互 │ └──────────────────┬──────────────────────────┘ │ ┌─────────────────────────────────────────────┐ │ HAL 层 │ └─────────────────────────────────────────────┘

一、Java Framework 层详解

1.1 定义和位置

Java Framework是用 Java 编写的框架层，位于：

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

1.2 核心作用

作用 1：提供应用开发 API

这是开发者直接使用的 API 层：

// 位置：frameworks/base/core/java/android/app/Activity.java public class Activity extends ContextThemeWrapper { // 生命周期方法 protected void onCreate(Bundle savedInstanceState) { } protected void onStart() { } protected void onResume() { } protected void onPause() { } protected void onStop() { } protected void onDestroy() { } // UI 相关 public void setContentView(int layoutResID) { getWindow().setContentView(layoutResID); } // Intent 相关 public void startActivity(Intent intent) { startActivityForResult(intent, -1); } }

提供的 API 包括：

• 四大组件：Activity、Service、BroadcastReceiver、ContentProvider
• UI 组件：View、ViewGroup、TextView、Button 等
• 系统服务访问：通过 Manager 类访问系统功能

作用 2：系统服务的 Java 实现

许多系统服务的主要逻辑用 Java 实现：

// 位置：frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java public class ActivityManagerService extends IActivityManager.Stub { // 启动 Activity @Override public final int startActivity(IApplicationThread caller, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) { return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, UserHandle.getCallingUserId()); } // 进程管理 final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName, boolean allowWhileBooting, boolean isolated, boolean keepIfLarge) { // 创建新进程 Process.start("android.app.ActivityThread", ...); return app; } // 内存管理 final void updateOomAdjLocked() { // 更新进程优先级 // 决定哪些进程可以被杀死 } }

作用 3：封装和抽象底层实现

Java Framework 隐藏了底层复杂性：

// 位置：frameworks/base/core/java/android/hardware/camera2/CameraManager.java public final class CameraManager { // 对外提供简单的 API public void openCamera(@NonNull String cameraId, @NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler) { // 内部处理复杂的逻辑 openCameraDeviceUserAsync(cameraId, callback, handler); } // 内部实现 private void openCameraDeviceUserAsync(String cameraId, final CameraDevice.StateCallback callback, Handler handler) { // 1. 权限检查 // 2. 参数验证 // 3. 调用 Native 层 ICameraService cameraService = CameraManagerGlobal.get().getCameraService(); // 通过 Binder 调用 Native 服务 cameraService.connectDevice(callbacks, cameraId, ...); } }

1.3 Java Framework 的主要模块

模块 1：Activity Manager

// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java public class ActivityManagerService extends IActivityManager.Stub { // 1. Activity 栈管理 ActivityStackSupervisor mStackSupervisor; // 2. 进程管理 final ArrayList<ProcessRecord> mProcessList = new ArrayList<>(); // 3. 服务管理 ActiveServices mServices; // 4. 广播管理 BroadcastQueue mFgBroadcastQueue; BroadcastQueue mBgBroadcastQueue; // 5. ContentProvider 管理 final ProviderMap mProviderMap; // 6. 权限管理 public int checkPermission(String permission, int pid, int uid) { // 检查权限 } // 7. ANR 检测 void appNotResponding(ProcessRecord app, ActivityRecord activity, ActivityRecord parent, boolean aboveSystem, final String annotation) { // 显示 ANR 对话框 } }

功能：

• 管理所有 Activity 的生命周期
• 管理应用进程的创建和销毁
• 管理 Service、BroadcastReceiver
• 内存管理和进程优先级调度
• ANR 检测和处理

模块 2：Package Manager

// frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java public class PackageManagerService extends IPackageManager.Stub { // 1. 已安装应用信息 final ArrayMap<String, PackageParser.Package> mPackages = new ArrayMap<>(); // 2. 安装 APK public void installPackage(String originPath, IPackageInstallObserver2 observer, int installFlags, String installerPackageName) { // 解析 APK PackageParser.Package pkg = parsePackage(originPath); // 验证签名 verifySignature(pkg); // 复制文件 copyApk(pkg); // dex 优化 performDexOpt(pkg); // 更新数据库 updatePackageDatabase(pkg); } // 3. 权限管理 public int checkPermission(String permName, String pkgName, int userId) { // 检查应用是否有该权限 } // 4. 组件查询 public ResolveInfo resolveIntent(Intent intent, String resolvedType, int flags) { // 查找能处理该 Intent 的组件 } }

功能：

• APK 安装、卸载、更新
• 解析 AndroidManifest.xml
• 管理应用权限
• 组件信息查询（Activity、Service 等）
• 应用签名验证

模块 3：Window Manager

// frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java public class WindowManagerService extends IWindowManager.Stub { // 1. 窗口列表 final WindowHashMap mWindowMap = new WindowHashMap(); // 2. 添加窗口 public int addWindow(Session session, IWindow client, int seq, LayoutParams attrs, int viewVisibility, int displayId, Rect outFrame, Rect outContentInsets, Rect outStableInsets, Rect outOutsets, DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel) { // 创建 WindowState WindowState win = new WindowState(this, session, client, token, parentWindow, appOp[0], seq, attrs, viewVisibility, session.mUid, session.mCanAddInternalSystemWindow); // 添加到窗口列表 mWindowMap.put(client.asBinder(), win); // 布局窗口 win.attach(); return WindowManagerGlobal.ADD_OKAY; } // 3. 触摸事件分发 public void dispatchPointerEvent(MotionEvent event) { // 找到目标窗口 WindowState targetWindow = findTargetWindow(event.getX(), event.getY()); // 分发事件 targetWindow.dispatchPointerEvent(event); } // 4. 窗口动画 void startAnimation(WindowState win, Animation anim) { // 执行窗口动画 } }

功能：

• 管理所有窗口的创建、销毁、显示
• 窗口层级管理（Z-order）
• 触摸事件分发
• 窗口动画和过渡效果
• 屏幕旋转处理

模块 4：Power Manager

// frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java public final class PowerManagerService extends SystemService { // 1. 电源状态 private int mWakefulness; // AWAKE, DREAMING, DOZING, ASLEEP // 2. WakeLock 管理 private final ArrayList<WakeLock> mWakeLocks = new ArrayList<>(); // 3. 获取 WakeLock public void acquireWakeLock(IBinder lock, int flags, String tag, String packageName, WorkSource ws, String historyTag) { // 创建 WakeLock WakeLock wakeLock = new WakeLock(lock, flags, tag, packageName, ws, historyTag); // 添加到列表 mWakeLocks.add(wakeLock); // 更新电源状态 updatePowerStateLocked(); } // 4. 休眠 public void goToSleep(long eventTime, int reason, int flags) { // 关闭屏幕 // 进入休眠状态 } // 5. 唤醒 public void wakeUp(long eventTime, String reason, String opPackageName) { // 打开屏幕 // 进入唤醒状态 } }

功能：

• 电源状态管理（唤醒、休眠）
• WakeLock 管理（防止休眠）
• 屏幕亮度控制
• 电池状态监控

模块 5：Notification Manager

// frameworks/base/services/core/java/com/android/server/notification/NotificationManagerService.java public class NotificationManagerService extends SystemService { // 1. 通知列表 final ArrayMap<String, NotificationRecord> mNotificationsByKey = new ArrayMap<>(); // 2. 发送通知 public void enqueueNotificationWithTag(String pkg, String opPkg, String tag, int id, Notification notification, int userId) { // 创建通知记录 NotificationRecord r = new NotificationRecord(getContext(), notification, channel); // 添加到列表 mNotificationsByKey.put(r.sbn.getKey(), r); // 显示通知 mHandler.post(new EnqueueNotificationRunnable(userId, r)); } // 3. 取消通知 public void cancelNotificationWithTag(String pkg, String tag, int id, int userId) { // 从列表移除 // 更新状态栏 } // 4. 通知渠道管理 (Android 8.0+) public void createNotificationChannel(String pkg, NotificationChannel channel) { // 创建通知渠道 } }

功能：

• 通知的发送、取消、更新
• 通知渠道管理
• 通知优先级和重要性
• 通知分组

二、Framework Native 层详解

2.1 定义和位置

Framework Native是用 C++ 编写的框架层，位于：

frameworks/native/ frameworks/av/ frameworks/base/core/jni/

2.2 核心作用

作用 1：实现性能关键的系统服务

对性能要求高的服务用 C++ 实现：

// 位置：frameworks/av/services/camera/libcameraservice/CameraService.cpp namespace android { class CameraService : public BinderService<CameraService>,public virtual ::android::hardware::BnCameraService { public: // 连接相机设备 virtual Status connectDevice( const sp<hardware::camera2::ICameraDeviceCallbacks>& callbacks, const String16& cameraId, const String16& clientPackageName, int clientUid, int clientPid, /*out*/ sp<hardware::camera2::ICameraDeviceUser>* device) override { // 1. 权限检查 Status ret = validateConnectLocked(cameraId, clientUid); // 2. 检查相机是否被占用 if (mBusy[cameraId]) { return STATUS_ERROR(ERROR_CAMERA_IN_USE); } // 3. 打开 HAL 设备 sp<hardware::camera::device::V3_2::ICameraDevice> halDevice; ret = mCameraProviderManager->openSession(cameraId, &halDevice); // 4. 创建客户端 sp<CameraDeviceClient> client = new CameraDeviceClient( this, halDevice, callbacks, cameraId, clientPackageName, clientUid, clientPid); *device = client; return Status::ok(); } private: // 相机提供者管理器 sp<CameraProviderManager> mCameraProviderManager; // 相机状态 std::map<String8, bool> mBusy; }; } // namespace android

为什么用 C++：

• 性能：相机数据处理需要高性能
• 内存控制：精确的内存管理
• 硬件交互：直接访问 HAL 层
• 实时性：低延迟要求

作用 2：多媒体处理

音视频处理都在 Native 层：

// 位置：frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp class MediaPlayerService : public BnMediaPlayerService { public: // 创建播放器 virtual sp<IMediaPlayer> create( const sp<IMediaPlayerClient>& client, int audioSessionId) { pid_t pid = IPCThreadState::self()->getCallingPid(); sp<Client> c = new Client(this, pid, connId, client, audioSessionId); return c; } class Client : public BnMediaPlayer { public: // 设置数据源 virtual status_t setDataSource(const sp<IStreamSource>& source) { // 创建播放器 player = MediaPlayerFactory::createPlayer(playerType, this, notify); // 设置数据源 player->setDataSource(source); return NO_ERROR; } // 开始播放 virtual status_t start() { return mPlayer->start(); } // 暂停 virtual status_t pause() { return mPlayer->pause(); } private: sp<MediaPlayerBase> mPlayer; // 实际的播放器实现 }; };

作用 3：图形系统

SurfaceFlinger 是核心的图形合成服务：

// 位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp class SurfaceFlinger : public BnSurfaceComposer { public: // 创建 Surface virtual sp<ISurfaceComposerClient> createConnection() { sp<ISurfaceComposerClient> client = new Client(this); return client; } // 合成所有图层 void onMessageReceived(int32_t what) { switch (what) { case MessageQueue::INVALIDATE: handleMessageInvalidate(); break; case MessageQueue::REFRESH: handleMessageRefresh(); break; } } void handleMessageRefresh() { // 1. 预合成 preComposition(); // 2. 合成所有图层 rebuildLayerStacks(); // 3. 后合成 postComposition(); // 4. 发送到显示设备 for (const auto& display : mDisplays) { display->present(); } } private: // 所有图层 SortedVector<sp<Layer>> mCurrentState.layersSortedByZ; // 显示设备 std::unordered_map<wp<IBinder>, sp<DisplayDevice>> mDisplays; };

SurfaceFlinger 功能：

• 合成所有应用的界面
• 管理图形缓冲区
• VSYNC 信号同步
• 硬件加速合成

作用 4：输入系统

触摸事件处理在 Native 层：

// 位置：frameworks/native/services/inputflinger/InputDispatcher.cpp class InputDispatcher : public InputDispatcherInterface { public: // 分发输入事件 void dispatchOnce() { // 1. 从队列获取事件 EventEntry* entry = mInboundQueue.dequeueAtHead(); // 2. 找到目标窗口 Vector<InputTarget> inputTargets; findFocusedWindowTargetsLocked(currentTime, entry, inputTargets); // 3. 分发事件 dispatchEventLocked(currentTime, entry, inputTargets);} private: // 查找目标窗口 int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry* entry, Vector<InputTarget>& inputTargets) { // 获取焦点窗口 sp<InputWindowHandle> focusedWindowHandle = getValueByKey(mFocusedWindowHandlesByDisplay, displayId); if (focusedWindowHandle != nullptr) { // 添加到目标列表 addWindowTargetLocked(focusedWindowHandle, inputTargets);} return INPUT_EVENT_INJECTION_SUCCEEDED; } };

2.3 Framework Native 的主要模块

模块 1：Binder 框架

// 位置：frameworks/native/libs/binder/IPCThreadState.cpp class IPCThreadState { public: // 发起 Binder 调用 status_t transact(int32_t handle, uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { // 1. 准备 Binder 数据 binder_transaction_data tr; tr.target.handle = handle; tr.code = code; tr.data_size = data.dataSize(); tr.data.ptr.buffer = data.data(); // 2. 写入 Binder 驱动 writeTransactionData(BC_TRANSACTION, flags, handle, code, data, nullptr); // 3. 等待回复 if ((flags & TF_ONE_WAY) == 0) { waitForResponse(reply); } return NO_ERROR; } // 处理 Binder 请求 status_t executeCommand(int32_t cmd) { switch (cmd) { case BR_TRANSACTION: { // 接收到 Binder 调用 binder_transaction_data tr; result = mIn.read(&tr, sizeof(tr)); // 调用目标对象 error = reinterpret_cast<BBinder*>(tr.cookie)->transact( tr.code, buffer, &reply, tr.flags); // 发送回复 sendReply(reply, 0); break; } } return result; } };

Binder 功能：

• 进程间通信
• 对象引用传递
• 死亡通知
• 线程池管理

模块 2：Audio Flinger

// 位置：frameworks/av/services/audioflinger/AudioFlinger.cpp class AudioFlinger : public BnAudioFlinger { public: // 创建音频轨道 virtual sp<IAudioTrack> createTrack( audio_stream_type_t streamType, uint32_t sampleRate, audio_format_t format, audio_channel_mask_t channelMask, size_t *frameCount, audio_output_flags_t *flags, const sp<IMemory>& sharedBuffer, audio_io_handle_t output, pid_t pid, pid_t tid, audio_session_t *sessionId, int clientUid, status_t *status) { // 1. 查找输出线程 sp<PlaybackThread> thread = checkPlaybackThread_l(output); // 2. 创建 Track sp<Track> track = thread->createTrack_l(client, streamType, sampleRate,format, channelMask, frameCount, sharedBuffer, sessionId, flags, pid, tid, clientUid, status); return track; } // 混音线程 class MixerThread : public PlaybackThread { virtual bool threadLoop() { // 1. 混合所有音轨 mAudioMixer->process(); // 2. 写入音频设备 mOutput->write(mSinkBuffer, mSinkBufferSize); return true; } }; private: // 所有播放线程 DefaultKeyedVector<audio_io_handle_t, sp<PlaybackThread>> mPlaybackThreads; };

AudioFlinger 功能：

• 音频混音
• 音频路由
• 音量控制
• 音效处理

模块 3：Surface 管理

// 位置：frameworks/native/libs/gui/Surface.cpp class Surface : public ANativeObjectBase<ANativeWindow, Surface, RefBase> { public: // 申请缓冲区 int dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) { // 从 BufferQueue 获取空闲缓冲区 status_t result = mGraphicBufferProducer->dequeueBuffer( &buf, &fence, reqWidth, reqHeight, reqFormat, reqUsage, &outBufferAge); *buffer = gbuf.get(); *fenceFd = fence->dup(); return OK; } // 提交缓冲区 int queueBuffer(android_native_buffer_t* buffer, int fenceFd) { // 将绘制完成的缓冲区提交到 BufferQueue status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output); return err; } private: sp<IGraphicBufferProducer> mGraphicBufferProducer; };

模块 4：Sensor 服务

// 位置：frameworks/native/services/sensorservice/SensorService.cpp class SensorService : public BinderService<SensorService>,public BnSensorServer { public: // 创建事件队列 virtual sp<ISensorEventConnection> createSensorEventConnection( const String8& packageName, int mode, const String16& opPackageName) { sp<SensorEventConnection> result = new SensorEventConnection( this, uid, packageName, mode == DATA_INJECTION, opPackageName); return result; } // 启用传感器 status_t enable(const sp<SensorEventConnection>& connection, int handle, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags, const String16& opPackageName) { // 1. 激活传感器 err = mSensors.activate(handle, true); // 2. 设置采样率 err = mSensors.batch(handle, samplingPeriodNs, maxBatchReportLatencyNs); return err; } // 传感器数据线程 void threadLoop() { // 1. 从 HAL 读取数据 ssize_t count = mSensors.poll(mSensorEventBuffer, numEventMax); // 2. 分发给所有连接 for (size_t i = 0; i < mActiveConnections.size(); i++) { mActiveConnections[i]->sendEvents(mSensorEventBuffer, count); } } };

三、JNI 实现 Java Framework 和 Native Framework 的交互

3.1 JNI (Java Native Interface)

Java 层通过 JNI 调用 Native 层：

// Java 层 // frameworks/base/core/java/android/view/Surface.java public class Surface implements Parcelable { // Native 方法声明 private static native long nativeCreateFromSurfaceTexture(SurfaceTexture surfaceTexture); private static native void nativeRelease(long nativeObject); private static native void nativeLockCanvas(long nativeObject, Canvas canvas, Rect dirty); // Java 方法调用 Native public Canvas lockCanvas(Rect inOutDirty) { synchronized (mLock) { Canvas c = new Canvas(); nativeLockCanvas(mNativeObject, c, inOutDirty); return c; } } }

// Native 层实现 // frameworks/base/core/jni/android_view_Surface.cpp static jlong nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz,jobject surfaceTextureObj) { // 从 Java 对象获取 Native 对象 sp<IGraphicBufferProducer> producer( SurfaceTexture_getProducer(env, surfaceTextureObj)); // 创建 Native Surface sp<Surface> surface(new Surface(producer, true)); // 增加引用计数 surface->incStrong(&sRefBaseOwner); // 返回 Native 指针 return reinterpret_cast<jlong>(surface.get()); } static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) { sp<Surface> surface(reinterpret_cast<Surface*>(nativeObject)); surface->decStrong(&sRefBaseOwner); } // JNI 方法注册 static const JNINativeMethod gSurfaceMethods[] = { {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)J", (void*)nativeCreateFromSurfaceTexture }, {"nativeRelease", "(J)V", (void*)nativeRelease }, }; int register_android_view_Surface(JNIEnv* env) { return RegisterMethodsOrDie(env, "android/view/Surface",gSurfaceMethods, NELEM(gSurfaceMethods)); }

3.2 典型交互流程

以播放视频为例：

应用层 (Java)↓ MediaPlayer.java (Java Framework) ↓ JNI android_media_MediaPlayer.cpp (JNI 层) ↓ MediaPlayer.cpp (Native Framework) ↓ Binder MediaPlayerService.cpp (Native 服务) ↓ NuPlayer.cpp (播放器实现) ↓ MediaCodec.cpp (编解码器) ↓ HIDL Codec2 HAL (HAL 层) ↓