admin/mkdocs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

测试

Browse Source
This commit is contained in:
renjianbo
2026-01-12 18:12:00 +08:00
parent 8a4717277d
commit bf169cc8b2
67 changed files with 9412 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
.obsidian/workspace.json vendored
View File

@@ -198,8 +198,36 @@
"bases:创建新数据库": false
}
},
"active": "42dcaa0fed1f392a",
"active": "5b497a77c6d68c73",
"lastOpenFiles": [
"docs/Obsidian笔记体系/Archive/资源-历史会议记录/2023年会议记录示例.md",
"docs/Obsidian笔记体系/Archive/领域-已废弃API研究/已废弃API-旧版Activity启动方式.md",
"docs/Obsidian笔记体系/Archive/项目-旧版ROM适配/项目A-旧版ROM适配-README.md",
"docs/Obsidian笔记体系/Archive/领域-已废弃API研究/README.md",
"docs/Obsidian笔记体系/Archive/项目-旧版ROM适配/README.md",
"docs/Obsidian笔记体系/Archive/资源-历史会议记录/README.md",
"docs/Obsidian笔记体系/Archive/README.md",
"docs/Obsidian笔记体系/Config/自定义脚本/自动生成日报.js",
"docs/Obsidian笔记体系/Config/自定义脚本/源码链接生成器.py",
"docs/Obsidian笔记体系/Config/插件列表与配置.md",
"docs/Obsidian笔记体系/MOCs/高频问题索引.md",
"docs/Obsidian笔记体系/MOCs/源码阅读地图.md",
"docs/Obsidian笔记体系/MOCs/Android Framework知识体系图.md",
"docs/Obsidian笔记体系/Daily/2024-06-02.md",
"docs/Obsidian笔记体系/Daily/2024-06-01.md",
"docs/Obsidian笔记体系/Daily/templates/每日模板.md",
"docs/Obsidian笔记体系/Resources/论文/移动操作系统前沿/移动系统安全研究.md",
"docs/Obsidian笔记体系/Resources/论文/移动操作系统前沿/移动边缘计算研究.md",
"docs/Obsidian笔记体系/Resources/论文/移动操作系统前沿/README.md",
"docs/Obsidian笔记体系/Resources/论文/Android系统优化论文/Android内存管理优化.md",
"docs/Obsidian笔记体系/Resources/论文/Android系统优化论文/Android启动优化研究.md",
"docs/Obsidian笔记体系/Resources/论文/Android系统优化论文/README.md",
"docs/Obsidian笔记体系/Resources/论文/README.md",
"docs/Obsidian笔记体系/Resources/技术文章/官方文档笔记/Android性能优化指南.md",
"docs/Obsidian笔记体系/Resources/技术文章/官方文档笔记/README.md",
"docs/Obsidian笔记体系/Resources/技术文章/内核相关文章/Binder内核机制分析.md",
"docs/Obsidian笔记体系/Resources/技术文章/内核相关文章/README.md",
"docs/Obsidian笔记体系/Resources/技术文章/优质博客归档（Gityuan等）/Gityuan_Activity启动流程.md",
"docs/Obsidian笔记体系/Resources/工具/脚本库/log_analyzer.py",
"docs/Obsidian笔记体系/Resources/工具/脚本库/performance_monitor.sh",
"docs/Obsidian笔记体系/Resources/工具/脚本库/test_startup_time.sh",
@@ -207,34 +235,6 @@
"docs/Obsidian笔记体系/脚本库",
"docs/Obsidian笔记体系/Resources/工具/脚本库/collect_logs.sh",
"docs/Obsidian笔记体系/Resources/工具/脚本库/install_apks.sh",
"docs/Obsidian笔记体系/Resources/工具/脚本库/README.md",
"docs/Obsidian笔记体系/Resources/工具/效率工具推荐/README.md",
"docs/cursor/cursor.md",
"个人笔记体系.md",
"docs/Obsidian/2026-01-05 个人文档管理.md",
"docs/Obsidian笔记体系/Areas/05-进程与线程通信/README.md",
"docs/Obsidian笔记体系/Areas/05-进程与线程通信/Handler机制源码解析.md",
"docs/Obsidian笔记体系/Areas/06-性能优化体系/内存优化（LeakCanary原理）.md",
"docs/Obsidian笔记体系/Areas/06-性能优化体系/启动优化方法论.md",
"docs/Obsidian笔记体系/Templates/源码解析模板.md",
"docs/Obsidian笔记体系/Templates/问题排查模板.md",
"docs/Obsidian笔记体系/Templates/技术方案设计模板.md",
"docs/Obsidian笔记体系/Templates/会议记录模板.md",
"docs/Obsidian笔记体系/Areas/05-进程与线程通信/Binder机制（内核到Java层）.md",
"docs/Obsidian笔记体系/Areas/04-资源与包管理/Resource资源加载机制.md",
"docs/Obsidian笔记体系/Areas/05-进程与线程通信/AIDL与HIDL使用与原理.md",
"docs/Obsidian笔记体系/Areas/05-进程与线程通信/跨进程同步与锁优化.md",
"docs/Obsidian笔记体系/Areas/06-性能优化体系/功耗优化工具链.md",
"docs/Obsidian笔记体系/Areas/04-资源与包管理/PackageManagerService.md",
"文档完善提示词模板.md",
"docs/Obsidian笔记体系/Areas/04-资源与包管理/动态加载与热修复原理.md",
"Resource资源加载机制.md",
"README.md",
"PackageManagerService.md",
"docs/Obsidian笔记体系/Areas/03-Window系统/README.md",
"docs/Obsidian笔记体系/Areas/01-系统启动流程/Bootloader到Init.md.bak",
"docs/Obsidian笔记体系/Config/自定义脚本/源码链接生成器.py",
"docs/Obsidian笔记体系/Config/自定义脚本/自动生成日报.js",
"docs/Obsidian笔记体系/Config/主题与样式.css"
"docs/Obsidian笔记体系/Areas/01-系统启动流程/Bootloader到Init.md.bak"
]
}

108
docs/Obsidian笔记体系/Archive/README.md Normal file
View File

@@ -0,0 +1,108 @@
# Archive 归档目录
## 概述
本目录用于归档不再活跃使用的笔记和资源，包括历史会议记录、已完成的项目、已废弃的技术研究等。
## 归档原则
### 1. 归档标准
- **历史会议记录**: 超过1年的会议记录
- **已完成项目**: 项目已完成且不再维护
- **废弃技术**: 技术已过时或被替代
- **临时笔记**: 临时性的、不再需要的笔记
### 2. 归档时机
- 定期归档（每月/每季度）
- 项目完成后归档
- 技术更新后归档旧内容
### 3. 归档方式
- 保持原有目录结构
- 添加归档日期标记
- 保留重要信息摘要
## 目录结构
### 资源-历史会议记录
归档历史会议记录和分享内容。
**归档内容**:
- 超过1年的会议记录
- 历史技术分享
- 不再相关的讨论记录
**相关链接**: [[Resources/会议与分享]]
### 项目-旧版ROM适配
归档已完成或废弃的项目。
**归档内容**:
- 已完成的项目文档
- 废弃的项目方案
- 旧版本适配记录
**相关链接**: [[Projects]]
### 领域-已废弃API研究
归档已废弃或过时的技术研究。
**归档内容**:
- 已废弃的API研究
- 过时的技术方案
- 不再使用的技术文档
**相关链接**: [[Areas]]
## 归档管理
### 归档流程
1. **评估**: 评估内容是否需要归档
2. **整理**: 整理内容，添加归档标记
3. **移动**: 移动到对应的归档目录
4. **更新**: 更新相关链接和索引
### 归档标记
在归档的文件中添加标记：
```markdown
---
归档日期: YYYY-MM-DD
归档原因: 项目完成/技术过时/不再需要
---
```
### 检索方法
- 使用Obsidian搜索功能
- 查看归档目录的README
- 使用标签筛选
## 恢复机制
### 恢复条件
- 需要参考历史内容
- 项目重新启动
- 技术重新使用
### 恢复流程
1. 在Archive中查找内容
2. 评估是否需要恢复
3. 移动到对应活动目录
4. 更新相关链接
## 清理建议
### 定期清理
- 每年清理一次
- 删除完全无用的内容
- 压缩长期归档内容
### 清理标准
- 超过5年且无参考价值
- 内容完全过时
- 有更好的替代内容
## 相关链接
- [[Resources/会议与分享]]
- [[Projects]]
- [[Areas]]

41
docs/Obsidian笔记体系/Archive/资源-历史会议记录/2023年会议记录示例.md Normal file
View File

@@ -0,0 +1,41 @@
# 2023年会议记录示例
## 基本信息
- **会议主题**: 项目启动会议
- **时间**: 2023-01-15 10:00 - 11:00
- **地点**: 线上
- **主持人**:
- **记录人**:
- **归档日期**: 2024-01-15
- **归档原因**: 超过1年，项目已完成
## 会议内容
### 议题1: 项目启动
- 讨论项目目标和范围
- 确定项目时间表
- 分配任务
### 议题2: 技术方案
- 讨论技术选型
- 确定实施方案
- 评估风险
## 关键决策
1. **决策1**: 确定项目启动时间
2. **决策2**: 确定技术方案
## 行动项
- [x] 行动项1 - 已完成
- [x] 行动项2 - 已完成
## 归档说明
本会议记录已归档，项目已完成。如需参考，请查看项目文档。
## 相关链接
- [[项目-旧版ROM适配/项目A-旧版ROM适配-README]]
- [[README]]

66
docs/Obsidian笔记体系/Archive/资源-历史会议记录/README.md Normal file
View File

@@ -0,0 +1,66 @@
# 资源-历史会议记录
## 概述
本目录用于归档历史会议记录和技术分享内容，包括超过1年的会议记录、历史技术分享等。
## 归档内容
### 会议记录
- 超过1年的会议记录
- 不再相关的讨论记录
- 历史项目会议
### 技术分享
- 历史技术分享内容
- 过时的技术方案分享
- 不再使用的技术文档
## 归档标准
### 归档条件
- **时间**: 超过1年的内容
- **相关性**: 不再与当前工作相关
- **价值**: 仍有参考价值但不再活跃使用
### 归档方式
- 保持原有目录结构
- 添加归档日期
- 保留关键信息
## 目录结构
```
资源-历史会议记录/
├── README.md
├── 2023年会议记录/
│ ├── 2023-01-XX-项目启动会议.md
│ └── ...
├── 2022年会议记录/
│ └── ...
└── 历史技术分享/
└── ...
```
## 检索方法
### 按时间检索
- 查看对应年份的目录
- 使用日期筛选
### 按主题检索
- 使用Obsidian搜索
- 查看文件标题
- 使用标签筛选
## 恢复机制
如果需要参考历史会议记录：
1. 在Archive中查找
2. 查看相关内容
3. 如需恢复，移动到[[Resources/会议与分享]]
## 相关链接
- [[Resources/会议与分享]]
- [[README]]

83
docs/Obsidian笔记体系/Archive/项目-旧版ROM适配/README.md Normal file
View File

@@ -0,0 +1,83 @@
# 项目-旧版ROM适配
## 概述
本目录用于归档已完成或废弃的项目，包括旧版ROM适配项目、已完成的项目文档等。
## 归档内容
### 已完成项目
- 项目已完成且不再维护
- 项目文档和总结
- 项目经验教训
### 废弃项目
- 项目已取消或废弃
- 废弃的技术方案
- 不再使用的项目文档
## 归档标准
### 归档条件
- **状态**: 项目已完成或废弃
- **维护**: 不再需要维护
- **参考**: 仍有参考价值
### 归档方式
- 保持项目完整结构
- 添加项目状态说明
- 保留关键文档
## 目录结构
```
项目-旧版ROM适配/
├── README.md
├── 项目A-旧版ROM适配/
│ ├── README.md
│ ├── 需求文档.md
│ ├── 技术方案.md
│ └── 项目总结.md
└── 项目B-XX项目/
└── ...
```
## 项目信息
### 项目A-旧版ROM适配
- **项目状态**: 已完成
- **完成时间**: 2023-12-31
- **归档时间**: 2024-01-15
- **归档原因**: 项目已完成，不再维护
**项目概述**:
- 适配旧版ROM系统
- 完成系统定制和优化
- 项目已交付
**关键文档**:
- 需求文档
- 技术方案
- 项目总结
## 检索方法
### 按项目检索
- 查看项目目录
- 阅读项目README
### 按技术检索
- 使用技术关键词搜索
- 查看技术方案文档
## 恢复机制
如果项目需要重新启动：
1. 在Archive中查找项目
2. 评估项目内容
3. 如需恢复，移动到[[Projects]]
## 相关链接
- [[Projects]]
- [[README]]

66
docs/Obsidian笔记体系/Archive/项目-旧版ROM适配/项目A-旧版ROM适配-README.md Normal file
View File

@@ -0,0 +1,66 @@
# 项目A-旧版ROM适配
## 项目信息
- **项目名称**: 旧版ROM适配项目
- **项目状态**: 已完成
- **完成时间**: 2023-12-31
- **归档时间**: 2024-01-15
- **归档原因**: 项目已完成，不再维护
## 项目概述
本项目旨在适配旧版ROM系统，完成系统定制和优化，满足特定业务需求。
## 项目目标
1. **系统适配**: 适配旧版ROM系统
2. **功能定制**: 定制系统功能
3. **性能优化**: 优化系统性能
4. **稳定性提升**: 提升系统稳定性
## 项目成果
### 完成内容
- ✅ 系统适配完成
- ✅ 功能定制完成
- ✅ 性能优化完成
- ✅ 稳定性提升
### 关键指标
- **适配完成度**: 100%
- **性能提升**: 20%
- **稳定性**: 99.9%
## 项目文档
### 需求文档
- 项目需求分析
- 功能需求定义
- 非功能需求
### 技术方案
- 系统架构设计
- 技术选型
- 实施方案
### 项目总结
- 项目完成情况
- 经验教训
- 后续建议
## 关键经验
### 成功经验
1. 充分的需求分析
2. 合理的技术方案
3. 严格的测试流程
### 经验教训
1. 旧版系统兼容性处理
2. 性能优化策略
3. 稳定性保障
## 相关链接
- [[README]]
- [[Projects/项目A-系统定制化]]

101
docs/Obsidian笔记体系/Archive/领域-已废弃API研究/README.md Normal file
View File

@@ -0,0 +1,101 @@
# 领域-已废弃API研究
## 概述
本目录用于归档已废弃或过时的技术研究，包括已废弃的API研究、过时的技术方案等。
## 归档内容
### 已废弃API
- Android已废弃的API研究
- 过时的API使用文档
- 废弃API的替代方案
### 过时技术
- 不再使用的技术方案
- 过时的技术文档
- 被新技术替代的内容
## 归档标准
### 归档条件
- **状态**: API已废弃或技术已过时
- **替代**: 已有新的替代方案
- **参考**: 仍有历史参考价值
### 归档方式
- 标记废弃原因
- 记录替代方案
- 保留历史信息
## 目录结构
```
领域-已废弃API研究/
├── README.md
├── 已废弃API/
│ ├── API1-废弃原因和替代.md
│ └── ...
├── 过时技术/
│ ├── 技术1-过时原因和替代.md
│ └── ...
└── 历史研究/
└── ...
```
## 归档内容示例
### 已废弃API示例
#### API1: 旧版Activity启动方式
- **废弃版本**: Android 10
- **废弃原因**: 新的启动方式更安全高效
- **替代方案**: 使用新的Activity启动API
- **归档日期**: 2024-01-15
#### API2: 旧版权限管理
- **废弃版本**: Android 6.0
- **废弃原因**: 运行时权限更安全
- **替代方案**: 使用运行时权限API
- **归档日期**: 2024-01-15
### 过时技术示例
#### 技术1: 旧版Binder使用方式
- **过时原因**: 新的AIDL方式更简单
- **替代方案**: 使用AIDL
- **归档日期**: 2024-01-15
## 检索方法
### 按API检索
- 查看已废弃API目录
- 使用API名称搜索
### 按技术检索
- 查看过时技术目录
- 使用技术关键词搜索
## 参考价值
### 历史参考
- 了解技术演进历史
- 理解废弃原因
- 学习替代方案
### 兼容性参考
- 旧版本兼容性处理
- 迁移方案参考
- 问题排查参考
## 恢复机制
如果技术重新使用或需要参考：
1. 在Archive中查找
2. 查看废弃原因和替代方案
3. 评估是否需要恢复
## 相关链接
- [[Areas]]
- [[README]]

96
docs/Obsidian笔记体系/Archive/领域-已废弃API研究/已废弃API-旧版Activity启动方式.md Normal file
View File

@@ -0,0 +1,96 @@
# 已废弃API - 旧版Activity启动方式
## API信息
- **API名称**: 旧版Activity启动方式
- **废弃版本**: Android 10 (API 29)
- **废弃时间**: 2019年
- **归档日期**: 2024-01-15
- **归档原因**: API已废弃，有新的替代方案
## 废弃原因
### 主要原因
1. **安全性**: 旧版启动方式存在安全风险
2. **性能**: 新的启动方式性能更好
3. **一致性**: 统一启动方式，便于管理
### 具体问题
- 启动方式不够安全
- 性能不如新方式
- 管理不够统一
## 旧版使用方式
### 代码示例
```java
// 旧版启动方式（已废弃）
Intent intent = new Intent();
intent.setAction(Intent.ACTION_VIEW);
intent.setData(Uri.parse("content://..."));
startActivity(intent);
```
### 问题
- 安全性不足
- 性能较差
- 管理复杂
## 替代方案
### 新版使用方式
```java
// 新版启动方式（推荐）
Intent intent = new Intent(context, TargetActivity.class);
intent.putExtra("key", "value");
startActivity(intent);
```
### 优势
- 更安全
- 性能更好
- 管理更统一
## 迁移指南
### 迁移步骤
1. 识别使用旧版API的代码
2. 替换为新版API
3. 测试验证
4. 更新文档
### 注意事项
- 保持功能一致性
- 注意权限变化
- 充分测试
## 兼容性处理
### 旧版本兼容
- 如果必须支持旧版本，需要兼容处理
- 使用版本判断
- 提供降级方案
### 代码示例
```java
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
// 使用新版API
startActivity(newIntent);
} else {
// 使用旧版API（兼容）
startActivity(oldIntent);
}
```
## 参考资源
### 官方文档
- [Android官方迁移指南](https://developer.android.com/guide)
- [Activity启动最佳实践](https://developer.android.com/topic/performance/vitals/launch-time)
### 相关链接
- [[02-Activity管理/Activity启动流程（跨进程）]]
- [[README]]
## 归档说明
本API已废弃，建议使用新的启动方式。本文档保留作为历史参考。

102
docs/Obsidian笔记体系/Areas/07-系统安全/README.md
View File

@@ -1 +1,103 @@
# 07-系统安全
## 概述
系统安全是Android Framework开发中的重要领域，涉及权限管理、数据加密、安全策略、漏洞防护等方面。本目录系统性地整理了Android系统安全相关的知识。
## 目录结构
### 1. 权限管理框架
- Android权限系统架构
- 权限申请与授予机制
- 运行时权限管理
- 权限最佳实践
### 2. SELinux策略编写
- SELinux基础概念
- 策略文件编写
- 策略调试方法
- 常见策略配置
### 3. 密钥存储与加密
- Android密钥存储系统
- 数据加密机制
- 密钥管理最佳实践
- 加密算法选择
### 4. 漏洞案例库
- 常见安全漏洞
- 漏洞分析案例
- 防护措施
- 安全编码规范
## 安全原则
### 1. 最小权限原则
- 只授予必要的权限
- 及时撤销不需要的权限
- 避免权限滥用
### 2. 纵深防御
- 多层安全防护
- 不依赖单一安全机制
- 建立安全防护体系
### 3. 安全设计
- 从设计阶段考虑安全
- 安全与功能并重
- 定期安全审计
### 4. 持续监控
- 安全事件监控
- 异常行为检测
- 及时响应和处理
## 安全机制
### 1. 权限管理
- **应用权限**: 应用级别的权限控制
- **系统权限**: 系统级别的权限控制
- **签名权限**: 基于签名的权限控制
### 2. SELinux
- **强制访问控制**: 基于SELinux的强制访问控制
- **策略配置**: SELinux策略的编写和配置
- **调试方法**: SELinux策略的调试
### 3. 加密机制
- **数据加密**: 敏感数据加密存储
- **密钥管理**: 密钥的安全存储和管理
- **加密算法**: 选择合适的加密算法
### 4. 安全启动
- **启动验证**: 系统启动时的安全验证
- **可信执行环境**: TEE的使用
- **安全引导**: 安全引导流程
## 安全最佳实践
### 1. 权限管理
- 最小权限原则
- 运行时权限检查
- 权限使用监控
### 2. 数据保护
- 敏感数据加密
- 安全存储机制
- 数据传输加密
### 3. 代码安全
- 安全编码规范
- 代码审查
- 漏洞扫描
### 4. 系统加固
- SELinux策略配置
- 系统服务安全
- 安全配置检查
## 相关链接
- [[04-资源与包管理]]
- [[08-定制化开发]]
- [[MOCs/Android Framework知识体系图]]

381
docs/Obsidian笔记体系/Areas/07-系统安全/SELinux策略编写.md
View File

@@ -1 +1,382 @@
# SELinux策略编写
## 概述
SELinux (Security-Enhanced Linux) 是Android系统的重要安全机制，通过强制访问控制（MAC）提供额外的安全保护层。
## SELinux基础
### 1. SELinux概念
#### 什么是SELinux
- Linux内核的安全模块
- 提供强制访问控制（MAC）
- 补充传统的自主访问控制（DAC）
#### SELinux模式
- **Enforcing**: 强制模式，拒绝违反策略的操作
- **Permissive**: 宽容模式，记录但不拒绝
- **Disabled**: 禁用模式，不执行SELinux
#### 查看SELinux状态
```bash
# 查看SELinux状态
adb shell getenforce
# 设置SELinux模式（需要root）
adb shell setenforce 0 # Permissive
adb shell setenforce 1 # Enforcing
```
### 2. SELinux策略
#### 策略类型
- **TE (Type Enforcement)**: 类型强制，主要策略类型
- **MLS (Multi-Level Security)**: 多级安全
- **RBAC (Role-Based Access Control)**: 基于角色的访问控制
#### 策略文件位置
```
/system/etc/selinux/
├── plat_sepolicy.cil # 平台策略
├── system_sepolicy.cil # 系统策略
└── vendor_sepolicy.cil # 厂商策略
```
## SELinux策略语法
### 1. 类型定义
#### 定义类型
```sepolicy
# 定义进程类型
type system_server, domain;
# 定义文件类型
type system_file, file_type;
# 定义属性
typeattribute system_server coredomain;
```
#### 类型属性
```sepolicy
# 定义属性
typeattribute coredomain;
# 将类型添加到属性
typeattribute system_server coredomain;
```
### 2. 访问向量规则
#### allow规则
```sepolicy
# 允许system_server读取system_file
allow system_server system_file:file read;
# 允许system_server执行system_file
allow system_server system_file:file execute;
```
#### 规则语法
```
allow source_type target_type:class permission_set;
```
#### 常用权限
- **file**: read, write, execute, create, delete, getattr, setattr
- **dir**: read, write, search, add_name, remove_name
- **socket**: create, bind, listen, accept, connect, send, receive
- **process**: fork, transition, signal, ptrace
### 3. 类型转换规则
#### type_transition
```sepolicy
# 文件类型转换
type_transition system_server system_file:process system_server;
# 目录类型转换
type_transition system_server system_file:dir system_data_file;
```
#### 规则语法
```
type_transition source_type target_type:class default_type;
```
## 常见策略配置
### 1. 系统服务策略
#### SystemServer策略
```sepolicy
# SystemServer类型定义
type system_server, domain;
typeattribute system_server coredomain;
# 允许SystemServer执行
allow system_server system_file:file execute;
# 允许SystemServer读取系统属性
allow system_server system_prop:property_service get;
# 允许SystemServer创建socket
allow system_server system_server:socket create_socket_perms;
```
#### 服务策略示例
```sepolicy
# ActivityManagerService策略
type activity_service, service_manager_type;
# 允许system_server注册服务
allow system_server activity_service:service_manager add;
# 允许应用查询服务
allow untrusted_app activity_service:service_manager find;
```
### 2. 应用策略
#### 应用域定义
```seplatform
# 应用域
type untrusted_app, domain;
typeattribute untrusted_app appdomain;
# 应用数据目录
type app_data_file, file_type, data_file_type;
```
#### 应用权限策略
```sepolicy
# 允许应用读取自己的数据
allow untrusted_app app_data_file:file rw_file_perms;
# 禁止应用访问系统文件
neverallow untrusted_app system_file:file { read write execute };
```
### 3. 文件系统策略
#### 文件类型定义
```sepolicy
# 系统文件
type system_file, file_type;
# 数据文件
type system_data_file, file_type, data_file_type;
# 缓存文件
type cache_file, file_type, cache_file_type;
```
#### 文件访问规则
```sepolicy
# 允许system_server读写系统数据
allow system_server system_data_file:file rw_file_perms;
# 允许system_server读取系统文件
allow system_server system_file:file read;
```
## 策略调试
### 1. 查看SELinux日志
#### dmesg日志
```bash
# 查看SELinux拒绝日志
adb shell dmesg | grep avc
# 实时查看
adb shell dmesg -w | grep avc
```
#### logcat日志
```bash
# 查看SELinux日志
adb logcat | grep avc
# 查看特定标签
adb logcat -s avc
```
### 2. 分析拒绝日志
#### 日志格式
```
avc: denied { read } for pid=1234 comm="system_server"
name="file" dev="mmcblk0p1" ino=12345
scontext=u:r:system_server:s0
tcontext=u:object_r:system_file:s0
tclass=file permissive=0
```
#### 日志解析
- **denied**: 拒绝的操作
- **scontext**: 源上下文（进程）
- **tcontext**: 目标上下文（对象）
- **tclass**: 目标类别
- **permissive**: 是否在宽容模式
### 3. 生成策略规则
#### audit2allow工具
```bash
# 从日志生成策略规则
adb shell dmesg | grep avc | audit2allow
# 生成策略文件
adb shell dmesg | grep avc | audit2allow -M mypolicy
```
#### 手动编写规则
根据拒绝日志手动编写allow规则：
```sepolicy
# 根据日志生成规则
# scontext=u:r:system_server:s0
# tcontext=u:object_r:system_file:s0
# tclass=file
# denied { read }
allow system_server system_file:file read;
```
## 策略编写实践
### 1. 最小权限原则
#### 只授予必要权限
```sepolicy
# ❌ 错误：授予过多权限
allow system_server system_file:file rw_file_perms;
# ✅ 正确：只授予必要权限
allow system_server system_file:file read;
```
### 2. 使用属性
#### 属性组织策略
```sepolicy
# 定义属性
typeattribute coredomain;
typeattribute system_server coredomain;
# 使用属性简化规则
allow coredomain system_file:file read;
```
### 3. 策略模块化
#### 模块化组织
```sepolicy
# system_server.te
type system_server, domain;
typeattribute system_server coredomain;
# system_server_file.te
type system_server_data_file, file_type;
allow system_server system_server_data_file:file rw_file_perms;
```
## 常见问题
### 1. 权限被拒绝
#### 问题现象
- 应用无法访问文件
- 服务无法启动
- 操作被SELinux拒绝
#### 解决方法
1. 查看SELinux日志
2. 分析拒绝原因
3. 编写或修改策略规则
4. 编译和加载策略
### 2. 策略冲突
#### 问题现象
- 策略规则冲突
- 编译失败
- 策略加载失败
#### 解决方法
1. 检查策略规则
2. 解决规则冲突
3. 重新编译策略
### 3. 性能影响
#### 问题现象
- SELinux影响性能
- 系统响应变慢
#### 解决方法
1. 优化策略规则
2. 使用属性减少规则数量
3. 避免过度限制
## 策略编译和加载
### 1. 编译策略
#### 使用sepolicy工具
```bash
# 编译策略
sepolicy compile -o sepolicy system_sepolicy.cil
# 验证策略
sepolicy validate system_sepolicy.cil
```
### 2. 加载策略
#### 加载到设备
```bash
# 推送策略文件
adb push sepolicy /data/local/tmp/
# 加载策略（需要root）
adb shell load_policy /data/local/tmp/sepolicy
```
### 3. 测试策略
#### 测试方法
1. 设置SELinux为Permissive模式
2. 测试功能
3. 查看日志
4. 修复策略
5. 设置为Enforcing模式
6. 再次测试
## 最佳实践
### 1. 策略编写
- 遵循最小权限原则
- 使用属性组织策略
- 模块化策略文件
- 充分测试策略
### 2. 策略调试
- 使用Permissive模式调试
- 仔细分析拒绝日志
- 逐步添加规则
- 验证策略效果
### 3. 策略维护
- 定期审查策略
- 更新策略规则
- 文档化策略变更
- 版本控制策略文件
## 相关链接
- [[README]]
- [[权限管理框架]]
- [[漏洞案例库]]

349
docs/Obsidian笔记体系/Areas/07-系统安全/密钥存储与加密.md
View File

@@ -1 +1,350 @@
# 密钥存储与加密
## 概述
Android系统提供了多种密钥存储和加密机制，用于保护敏感数据和应用密钥。本文档介绍Android密钥存储系统和数据加密方法。
## Android密钥存储系统
### 1. KeyStore系统
#### KeyStore概述
- Android提供的密钥存储系统
- 支持硬件和软件密钥存储
- 保护密钥不被应用直接访问
#### KeyStore类型
- **AndroidKeyStore**: Android密钥存储提供者
- **KeyChain**: 系统级密钥链
- **硬件安全模块**: 硬件支持的密钥存储
### 2. AndroidKeyStore使用
#### 生成密钥
```java
// 生成密钥对
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(
KeyProperties.KEY_ALGORITHM_RSA, "AndroidKeyStore");
KeyGenParameterSpec spec = new KeyGenParameterSpec.Builder(
"my_key_alias",
KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_RSA_PKCS1)
.build();
keyPairGenerator.initialize(spec);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
```
#### 存储密钥
```java
// 密钥自动存储在AndroidKeyStore中
// 不需要手动存储，系统自动管理
```
#### 获取密钥
```java
// 从KeyStore获取密钥
KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
keyStore.load(null);
PrivateKey privateKey = (PrivateKey) keyStore.getKey("my_key_alias", null);
PublicKey publicKey = keyStore.getCertificate("my_key_alias").getPublicKey();
```
### 3. 密钥属性
#### 密钥用途
- **PURPOSE_ENCRYPT**: 加密
- **PURPOSE_DECRYPT**: 解密
- **PURPOSE_SIGN**: 签名
- **PURPOSE_VERIFY**: 验证
#### 加密填充
- **ENCRYPTION_PADDING_RSA_PKCS1**: PKCS1填充
- **ENCRYPTION_PADDING_RSA_OAEP**: OAEP填充
- **ENCRYPTION_PADDING_NONE**: 无填充
#### 密钥保护
- **BLOCK_MODE_ECB**: ECB模式
- **BLOCK_MODE_CBC**: CBC模式
- **BLOCK_MODE_GCM**: GCM模式
## 数据加密
### 1. 对称加密
#### AES加密
```java
// 生成AES密钥
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(256);
SecretKey secretKey = keyGenerator.generateKey();
// 加密数据
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] encryptedData = cipher.doFinal(data.getBytes());
// 获取IV
byte[] iv = cipher.getIV();
```
#### 解密数据
```java
// 解密数据
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
GCMParameterSpec spec = new GCMParameterSpec(128, iv);
cipher.init(Cipher.DECRYPT_MODE, secretKey, spec);
byte[] decryptedData = cipher.doFinal(encryptedData);
```
### 2. 非对称加密
#### RSA加密
```java
// 使用公钥加密
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encryptedData = cipher.doFinal(data.getBytes());
```
#### RSA解密
```java
// 使用私钥解密
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] decryptedData = cipher.doFinal(encryptedData);
```
### 3. 哈希和签名
#### 数据哈希
```java
// SHA-256哈希
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hash = digest.digest(data.getBytes());
```
#### 数字签名
```java
// 使用私钥签名
Signature signature = Signature.getInstance("SHA256withRSA");
signature.initSign(privateKey);
signature.update(data.getBytes());
byte[] signatureBytes = signature.sign();
```
#### 验证签名
```java
// 使用公钥验证
Signature signature = Signature.getInstance("SHA256withRSA");
signature.initVerify(publicKey);
signature.update(data.getBytes());
boolean isValid = signature.verify(signatureBytes);
```
## 密钥管理
### 1. 密钥生成
#### 安全随机数
```java
// 使用SecureRandom生成随机数
SecureRandom random = new SecureRandom();
byte[] randomBytes = new byte[32];
random.nextBytes(randomBytes);
```
#### 密钥派生
```java
// 使用PBKDF2派生密钥
SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 65536, 256);
SecretKey key = factory.generateSecret(spec);
```
### 2. 密钥存储
#### SharedPreferences加密存储
```java
// 使用EncryptedSharedPreferences
String masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC);
SharedPreferences sharedPreferences = EncryptedSharedPreferences.create(
"prefs",
masterKeyAlias,
context,
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
);
```
#### 文件加密存储
```java
// 加密文件
File encryptedFile = new File(context.getFilesDir(), "encrypted_data");
FileOutputStream fos = new FileOutputStream(encryptedFile);
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
CipherOutputStream cos = new CipherOutputStream(fos, cipher);
cos.write(data.getBytes());
cos.close();
```
### 3. 密钥轮换
#### 密钥版本管理
```java
// 密钥版本管理
public class KeyManager {
private static final String KEY_ALIAS_PREFIX = "key_v";
private static final int CURRENT_KEY_VERSION = 2;
public String getCurrentKeyAlias() {
return KEY_ALIAS_PREFIX + CURRENT_KEY_VERSION;
}
public void rotateKey() {
// 生成新密钥
generateKey(CURRENT_KEY_VERSION + 1);
// 迁移数据
migrateData(CURRENT_KEY_VERSION, CURRENT_KEY_VERSION + 1);
}
}
```
## 硬件安全模块
### 1. 硬件支持的密钥存储
#### 检查硬件支持
```java
// 检查硬件支持的密钥算法
KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
keyStore.load(null);
Set<String> supportedAlgorithms = keyStore.getProvider()
.getServices().stream()
.filter(service -> service.getType().equals("Cipher"))
.map(Provider.Service::getAlgorithm)
.collect(Collectors.toSet());
```
#### 使用硬件密钥
```java
// 生成硬件支持的密钥
KeyGenParameterSpec spec = new KeyGenParameterSpec.Builder(
"hardware_key",
KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
.setIsStrongBoxBacked(true) // 使用StrongBox
.build();
```
### 2. StrongBox
#### StrongBox概述
- 硬件安全模块
- 提供更强的安全保护
- 支持密钥存储和加密操作
#### StrongBox使用
```java
// 检查StrongBox支持
KeyInfo keyInfo = (KeyInfo) keyFactory.getKeySpec(key, KeyInfo.class);
boolean isStrongBoxBacked = keyInfo.isInsideSecureHardware();
```
## 加密算法选择
### 1. 对称加密算法
#### AES
- **推荐**: AES-256-GCM
- **用途**: 数据加密
- **优势**: 性能好，安全性高
#### ChaCha20
- **推荐**: ChaCha20-Poly1305
- **用途**: 数据加密
- **优势**: 性能好，适合移动设备
### 2. 非对称加密算法
#### RSA
- **推荐**: RSA-2048或RSA-4096
- **用途**: 密钥交换、数字签名
- **优势**: 广泛支持
#### ECC
- **推荐**: ECDSA-P256
- **用途**: 数字签名
- **优势**: 密钥短，性能好
### 3. 哈希算法
#### SHA-256
- **推荐**: SHA-256
- **用途**: 数据完整性验证
- **优势**: 安全性高，性能好
## 安全最佳实践
### 1. 密钥管理
- 使用AndroidKeyStore存储密钥
- 定期轮换密钥
- 使用硬件安全模块（如果可用）
- 避免硬编码密钥
### 2. 数据加密
- 敏感数据必须加密
- 使用强加密算法
- 安全存储加密密钥
- 传输时使用HTTPS
### 3. 密钥保护
- 不在日志中输出密钥
- 不在代码中硬编码密钥
- 使用安全的密钥派生方法
- 及时清除内存中的密钥
## 常见问题
### 1. 密钥丢失
#### 问题
- 密钥无法恢复
- 数据无法解密
#### 解决
- 备份密钥（安全方式）
- 使用密钥恢复机制
- 避免密钥丢失
### 2. 性能问题
#### 问题
- 加密解密性能影响
#### 解决
- 选择合适的算法
- 使用硬件加速
- 优化加密操作
### 3. 兼容性问题
#### 问题
- 不同设备支持不同
#### 解决
- 检查设备支持
- 提供降级方案
- 充分测试
## 相关链接
- [[README]]
- [[权限管理框架]]
- [[漏洞案例库]]

329
docs/Obsidian笔记体系/Areas/07-系统安全/权限管理框架.md
View File

@@ -1 +1,330 @@
# 权限管理框架
## 概述
Android权限管理框架是Android系统安全的核心机制之一，用于控制应用对系统资源和用户数据的访问。
## 权限系统架构
### 1. 权限类型
#### 普通权限（Normal Permissions）
- **特点**: 不涉及用户隐私，系统自动授予
- **示例**: INTERNET, ACCESS_NETWORK_STATE
- **授予方式**: 安装时自动授予
#### 危险权限（Dangerous Permissions）
- **特点**: 涉及用户隐私或系统安全
- **示例**: CAMERA, READ_CONTACTS, WRITE_EXTERNAL_STORAGE
- **授予方式**: 运行时动态申请
#### 签名权限（Signature Permissions）
- **特点**: 只有与定义权限的应用使用相同签名才能获得
- **示例**: 系统级权限
- **授予方式**: 签名匹配时自动授予
#### 特殊权限（Special Permissions）
- **特点**: 需要用户手动在设置中授予
- **示例**: SYSTEM_ALERT_WINDOW, WRITE_SETTINGS
- **授予方式**: 跳转到设置页面授予
### 2. 权限声明
#### AndroidManifest.xml声明
```xml
<manifest>
<!-- 声明权限 -->
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.READ_CONTACTS" />
<!-- 定义自定义权限 -->
<permission
android:name="com.example.CUSTOM_PERMISSION"
android:label="自定义权限"
android:description="权限描述"
android:protectionLevel="dangerous" />
</manifest>
```
#### 保护级别（Protection Level）
- **normal**: 普通权限
- **dangerous**: 危险权限
- **signature**: 签名权限
- **signatureOrSystem**: 签名或系统权限
### 3. 权限组
#### 权限组概念
- 相关权限归为一组
- 授予组内一个权限，组内其他权限自动授予
- 撤销组内一个权限，组内其他权限自动撤销
#### 常见权限组
- **CALENDAR**: 日历相关权限
- **CAMERA**: 相机权限
- **CONTACTS**: 联系人权限
- **LOCATION**: 位置权限
- **MICROPHONE**: 麦克风权限
- **PHONE**: 电话权限
- **SENSORS**: 传感器权限
- **SMS**: 短信权限
- **STORAGE**: 存储权限
## 权限申请流程
### 1. 运行时权限申请（Android 6.0+）
#### 检查权限
```java
// 检查权限是否已授予
if (ContextCompat.checkSelfPermission(context,
Manifest.permission.CAMERA)
!= PackageManager.PERMISSION_GRANTED) {
// 权限未授予，需要申请
}
```
#### 申请权限
```java
// 申请权限
ActivityCompat.requestPermissions(activity,
new String[]{Manifest.permission.CAMERA},
REQUEST_CODE_CAMERA);
```
#### 处理权限结果
```java
@Override
public void onRequestPermissionsResult(int requestCode,
@NonNull String[] permissions,
@NonNull int[] grantResults) {
if (requestCode == REQUEST_CODE_CAMERA) {
if (grantResults.length > 0 &&
grantResults[0] == PackageManager.PERMISSION_GRANTED) {
// 权限已授予
useCamera();
} else {
// 权限被拒绝
handlePermissionDenied();
}
}
}
```
### 2. 权限申请最佳实践
#### 解释权限用途
```java
// 如果用户之前拒绝过权限，解释为什么需要权限
if (ActivityCompat.shouldShowRequestPermissionRationale(activity,
Manifest.permission.CAMERA)) {
// 显示解释对话框
showExplanationDialog();
} else {
// 直接申请权限
requestPermission();
}
```
#### 处理永久拒绝
```java
// 检查是否永久拒绝（不再询问）
if (!ActivityCompat.shouldShowRequestPermissionRationale(activity,
Manifest.permission.CAMERA) &&
!isPermissionGranted()) {
// 引导用户到设置页面
openAppSettings();
}
```
## 权限管理实现
### 1. PackageManagerService
#### 权限检查
```java
// PackageManagerService.java
public int checkPermission(String permName, String pkgName, int userId) {
// 检查权限是否授予
// 返回PERMISSION_GRANTED或PERMISSION_DENIED
}
```
#### 权限授予
```java
public void grantRuntimePermission(String packageName,
String permissionName, int userId) {
// 授予运行时权限
// 更新权限状态
// 通知相关组件
}
```
### 2. PermissionController
#### 权限管理界面
- 系统权限管理应用
- 用户权限设置界面
- 权限使用统计
#### 权限策略
- 自动撤销未使用权限
- 权限使用提醒
- 权限使用统计
## 权限最佳实践
### 1. 最小权限原则
```java
// ❌ 错误：申请过多权限
<uses-permission android:name="android.permission.READ_CONTACTS" />
<uses-permission android:name="android.permission.WRITE_CONTACTS" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
// ✅ 正确：只申请必要的权限
<uses-permission android:name="android.permission.READ_CONTACTS" />
```
### 2. 运行时权限检查
```java
// 每次使用前都检查权限
if (checkPermission()) {
useFeature();
} else {
requestPermission();
}
```
### 3. 权限使用说明
```java
// 向用户解释为什么需要权限
private void showPermissionExplanation() {
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("需要相机权限");
builder.setMessage("我们需要相机权限来拍摄照片");
builder.setPositiveButton("确定", (dialog, which) -> {
requestPermission();
});
builder.show();
}
```
### 4. 权限撤销处理
```java
// 监听权限变化
private BroadcastReceiver permissionReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction().equals(
PackageManager.ACTION_PERMISSION_REVOKED)) {
// 权限被撤销，处理逻辑
handlePermissionRevoked();
}
}
};
```
## 自定义权限
### 1. 定义自定义权限
```xml
<!-- AndroidManifest.xml -->
<permission
android:name="com.example.CUSTOM_PERMISSION"
android:label="自定义权限"
android:description="这是自定义权限的描述"
android:protectionLevel="dangerous"
android:permissionGroup="com.example.PERMISSION_GROUP" />
```
### 2. 使用自定义权限
```xml
<!-- 在需要保护的组件上使用 -->
<activity
android:name=".ProtectedActivity"
android:permission="com.example.CUSTOM_PERMISSION" />
```
### 3. 检查自定义权限
```java
// 检查自定义权限
if (checkSelfPermission("com.example.CUSTOM_PERMISSION")
== PackageManager.PERMISSION_GRANTED) {
// 权限已授予
}
```
## 系统权限
### 1. 系统级权限
- **SYSTEM_ALERT_WINDOW**: 悬浮窗权限
- **WRITE_SETTINGS**: 系统设置权限
- **REQUEST_IGNORE_BATTERY_OPTIMIZATIONS**: 忽略电池优化
### 2. 系统权限申请
```java
// 申请系统权限
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (!Settings.canDrawOverlays(this)) {
Intent intent = new Intent(
Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
intent.setData(Uri.parse("package:" + getPackageName()));
startActivity(intent);
}
}
```
## 权限调试
### 1. 查看权限状态
```bash
# 查看应用权限
adb shell dumpsys package com.example.app | grep permission
# 查看所有权限
adb shell pm list permissions
# 查看权限组
adb shell pm list permission-groups
```
### 2. 授予/撤销权限
```bash
# 授予权限
adb shell pm grant com.example.app android.permission.CAMERA
# 撤销权限
adb shell pm revoke com.example.app android.permission.CAMERA
```
### 3. 权限测试
```bash
# 重置权限
adb shell pm reset-permissions
# 清除应用数据（会清除权限）
adb shell pm clear com.example.app
```
## 安全考虑
### 1. 权限滥用防护
- 检查权限使用合理性
- 监控权限使用情况
- 及时撤销未使用权限
### 2. 权限泄露防护
- 避免权限泄露
- 安全存储权限信息
- 防止权限被恶意利用
### 3. 权限升级攻击防护
- 防止权限升级攻击
- 验证权限授予来源
- 监控异常权限授予
## 相关链接
- [[README]]
- [[04-资源与包管理/PackageManagerService]]
- [[漏洞案例库]]

390
docs/Obsidian笔记体系/Areas/07-系统安全/漏洞案例库.md
View File

@@ -1 +1,391 @@
# 漏洞案例库
## 概述
本文档收集了Android系统开发中常见的安全漏洞案例，包括漏洞分析、利用方式、防护措施等，帮助开发者避免类似问题。
## 漏洞分类
### 1. 权限相关漏洞
#### 案例1: 权限提升攻击
**漏洞描述**: 应用通过权限提升获得不应有的权限
**漏洞原因**:
- 权限检查不严格
- 权限授予逻辑错误
- 权限泄露
**利用方式**:
```java
// 恶意应用尝试获取系统权限
Intent intent = new Intent();
intent.setComponent(new ComponentName("com.system.app",
"com.system.app.ProtectedActivity"));
// 如果权限检查不严格，可能成功启动
startActivity(intent);
```
**防护措施**:
- 严格权限检查
- 验证调用者身份
- 使用签名权限
- 最小权限原则
**相关链接**: [[权限管理框架]]
#### 案例2: 权限泄露
**漏洞描述**: 应用将权限泄露给其他应用
**漏洞原因**:
- 组件导出且未设置权限
- 权限检查绕过
- 数据泄露
**利用方式**:
```xml
<!-- 错误配置：组件导出且无权限保护 -->
<activity
android:name=".SensitiveActivity"
android:exported="true" />
```
**防护措施**:
- 设置组件权限
- 限制组件导出
- 验证调用者
- 数据访问控制
### 2. 数据泄露漏洞
#### 案例3: 日志泄露敏感信息
**漏洞描述**: 日志中输出敏感信息，被恶意应用读取
**漏洞原因**:
- 开发时添加调试日志
- 生产环境未移除
- 日志级别设置不当
**利用方式**:
```java
// 错误示例：日志中输出敏感信息
Log.d("TAG", "User password: " + password);
Log.d("TAG", "API key: " + apiKey);
// 恶意应用可以读取日志
Process process = Runtime.getRuntime().exec("logcat -d");
BufferedReader reader = new BufferedReader(
new InputStreamReader(process.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
// 解析日志，获取敏感信息
}
```
**防护措施**:
- 生产环境移除调试日志
- 使用ProGuard混淆
- 敏感信息脱敏
- 设置日志级别
#### 案例4: 文件权限泄露
**漏洞描述**: 文件权限设置不当，其他应用可以访问
**漏洞原因**:
- 文件权限设置为全局可读
- 敏感文件未加密
- 文件路径可预测
**利用方式**:
```java
// 错误示例：文件权限设置为全局可读
File file = new File(getFilesDir(), "sensitive_data.txt");
file.setReadable(true, false); // 全局可读
// 恶意应用可以读取
File sensitiveFile = new File("/data/data/com.victim.app/files/sensitive_data.txt");
if (sensitiveFile.exists() && sensitiveFile.canRead()) {
// 读取敏感数据
}
```
**防护措施**:
- 使用MODE_PRIVATE创建文件
- 敏感文件加密存储
- 使用AndroidKeyStore
- 验证文件访问权限
### 3. 组件安全漏洞
#### 案例5: Intent劫持
**漏洞描述**: 恶意应用劫持Intent，获取敏感数据
**漏洞原因**:
- Intent未指定接收者
- 组件导出且无权限保护
- 数据验证不足
**利用方式**:
```java
// 错误示例：隐式Intent
Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra("sensitive_data", data);
startActivity(intent); // 可能被恶意应用劫持
// 恶意应用注册相同的Intent Filter
<activity android:name=".MaliciousActivity">
<intent-filter>
<action android:name="android.intent.action.SEND" />
</intent-filter>
</activity>
```
**防护措施**:
- 使用显式Intent
- 验证Intent接收者
- 设置组件权限
- 数据加密传输
#### 案例6: 组件导出漏洞
**漏洞描述**: 导出的组件未设置权限，被恶意应用调用
**漏洞原因**:
- 组件意外导出
- 未设置权限保护
- 功能验证不足
**利用方式**:
```xml
<!-- 错误配置 -->
<activity
android:name=".AdminActivity"
android:exported="true" />
<!-- 恶意应用直接调用 -->
Intent intent = new Intent();
intent.setComponent(new ComponentName("com.victim.app",
"com.victim.app.AdminActivity"));
startActivity(intent);
```
**防护措施**:
- 限制组件导出
- 设置权限保护
- 验证调用者
- 功能访问控制
### 4. 加密相关漏洞
#### 案例7: 弱加密算法
**漏洞描述**: 使用弱加密算法，容易被破解
**漏洞原因**:
- 使用过时的加密算法
- 密钥长度不足
- 加密实现错误
**利用方式**:
```java
// 错误示例：使用弱加密算法
Cipher cipher = Cipher.getInstance("DES"); // DES已不安全
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] encrypted = cipher.doFinal(data);
// 攻击者可以破解
// DES密钥只有56位，容易被暴力破解
```
**防护措施**:
- 使用强加密算法（AES-256）
- 足够的密钥长度
- 使用标准加密库
- 定期更新加密算法
#### 案例8: 密钥硬编码
**漏洞描述**: 密钥硬编码在代码中，容易被提取
**漏洞原因**:
- 开发便利性考虑
- 安全意识不足
- 密钥管理不当
**利用方式**:
```java
// 错误示例：密钥硬编码
private static final String SECRET_KEY = "my_secret_key_12345";
// 攻击者可以反编译APK，提取密钥
// 使用jadx等工具反编译
// 找到硬编码的密钥
```
**防护措施**:
- 使用AndroidKeyStore
- 密钥服务器端管理
- 使用密钥派生
- 代码混淆
### 5. 网络安全漏洞
#### 案例9: 中间人攻击
**漏洞描述**: 未使用HTTPS或证书验证不当，容易被中间人攻击
**漏洞原因**:
- 使用HTTP传输敏感数据
- 证书验证被禁用
- 信任所有证书
**利用方式**:
```java
// 错误示例：信任所有证书
TrustManager[] trustAllCerts = new TrustManager[]{
new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() { return null; }
public void checkClientTrusted(X509Certificate[] certs, String authType) {}
public void checkServerTrusted(X509Certificate[] certs, String authType) {}
}
};
SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, trustAllCerts, new SecureRandom());
```
**防护措施**:
- 使用HTTPS
- 正确验证证书
- 证书固定
- 网络安全配置
#### 案例10: 敏感数据明文传输
**漏洞描述**: 敏感数据未加密传输
**漏洞原因**:
- 使用HTTP
- 数据未加密
- 安全意识不足
**防护措施**:
- 使用HTTPS
- 数据加密传输
- 使用安全协议
## 漏洞防护措施
### 1. 代码安全
#### 安全编码规范
- 输入验证
- 输出编码
- 错误处理
- 安全配置
#### 代码审查
- 安全代码审查
- 漏洞扫描
- 静态分析
- 动态测试
### 2. 系统加固
#### SELinux配置
- 编写SELinux策略
- 限制应用权限
- 强制访问控制
#### 系统配置
- 安全配置检查
- 系统服务安全
- 网络安全配置
### 3. 安全测试
#### 渗透测试
- 安全测试
- 漏洞扫描
- 安全审计
#### 自动化测试
- 安全测试用例
- 自动化扫描
- 持续监控
## 漏洞响应
### 1. 漏洞发现
#### 发现流程
1. 漏洞报告
2. 漏洞验证
3. 影响评估
4. 修复计划
### 2. 漏洞修复
#### 修复流程
1. 分析漏洞根因
2. 制定修复方案
3. 实施修复
4. 测试验证
5. 发布更新
### 3. 漏洞披露
#### 披露原则
- 负责任披露
- 及时通知
- 提供修复方案
- 安全公告
## 安全编码规范
### 1. 输入验证
```java
// ✅ 正确：验证输入
public void processInput(String input) {
if (input == null || input.isEmpty()) {
throw new IllegalArgumentException("Input cannot be null or empty");
}
// 验证输入格式
if (!input.matches("[a-zA-Z0-9]+")) {
throw new IllegalArgumentException("Invalid input format");
}
// 处理输入
}
```
### 2. 输出编码
```java
// ✅ 正确：输出编码
public String displayContent(String content) {
// HTML编码
return Html.escapeHtml(content);
}
```
### 3. 错误处理
```java
// ✅ 正确：不泄露敏感信息
try {
// 操作
} catch (Exception e) {
// 记录详细错误（内部日志）
Log.e("TAG", "Error details", e);
// 返回通用错误（用户界面）
showError("操作失败，请重试");
}
```
### 4. 安全配置
```xml
<!-- ✅ 正确：安全配置 -->
<activity
android:name=".SensitiveActivity"
android:exported="false"
android:permission="com.example.PERMISSION" />
```
## 相关链接
- [[README]]
- [[权限管理框架]]
- [[SELinux策略编写]]
- [[密钥存储与加密]]

108
docs/Obsidian笔记体系/Areas/08-定制化开发/README.md
View File

@@ -1 +1,109 @@
# 08-定制化开发
## 概述
定制化开发是Android Framework开发中的重要领域，涉及系统服务定制、UI定制、功能扩展等方面。本目录系统性地整理了Android系统定制化开发的知识。
## 目录结构
### 1. 系统服务添加流程
- 系统服务设计
- 服务注册和启动
- 服务接口定义
- 服务实现和测试
### 2. 系统属性定制
- 系统属性定义
- 属性读写管理
- 属性持久化
- 属性使用规范
### 3. 厂商定制接口规范
- 定制接口设计规范
- 接口版本管理
- 接口兼容性
- 接口文档规范
### 4. 开机动画与OTA
- 开机动画定制
- OTA升级机制
- 升级包制作
- 升级流程管理
## 定制化原则
### 1. 兼容性原则
- 保持与AOSP的兼容性
- 避免破坏系统稳定性
- 遵循Android规范
### 2. 可维护性原则
- 代码结构清晰
- 文档完善
- 易于扩展和维护
### 3. 性能原则
- 不影响系统性能
- 优化定制功能
- 资源使用合理
### 4. 安全原则
- 遵循安全规范
- 权限控制严格
- 数据保护到位
## 定制化类型
### 1. 系统服务定制
- 添加新的系统服务
- 扩展现有系统服务
- 定制服务行为
### 2. UI定制
- 系统主题定制
- 开机动画定制
- 系统图标定制
### 3. 功能定制
- 添加新功能
- 修改系统行为
- 扩展系统能力
### 4. 配置定制
- 系统属性定制
- 配置文件定制
- 默认值定制
## 开发流程
### 1. 需求分析
- 明确定制需求
- 分析技术可行性
- 评估影响范围
### 2. 方案设计
- 设计技术方案
- 确定实现方式
- 评估风险和成本
### 3. 开发实现
- 代码实现
- 功能测试
- 性能优化
### 4. 测试验证
- 功能测试
- 兼容性测试
- 稳定性测试
### 5. 部署上线
- 打包发布
- 部署验证
- 监控维护
## 相关链接
- [[01-系统启动流程]]
- [[04-资源与包管理]]
- [[07-系统安全]]
- [[MOCs/Android Framework知识体系图]]

441
docs/Obsidian笔记体系/Areas/08-定制化开发/厂商定制接口规范.md
View File

@@ -1 +1,442 @@
# 厂商定制接口规范
## 概述
厂商定制接口是Android系统定制化开发中的重要内容，本文档介绍厂商定制接口的设计规范、版本管理、兼容性等。
## 接口设计原则
### 1. 设计原则
#### 兼容性原则
- 保持向后兼容
- 避免破坏性变更
- 提供迁移路径
#### 可扩展性原则
- 接口设计灵活
- 支持功能扩展
- 预留扩展空间
#### 稳定性原则
- 接口稳定可靠
- 充分测试验证
- 文档完善
### 2. 接口分类
#### 系统服务接口
- 系统级服务接口
- 需要系统权限
- 通过Binder通信
#### 应用接口
- 应用可用的接口
- 通过API提供
- 权限控制
#### 隐藏接口
- 系统内部接口
- 不对外公开
- 使用@hide标记
## 接口定义规范
### 1. AIDL接口定义
#### 接口文件规范
```java
// IVendorCustomService.aidl
package com.android.vendor;
/**
* 厂商定制服务接口
* @version 1.0
* @since Android 10
*/
interface IVendorCustomService {
/**
* 获取定制数据
* @return 定制数据
*/
String getCustomData();
/**
* 设置定制数据
* @param data 定制数据
* @return 操作结果，0表示成功
*/
int setCustomData(String data);
/**
* 执行定制操作
* @param operation 操作类型
* @param params 操作参数
* @return 操作结果
*/
Bundle performCustomOperation(int operation, Bundle params);
}
```
#### 接口命名规范
- 使用描述性名称
- 遵循Java命名规范
- 使用前缀区分（如Vendor）
### 2. Java接口定义
#### 接口类定义
```java
/**
* 厂商定制接口
* @hide
*/
public interface IVendorCustomInterface {
/**
* 获取版本号
* @return 接口版本号
*/
int getVersion();
/**
* 检查功能是否支持
* @param feature 功能ID
* @return 是否支持
*/
boolean isFeatureSupported(int feature);
/**
* 执行功能
* @param feature 功能ID
* @param params 参数
* @return 执行结果
*/
boolean executeFeature(int feature, Bundle params);
}
```
### 3. 接口实现
#### 服务实现
```java
/**
* 厂商定制服务实现
* @hide
*/
public class VendorCustomService extends IVendorCustomService.Stub {
private static final String TAG = "VendorCustomService";
private static final int VERSION = 1;
@Override
public String getCustomData() {
// 权限检查
enforceVendorPermission();
// 实现逻辑
return getData();
}
@Override
public int setCustomData(String data) {
enforceVendorPermission();
// 实现逻辑
return setData(data);
}
private void enforceVendorPermission() {
// 检查调用者权限
if (Binder.getCallingUid() != Process.SYSTEM_UID) {
throw new SecurityException("Vendor permission required");
}
}
}
```
## 接口版本管理
### 1. 版本号规范
#### 版本号格式
- **主版本号**: 不兼容的变更
- **次版本号**: 兼容的功能添加
- **修订版本号**: 兼容的问题修复
#### 版本号示例
```
1.0.0 # 初始版本
1.1.0 # 添加新功能
1.1.1 # 修复问题
2.0.0 # 不兼容变更
```
### 2. 版本兼容性
#### 向后兼容
- 新版本保持旧接口
- 不删除已有接口
- 不修改接口签名
#### 兼容性处理
```java
public class VendorCustomService extends IVendorCustomService.Stub {
private static final int CURRENT_VERSION = 2;
@Override
public int getVersion() {
return CURRENT_VERSION;
}
// 保持旧接口
@Override
public String getCustomData() {
return getCustomDataV2(null);
}
// 新接口
public String getCustomDataV2(Bundle options) {
// 新实现
}
}
```
### 3. 版本迁移
#### 迁移策略
- 提供迁移指南
- 保持旧接口一段时间
- 逐步迁移到新接口
#### 迁移示例
```java
/**
* @deprecated 使用 getCustomDataV2 替代
*/
@Deprecated
public String getCustomData() {
// 调用新接口
return getCustomDataV2(null);
}
```
## 接口文档
### 1. 接口文档规范
#### 文档内容
- 接口概述
- 方法说明
- 参数说明
- 返回值说明
- 异常说明
- 使用示例
#### 文档示例
```java
/**
* 厂商定制服务接口
*
* <p>提供厂商定制功能的服务接口，包括数据获取、设置等功能。</p>
*
* <p>使用示例：</p>
* <pre>
* IVendorCustomService service = VendorCustomServiceManager.getService();
* String data = service.getCustomData();
* </pre>
*
* @version 1.0
* @since Android 10
* @hide
*/
public interface IVendorCustomService {
/**
* 获取定制数据
*
* <p>获取系统存储的定制数据，如果数据不存在返回默认值。</p>
*
* @return 定制数据字符串，如果不存在返回"default"
* @throws RemoteException 如果服务调用失败
*/
String getCustomData() throws RemoteException;
}
```
### 2. API文档生成
#### 使用javadoc
```bash
# 生成API文档
javadoc -d docs -sourcepath src com.android.vendor
```
## 接口测试
### 1. 单元测试
#### 测试接口功能
```java
@Test
public void testGetCustomData() {
VendorCustomService service = new VendorCustomService(mockContext);
String data = service.getCustomData();
assertNotNull(data);
}
@Test
public void testSetCustomData() {
VendorCustomService service = new VendorCustomService(mockContext);
int result = service.setCustomData("test");
assertEquals(0, result);
}
```
### 2. 集成测试
#### 测试服务调用
```java
@Test
public void testServiceCall() {
IVendorCustomService service = VendorCustomServiceManager.getService();
assertNotNull(service);
String data = service.getCustomData();
assertNotNull(data);
}
```
### 3. 兼容性测试
#### 测试版本兼容
```java
@Test
public void testVersionCompatibility() {
IVendorCustomService service = VendorCustomServiceManager.getService();
int version = service.getVersion();
// 测试不同版本的兼容性
if (version >= 2) {
// 使用新接口
String data = service.getCustomDataV2(null);
} else {
// 使用旧接口
String data = service.getCustomData();
}
}
```
## 接口使用规范
### 1. 客户端使用
#### 获取服务
```java
public class VendorCustomClient {
private IVendorCustomService mService;
public VendorCustomClient() {
mService = VendorCustomServiceManager.getService();
}
public String getCustomData() {
if (mService == null) {
return "default";
}
try {
return mService.getCustomData();
} catch (RemoteException e) {
Log.e(TAG, "Failed to get custom data", e);
return "default";
}
}
}
```
### 2. 错误处理
#### 异常处理
```java
try {
String data = service.getCustomData();
// 处理数据
} catch (RemoteException e) {
// 服务调用失败
Log.e(TAG, "Service call failed", e);
handleError();
} catch (SecurityException e) {
// 权限不足
Log.e(TAG, "Permission denied", e);
requestPermission();
}
```
### 3. 权限检查
#### 权限验证
```java
// 检查权限
if (checkSelfPermission("android.permission.USE_VENDOR_SERVICE")
!= PackageManager.PERMISSION_GRANTED) {
// 请求权限
requestPermission();
return;
}
// 使用服务
useService();
```
## 接口扩展
### 1. 功能扩展
#### 添加新方法
```java
// 在接口中添加新方法
public interface IVendorCustomService {
// 原有方法
String getCustomData();
// 新增方法
String getCustomDataV2(Bundle options);
}
```
### 2. 参数扩展
#### 使用Bundle扩展
```java
// 使用Bundle支持参数扩展
public Bundle performOperation(int operation, Bundle params) {
// 支持参数扩展
if (params != null) {
// 处理扩展参数
}
// 执行操作
}
```
## 最佳实践
### 1. 接口设计
- 接口设计清晰
- 职责单一
- 易于使用
### 2. 版本管理
- 保持向后兼容
- 版本号规范
- 迁移指南
### 3. 文档完善
- 接口文档完整
- 使用示例清晰
- 更新及时
### 4. 测试充分
- 单元测试
- 集成测试
- 兼容性测试
## 相关链接
- [[README]]
- [[系统服务添加流程]]
- [[05-进程与线程通信/AIDL与HIDL使用与原理]]

354
docs/Obsidian笔记体系/Areas/08-定制化开发/开机动画与OTA.md
View File

@@ -1 +1,355 @@
# 开机动画与OTA
## 概述
开机动画和OTA升级是Android系统定制化的重要内容。本文档介绍开机动画的定制方法和OTA升级机制。
## 开机动画定制
### 1. 开机动画基础
#### 动画格式
- **bootanimation.zip**: 开机动画压缩包
- **desc.txt**: 动画描述文件
- **图片序列**: PNG格式图片序列
#### 动画位置
```
/system/media/bootanimation.zip
```
#### 动画结构
```
bootanimation.zip
├── desc.txt # 描述文件
├── part0/ # 第一部分图片
│ ├── 00000.png
│ ├── 00001.png
│ └── ...
└── part1/ # 第二部分图片
├── 00000.png
├── 00001.png
└── ...
```
### 2. 描述文件格式
#### desc.txt格式
```
width height fps
p type count path
p type count path
```
#### 参数说明
- **width**: 动画宽度（像素）
- **height**: 动画高度（像素）
- **fps**: 帧率（帧/秒）
- **p**: 部分标识
- **type**: 播放类型（c=循环，p=播放一次）
- **count**: 播放次数（0=无限循环）
- **path**: 图片路径
#### 示例
```
1080 1920 30
p 1 0 part0
p 0 0 part1
```
### 3. 制作开机动画
#### 步骤1: 准备图片
- 准备PNG格式图片序列
- 图片尺寸一致
- 图片命名规范（00000.png, 00001.png...）
#### 步骤2: 创建目录结构
```bash
mkdir bootanimation
cd bootanimation
mkdir part0 part1
# 复制图片到对应目录
```
#### 步骤3: 创建描述文件
```bash
# 创建desc.txt
cat > desc.txt << EOF
1080 1920 30
p 1 0 part0
p 0 0 part1
EOF
```
#### 步骤4: 打包
```bash
# 打包为zip文件（注意：使用zip命令，不要压缩）
zip -0 -r ../bootanimation.zip desc.txt part0 part1
```
#### 步骤5: 部署
```bash
# 推送到设备
adb push bootanimation.zip /system/media/
# 设置权限
adb shell chmod 644 /system/media/bootanimation.zip
adb shell chown root:root /system/media/bootanimation.zip
```
### 4. 开机动画优化
#### 性能优化
- 减少图片数量
- 优化图片大小
- 使用合适的帧率
- 减少动画时长
#### 图片优化
```bash
# 压缩图片
pngquant --quality=65-80 bootanimation/part0/*.png
# 优化图片大小
optipng -o7 bootanimation/part0/*.png
```
## OTA升级机制
### 1. OTA基础
#### OTA类型
- **增量OTA**: 只更新变更部分
- **全量OTA**: 完整系统更新
- **AB系统OTA**: A/B分区系统更新
#### OTA包结构
```
ota_package.zip
├── META-INF/
│ ├── com/
│ │ └── android/
│ │ ├── metadata
│ │ └── otacert
│ └── MANIFEST.MF
├── system/
│ └── ...
└── boot.img
```
### 2. OTA包制作
#### 使用build/tools制作
```bash
# 制作增量OTA包
./build/tools/releasetools/ota_from_target_files \
-k build/target/product/security/testkey \
-i previous.zip current.zip incremental.zip
# 制作全量OTA包
./build/tools/releasetools/ota_from_target_files \
-k build/target/product/security/testkey \
target_files.zip full_ota.zip
```
#### target_files.zip制作
```bash
# 从系统镜像制作target_files
./build/tools/releasetools/img_from_target_files \
target_files.zip system.img
```
### 3. OTA升级流程
#### 升级步骤
```
1. 下载OTA包
↓
2. 验证OTA包签名
↓
3. 进入Recovery模式
↓
4. 安装OTA包
↓
5. 重启系统
↓
6. 完成升级
```
#### Recovery升级脚本
```bash
#!/sbin/sh
# update-binary脚本
# 挂载分区
mount /system
mount /data
# 应用更新
apply_patch SYSTEM:system.new.dat system.transfer.list
# 清理
unmount /system
unmount /data
```
### 4. OTA升级实现
#### 系统升级服务
```java
// SystemUpdateService.java
public class SystemUpdateService extends SystemService {
private static final String TAG = "SystemUpdateService";
public void checkForUpdates() {
// 检查更新
UpdateInfo updateInfo = fetchUpdateInfo();
if (updateInfo != null) {
// 下载更新
downloadUpdate(updateInfo);
}
}
public void installUpdate(File updateFile) {
// 验证签名
if (!verifySignature(updateFile)) {
return;
}
// 进入Recovery安装
rebootToRecovery(updateFile);
}
}
```
#### Recovery升级
```java
// RecoverySystem.java
public class RecoverySystem {
public static void installPackage(Context context, File packageFile)
throws IOException {
// 验证包
verifyPackage(packageFile);
// 写入命令
String command = "update_package=" + packageFile.getCanonicalPath();
RecoverySystem.bootCommand(context, command);
}
}
```
## 开机动画性能优化
### 1. 优化策略
#### 减少资源
- 减少图片数量
- 优化图片大小
- 使用压缩格式
#### 优化加载
- 预加载动画资源
- 优化解码性能
- 减少内存占用
### 2. 性能测试
#### 测试方法
```bash
# 测量开机动画加载时间
adb shell dmesg | grep bootanimation
# 测量动画播放帧率
adb shell dumpsys SurfaceFlinger | grep bootanimation
```
## OTA升级优化
### 1. 增量升级
#### 增量包制作
- 只包含变更文件
- 使用差分包
- 减少下载大小
#### 增量升级优势
- 下载速度快
- 节省带宽
- 升级时间短
### 2. A/B系统升级
#### A/B分区
- 双系统分区
- 无缝升级
- 快速回滚
#### A/B升级流程
```
当前系统在A分区
↓
下载更新到B分区
↓
安装更新到B分区
↓
重启切换到B分区
↓
B分区成为当前系统
```
## 常见问题
### 1. 开机动画不显示
#### 问题原因
- 文件路径错误
- 权限设置错误
- 格式不正确
#### 解决方法
- 检查文件路径
- 检查文件权限
- 验证zip格式
### 2. 开机动画卡顿
#### 问题原因
- 图片过大
- 帧率过高
- 资源加载慢
#### 解决方法
- 优化图片大小
- 降低帧率
- 优化加载流程
### 3. OTA升级失败
#### 问题原因
- 签名验证失败
- 空间不足
- 版本不匹配
#### 解决方法
- 检查签名
- 检查空间
- 检查版本
## 最佳实践
### 1. 开机动画
- 保持动画简洁
- 优化资源大小
- 测试不同设备
### 2. OTA升级
- 充分测试升级包
- 提供回滚机制
- 监控升级过程
## 相关链接
- [[README]]
- [[01-系统启动流程]]
- [[06-性能优化体系/启动优化方法论]]

354
docs/Obsidian笔记体系/Areas/08-定制化开发/系统属性定制.md
View File

@@ -1 +1,355 @@
# 系统属性定制
## 概述
系统属性是Android系统中用于配置和存储系统信息的重要机制。本文档介绍如何定制系统属性，包括属性定义、读写管理、持久化等。
## 系统属性基础
### 1. 属性类型
#### 只读属性（ro.*）
- **特点**: 只读，系统启动时设置，不能修改
- **示例**: `ro.build.version.sdk`, `ro.product.model`
- **用途**: 系统信息、硬件信息
#### 可写属性（其他）
- **特点**: 可读写，运行时可以修改
- **示例**: `sys.settings.global.*`, `persist.*`
- **用途**: 系统配置、应用配置
#### 持久化属性（persist.*）
- **特点**: 修改后持久化到文件，重启后保持
- **示例**: `persist.sys.timezone`, `persist.vendor.*`
- **用途**: 需要持久化的配置
### 2. 属性命名规范
#### 命名规则
- **ro.**: 只读属性
- **persist.**: 持久化属性
- **vendor.**: 厂商属性
- **sys.**: 系统属性
- **ctl.**: 控制属性
#### 命名示例
```bash
# 只读属性
ro.build.version.sdk
ro.product.manufacturer
# 持久化属性
persist.sys.timezone
persist.vendor.custom.property
# 系统属性
sys.settings.global.screen_brightness
# 厂商属性
ro.vendor.custom.feature
```
## 属性定义
### 1. 在源码中定义属性
#### 定义位置
```
build/target/product/
└── system_prop.mk
```
#### 定义方式
```makefile
# system_prop.mk
# 定义只读属性
PRODUCT_PROPERTY_OVERRIDES += \
ro.custom.property=value \
ro.vendor.feature.enabled=true
# 定义持久化属性默认值
PRODUCT_PROPERTY_OVERRIDES += \
persist.sys.custom.setting=default_value
```
### 2. 在代码中设置属性
#### 设置只读属性
```java
// 在init进程或SystemServer中设置
SystemProperties.set("ro.custom.property", "value");
// 注意：ro.*属性只能在系统启动时设置
```
#### 设置可写属性
```java
// 设置系统属性
SystemProperties.set("sys.custom.property", "value");
// 设置持久化属性
SystemProperties.set("persist.custom.property", "value");
```
### 3. 属性默认值
#### 在default.prop中设置
```bash
# default.prop
ro.custom.property=default_value
persist.sys.custom.setting=default
```
#### 在build.prop中设置
```bash
# build.prop
ro.build.custom.feature=true
ro.vendor.custom.config=value
```
## 属性读写
### 1. Java层读写
#### 读取属性
```java
// 读取属性
String value = SystemProperties.get("ro.custom.property", "default");
// 读取整数属性
int intValue = SystemProperties.getInt("sys.custom.int", 0);
// 读取长整数属性
long longValue = SystemProperties.getLong("sys.custom.long", 0L);
// 读取布尔属性
boolean boolValue = SystemProperties.getBoolean("sys.custom.bool", false);
```
#### 设置属性
```java
// 设置属性（需要系统权限）
SystemProperties.set("sys.custom.property", "value");
// 注意：只有系统进程可以设置属性
```
### 2. Native层读写
#### C/C++代码
```cpp
#include <cutils/properties.h>
// 读取属性
char value[PROPERTY_VALUE_MAX];
property_get("ro.custom.property", value, "default");
// 设置属性
property_set("sys.custom.property", "value");
```
### 3. Shell命令
#### 查看属性
```bash
# 查看所有属性
adb shell getprop
# 查看特定属性
adb shell getprop ro.custom.property
# 查看属性列表（过滤）
adb shell getprop | grep custom
```
#### 设置属性
```bash
# 设置属性（需要root）
adb shell setprop sys.custom.property value
# 设置持久化属性
adb shell setprop persist.custom.property value
```
## 属性持久化
### 1. 持久化机制
#### persist.*属性
- 自动持久化到 `/data/property/`
- 系统启动时自动加载
- 修改后立即持久化
#### 持久化文件
```bash
# 持久化属性文件位置
/data/property/
├── persist.sys.timezone
├── persist.vendor.custom.property
└── ...
```
### 2. 自定义持久化
#### 实现持久化逻辑
```java
public class CustomPropertyManager {
private static final String PROPERTY_FILE = "/data/custom/properties";
public void saveProperty(String key, String value) {
try {
Properties props = loadProperties();
props.setProperty(key, value);
saveProperties(props);
} catch (IOException e) {
Slog.e(TAG, "Failed to save property", e);
}
}
public String loadProperty(String key, String defaultValue) {
try {
Properties props = loadProperties();
return props.getProperty(key, defaultValue);
} catch (IOException e) {
return defaultValue;
}
}
}
```
## 属性使用场景
### 1. 系统配置
#### 系统设置
```java
// 使用属性存储系统配置
SystemProperties.set("sys.settings.screen_brightness", "128");
SystemProperties.set("sys.settings.sound_enabled", "true");
```
### 2. 功能开关
#### 功能控制
```java
// 使用属性控制功能开关
boolean featureEnabled = SystemProperties.getBoolean(
"ro.vendor.feature.enabled", false);
if (featureEnabled) {
enableFeature();
}
```
### 3. 调试配置
#### 调试开关
```java
// 使用属性控制调试功能
boolean debugMode = SystemProperties.getBoolean(
"debug.custom.enable", false);
if (debugMode) {
enableDebugLogging();
}
```
## 属性安全
### 1. 权限控制
#### 属性访问权限
- **读取**: 所有应用可以读取
- **写入**: 只有系统进程可以写入
- **控制**: 通过SELinux策略控制
### 2. SELinux策略
#### 属性访问策略
```sepolicy
# 允许进程读取属性
allow system_server system_prop:property_service get;
# 允许进程设置属性
allow system_server system_prop:property_service set;
```
### 3. 属性验证
#### 输入验证
```java
public void setCustomProperty(String key, String value) {
// 验证属性名
if (!isValidPropertyName(key)) {
throw new IllegalArgumentException("Invalid property name");
}
// 验证属性值
if (!isValidPropertyValue(value)) {
throw new IllegalArgumentException("Invalid property value");
}
// 设置属性
SystemProperties.set(key, value);
}
```
## 常见问题
### 1. 属性不生效
#### 问题原因
- 属性名错误
- 权限不足
- 属性未持久化
#### 解决方法
- 检查属性名拼写
- 检查权限配置
- 使用persist.*属性
### 2. 属性丢失
#### 问题原因
- 未使用persist.*
- 持久化文件被删除
- 系统重置
#### 解决方法
- 使用persist.*属性
- 保护持久化文件
- 在代码中设置默认值
### 3. 属性冲突
#### 问题原因
- 属性名冲突
- 属性值冲突
#### 解决方法
- 使用命名空间
- 检查属性使用
- 统一属性管理
## 最佳实践
### 1. 命名规范
- 使用清晰的命名
- 遵循命名规范
- 使用命名空间
### 2. 属性管理
- 统一属性管理
- 文档化属性
- 版本控制
### 3. 安全考虑
- 权限控制
- 输入验证
- SELinux策略
## 相关链接
- [[README]]
- [[系统服务添加流程]]
- [[07-系统安全/SELinux策略编写]]

401
docs/Obsidian笔记体系/Areas/08-定制化开发/系统服务添加流程.md
View File

@@ -1 +1,402 @@
# 系统服务添加流程
## 概述
系统服务是Android Framework的核心组件，本文档介绍如何添加自定义系统服务，包括服务设计、注册、启动等完整流程。
## 系统服务架构
### 1. 系统服务类型
#### 系统服务分类
- **核心服务**: SystemServer中启动的核心服务
- **系统服务**: 系统级服务，需要系统权限
- **应用服务**: 应用级服务，普通应用可使用
#### 服务生命周期
```
服务创建
↓
服务初始化
↓
服务注册
↓
服务运行
↓
服务销毁
```
### 2. 系统服务组件
#### 服务接口（AIDL）
- 定义服务接口
- 使用AIDL描述接口
- 生成接口代码
#### 服务实现
- 实现服务接口
- 处理业务逻辑
- 管理服务状态
#### 服务注册
- 在SystemServer中注册
- 添加到ServiceManager
- 设置服务权限
## 添加系统服务流程
### 1. 定义服务接口（AIDL）
#### 创建AIDL文件
```java
// IMyCustomService.aidl
package com.android.server;
interface IMyCustomService {
// 定义接口方法
String getCustomData();
void setCustomData(String data);
int performOperation(int param);
}
```
#### AIDL文件位置
```
frameworks/base/core/java/android/os/
└── IMyCustomService.aidl
```
### 2. 实现服务类
#### 服务实现
```java
// MyCustomService.java
package com.android.server;
import android.content.Context;
import android.os.Binder;
import android.util.Slog;
public class MyCustomService extends IMyCustomService.Stub {
private static final String TAG = "MyCustomService";
private final Context mContext;
private String mCustomData = "default";
public MyCustomService(Context context) {
mContext = context;
Slog.d(TAG, "MyCustomService created");
}
@Override
public String getCustomData() {
// 权限检查
enforcePermission();
return mCustomData;
}
@Override
public void setCustomData(String data) {
// 权限检查
enforcePermission();
mCustomData = data;
Slog.d(TAG, "Custom data set: " + data);
}
@Override
public int performOperation(int param) {
enforcePermission();
// 实现业务逻辑
return param * 2;
}
private void enforcePermission() {
// 检查调用者权限
if (Binder.getCallingUid() != Process.SYSTEM_UID) {
throw new SecurityException("Only system can call this service");
}
}
}
```
### 3. 在SystemServer中注册服务
#### 修改SystemServer
```java
// SystemServer.java
public final class SystemServer {
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
// ... 其他服务启动 ...
}
private void startCoreServices(@NonNull TimingsTraceAndSlog t) {
// ... 核心服务启动 ...
}
private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
// ... 其他服务启动 ...
// 启动自定义服务
t.traceBegin("StartMyCustomService");
try {
ServiceManager.addService("my_custom_service",
new MyCustomService(mSystemContext));
Slog.i(TAG, "MyCustomService started");
} catch (Throwable e) {
Slog.e(TAG, "Failure starting MyCustomService", e);
}
t.traceEnd();
}
}
```
### 4. 定义服务权限
#### 定义权限
```xml
<!-- frameworks/base/core/res/AndroidManifest.xml -->
<permission
android:name="android.permission.USE_MY_CUSTOM_SERVICE"
android:protectionLevel="signature|privileged"
android:label="@string/permission_use_my_custom_service"
android:description="@string/permission_use_my_custom_service_desc" />
```
### 5. 创建服务管理器
#### 服务管理器类
```java
// MyCustomServiceManager.java
package com.android.server;
import android.content.Context;
import android.os.ServiceManager;
public class MyCustomServiceManager {
private static final String SERVICE_NAME = "my_custom_service";
private static IMyCustomService sService;
public static IMyCustomService getService() {
synchronized (MyCustomServiceManager.class) {
if (sService == null) {
IBinder binder = ServiceManager.getService(SERVICE_NAME);
if (binder != null) {
sService = IMyCustomService.Stub.asInterface(binder);
}
}
return sService;
}
}
}
```
## 服务使用
### 1. 客户端调用
#### 获取服务
```java
// 客户端代码
IMyCustomService service = MyCustomServiceManager.getService();
if (service != null) {
try {
String data = service.getCustomData();
service.setCustomData("new data");
int result = service.performOperation(10);
} catch (RemoteException e) {
e.printStackTrace();
}
}
```
### 2. 权限检查
#### 声明权限
```xml
<!-- 客户端AndroidManifest.xml -->
<uses-permission android:name="android.permission.USE_MY_CUSTOM_SERVICE" />
```
#### 运行时检查
```java
// 检查权限
if (checkSelfPermission("android.permission.USE_MY_CUSTOM_SERVICE")
!= PackageManager.PERMISSION_GRANTED) {
// 权限未授予
return;
}
```
## 服务生命周期管理
### 1. 服务启动
#### 启动时机
- SystemServer启动时
- 按启动顺序启动
- 依赖其他服务时等待
#### 启动顺序
```java
// 在SystemServer中按顺序启动
private void startOtherServices() {
// 1. 先启动依赖的服务
startDependencyService();
// 2. 启动自定义服务
startMyCustomService();
// 3. 启动后续服务
startOtherServices();
}
```
### 2. 服务初始化
#### 初始化步骤
```java
public MyCustomService(Context context) {
mContext = context;
// 1. 初始化资源
initResources();
// 2. 初始化数据
initData();
// 3. 注册监听器
registerListeners();
// 4. 启动后台任务
startBackgroundTasks();
}
```
### 3. 服务销毁
#### 清理资源
```java
public void shutdown() {
// 1. 停止后台任务
stopBackgroundTasks();
// 2. 注销监听器
unregisterListeners();
// 3. 清理数据
cleanupData();
// 4. 释放资源
releaseResources();
}
```
## 服务测试
### 1. 单元测试
#### 测试服务功能
```java
@Test
public void testGetCustomData() {
MyCustomService service = new MyCustomService(mockContext);
String data = service.getCustomData();
assertEquals("default", data);
}
@Test
public void testSetCustomData() {
MyCustomService service = new MyCustomService(mockContext);
service.setCustomData("test");
String data = service.getCustomData();
assertEquals("test", data);
}
```
### 2. 集成测试
#### 测试服务注册
```java
@Test
public void testServiceRegistration() {
IBinder binder = ServiceManager.getService("my_custom_service");
assertNotNull(binder);
IMyCustomService service = IMyCustomService.Stub.asInterface(binder);
assertNotNull(service);
}
```
### 3. 功能测试
#### 测试服务调用
```bash
# 使用adb测试服务
adb shell service call my_custom_service 1 s16 "test"
```
## 常见问题
### 1. 服务无法启动
#### 问题原因
- 服务注册失败
- 权限不足
- 依赖服务未启动
#### 解决方法
- 检查服务注册代码
- 检查权限配置
- 检查启动顺序
### 2. 服务调用失败
#### 问题原因
- 服务未注册
- 权限不足
- 接口不匹配
#### 解决方法
- 检查服务是否启动
- 检查权限配置
- 检查接口定义
### 3. 服务性能问题
#### 问题原因
- 初始化耗时
- 业务逻辑复杂
- 资源占用高
#### 解决方法
- 优化初始化流程
- 优化业务逻辑
- 优化资源使用
## 最佳实践
### 1. 服务设计
- 接口设计清晰
- 职责单一
- 易于扩展
### 2. 权限管理
- 最小权限原则
- 严格权限检查
- 权限文档完善
### 3. 错误处理
- 完善的错误处理
- 详细的错误日志
- 异常恢复机制
### 4. 性能优化
- 避免阻塞主线程
- 优化资源使用
- 合理使用缓存
## 相关链接
- [[README]]
- [[01-系统启动流程/SystemServer核心服务]]
- [[05-进程与线程通信/AIDL与HIDL使用与原理]]
- [[07-系统安全/权限管理框架]]

BIN
docs/Obsidian笔记体系/Config/主题与样式.css
View File

Binary file not shown.

BIN
docs/Obsidian笔记体系/Config/插件列表与配置.md
View File

Binary file not shown.

BIN
docs/Obsidian笔记体系/Config/自定义脚本/源码链接生成器.py
View File

Binary file not shown.

BIN
docs/Obsidian笔记体系/Config/自定义脚本/自动生成日报.js
View File

Binary file not shown.

BIN
docs/Obsidian笔记体系/Daily/2024-06-01.md
View File

Binary file not shown.

BIN
docs/Obsidian笔记体系/Daily/2024-06-02.md
View File

Binary file not shown.

BIN
docs/Obsidian笔记体系/Daily/templates/每日模板.md
View File

Binary file not shown.

BIN
docs/Obsidian笔记体系/MOCs/Android Framework知识体系图.md
View File

Binary file not shown.

242
docs/Obsidian笔记体系/MOCs/技能提升路线图.md
View File

@@ -1 +1,243 @@
# 技能提升路线图
## 概述
本文档是Android Framework开发的技能提升路线图，帮助规划学习路径和技能提升计划。
## 技能等级
### Level 1: 初级 (0-1年)
**目标**: 理解Android系统基础，能够进行基础开发
**核心技能**:
- Android系统基础概念
- 基础开发能力
- 调试工具使用
**学习内容**:
1. **系统启动流程** [[01-系统启动流程/README]]
- 理解系统启动流程
- 了解各进程的作用
- 掌握基础调试方法
2. **Activity管理** [[02-Activity管理/README]]
- 理解Activity生命周期
- 掌握Activity启动流程
- 能够排查基础问题
3. **调试与工具链** [[09-调试与工具链/README]]
- 掌握ADB常用命令
- 能够查看和分析日志
- 使用基础调试工具
**实践项目**:
- 简单的系统定制
- 基础问题排查
- 日志分析
### Level 2: 中级 (1-3年)
**目标**: 深入理解Android系统机制，能够解决复杂问题
**核心技能**:
- 深入理解系统机制
- 性能优化能力
- 问题排查能力
**学习内容**:
1. **Window系统** [[03-Window系统/README]]
- 深入理解Window系统架构
- 掌握窗口管理机制
- 理解触摸事件传递
2. **进程与线程通信** [[05-进程与线程通信/README]]
- 深入理解Binder机制
- 掌握Handler机制
- 理解进程间通信
3. **资源与包管理** [[04-资源与包管理/README]]
- 理解包管理机制
- 掌握资源加载流程
- 理解动态加载原理
4. **性能优化体系** [[06-性能优化体系/README]]
- 掌握性能优化方法
- 能够使用性能分析工具
- 能够定位和解决性能问题
**实践项目**:
- 系统服务定制
- 性能优化项目
- 复杂问题排查
### Level 3: 高级 (3-5年)
**目标**: 精通Android系统，能够进行系统级优化和定制
**核心技能**:
- 系统架构设计能力
- 深度优化能力
- 系统定制能力
**学习内容**:
1. **系统安全** [[07-系统安全/README]]
- 深入理解安全机制
- 掌握权限管理
- 理解安全策略
2. **定制化开发** [[08-定制化开发/README]]
- 掌握系统定制方法
- 能够添加系统服务
- 能够定制系统功能
3. **内核相关** [[Resources/技术文章/内核相关文章]]
- 理解Linux内核基础
- 理解Android内核机制
- 能够进行内核调试
**实践项目**:
- 大型系统定制项目
- 性能优化专项
- 系统架构设计
### Level 4: 专家 (5年+)
**目标**: 成为Android系统专家，能够进行系统级创新
**核心技能**:
- 系统架构创新能力
- 技术领导能力
- 技术深度和广度
**学习内容**:
1. **前沿技术** [[Resources/论文/移动操作系统前沿]]
- 关注前沿技术发展
- 研究新技术应用
- 技术创新
2. **系统优化** [[Resources/论文/Android系统优化论文]]
- 深入研究系统优化
- 提出优化方案
- 推动技术改进
3. **技术领导**
- 技术方案设计
- 团队技术指导
- 技术决策
**实践项目**:
- 技术架构设计
- 技术方案制定
- 技术团队管理
## 学习路径
### 路径1: 系统理解路径
```
系统启动流程
↓
Activity管理
↓
Window系统
↓
进程与线程通信
↓
资源与包管理
```
### 路径2: 性能优化路径
```
调试与工具链
↓
性能优化体系
↓
系统优化实践
↓
性能优化专项
```
### 路径3: 系统定制路径
```
系统启动流程
↓
定制化开发
↓
系统服务定制
↓
系统定制项目
```
## 技能评估
### 评估维度
#### 1. 理论知识
- **Level 1**: 理解基础概念
- **Level 2**: 深入理解机制
- **Level 3**: 精通系统原理
- **Level 4**: 创新理论应用
#### 2. 实践能力
- **Level 1**: 能够完成基础任务
- **Level 2**: 能够解决复杂问题
- **Level 3**: 能够进行系统优化
- **Level 4**: 能够进行系统创新
#### 3. 问题解决
- **Level 1**: 能够排查基础问题
- **Level 2**: 能够解决复杂问题
- **Level 3**: 能够预防和优化问题
- **Level 4**: 能够创新解决方案
#### 4. 工具使用
- **Level 1**: 掌握基础工具
- **Level 2**: 熟练使用工具
- **Level 3**: 能够定制工具
- **Level 4**: 能够开发工具
## 学习资源
### 官方资源
- [[Resources/技术文章/官方文档笔记]]
- Android官方文档
- AOSP源码
### 技术博客
- [[Resources/技术文章/优质博客归档（Gityuan等）]]
- 知名技术博客
- 技术社区
### 学术论文
- [[Resources/论文/Android系统优化论文]]
- [[Resources/论文/移动操作系统前沿]]
- 顶级会议论文
### 工具资源
- [[Resources/工具/效率工具推荐]]
- [[Resources/工具/脚本库]]
- 开发工具
## 实践建议
### 1. 系统化学习
- 按照知识体系系统化学习
- 建立知识关联
- 定期回顾和总结
### 2. 实践结合
- 理论学习结合实践
- 通过项目加深理解
- 积累实践经验
### 3. 持续学习
- 关注技术发展
- 学习新技术
- 保持技术敏感度
### 4. 知识分享
- 技术分享
- 文档整理
- 团队协作
## 相关链接
- [[Android Framework知识体系图]]
- [[源码阅读地图]]
- [[高频问题索引]]

BIN
docs/Obsidian笔记体系/MOCs/源码阅读地图.md
View File

Binary file not shown.

BIN
docs/Obsidian笔记体系/MOCs/高频问题索引.md
View File

Binary file not shown.

69
docs/Obsidian笔记体系/Projects/项目A-系统定制化/README.md
View File

@@ -1 +1,70 @@
# 项目A-系统定制化
## 项目概述
本项目旨在对Android系统进行深度定制化开发，包括系统服务定制、UI定制、功能扩展等方面，以满足特定业务需求。
## 项目信息
- **项目名称**: 系统定制化项目
- **项目周期**: 2024-01-01 - 2024-06-30
- **项目负责人**:
- **项目状态**: 进行中/已完成
- **项目版本**: v1.0
## 项目目标
1. **系统服务定制**: 定制系统服务，满足特定业务需求
2. **UI定制**: 定制系统UI，提升用户体验
3. **功能扩展**: 扩展系统功能，增加新特性
4. **性能优化**: 优化系统性能，提升运行效率
## 项目范围
### 包含内容
- 系统服务定制
- 开机动画定制
- 系统属性定制
- 系统UI定制
### 不包含内容
- 内核修改
- 驱动开发
## 项目结构
```
项目A-系统定制化/
├── README.md # 项目概述
├── 需求与背景.md # 项目需求和背景
├── 技术方案设计.md # 技术方案设计
├── 测试与验证记录.md # 测试和验证记录
├── 复盘与总结.md # 项目复盘和总结
└── 关键问题记录/ # 关键问题记录
├── 2024-XX-XX-Service重启机制优化.md
└── 2024-XX-XX-开机动画卡顿调试.md
```
## 关键里程碑
| 里程碑 | 计划时间 | 实际时间 | 状态 |
|--------|----------|----------|------|
| 需求分析完成 | 2024-01-15 | 2024-01-15 | ✅ |
| 技术方案确定 | 2024-01-30 | 2024-02-01 | ✅ |
| 开发完成 | 2024-05-30 | - | 🔄 |
| 测试完成 | 2024-06-15 | - | ⏳ |
| 上线 | 2024-06-30 | - | ⏳ |
## 团队成员
- **项目经理**:
- **技术负责人**:
- **开发人员**:
- **测试人员**:
## 相关链接
- [[需求与背景]]
- [[技术方案设计]]
- [[测试与验证记录]]
- [[复盘与总结]]

123
docs/Obsidian笔记体系/Projects/项目A-系统定制化/关键问题记录/2024-XX-XX-Service重启机制优化.md
View File

@@ -1 +1,122 @@
# 2024-XX-XX-Service重启机制优化
# Service重启机制优化
## 基本信息
- **问题发现时间**: 2024-03-25
- **问题发现人**:
- **问题等级**: P1
- **问题状态**: 已解决
- **解决时间**: 2024-03-30
## 问题描述
### 现象
- Service在某些情况下无法正常重启
- 系统日志显示Service重启失败
- 影响系统功能正常使用
### 复现步骤
1. 启动系统
2. 触发Service重启条件
3. 观察Service重启行为
4. 发现Service重启失败
### 环境信息
- **系统版本**: 定制系统 v1.0
- **Android版本**: Android 10
- **设备型号**: 测试设备
## 问题分析
### 初步分析
- 可能是Service重启逻辑有问题
- 可能是系统资源不足
- 可能是权限问题
### 日志分析
```
[时间] E/ActivityManager: Service restart failed
[时间] E/SystemServer: Unable to restart service
```
### 根因分析
通过源码分析，发现Service重启机制存在以下问题：
1. **重启时机不当**: Service重启时机选择不当，可能导致资源竞争
2. **重启逻辑不完善**: 重启逻辑不够健壮，没有处理异常情况
3. **资源管理问题**: 重启时资源管理不当，可能导致资源泄漏
## 解决方案
### 方案设计
优化Service重启机制，包括：
1. 优化重启时机
2. 完善重启逻辑
3. 改进资源管理
### 代码修改
```java
// 修改前
public void restartService() {
stopService();
startService();
}
// 修改后
public void restartService() {
try {
// 停止Service
stopService();
// 等待资源释放
waitForResourceRelease();
// 检查资源状态
if (checkResourceStatus()) {
// 启动Service
startService();
} else {
// 处理资源问题
handleResourceIssue();
}
} catch (Exception e) {
// 异常处理
handleException(e);
}
}
```
## 实施过程
### 实施步骤
1. **代码修改**: 2024-03-26
2. **单元测试**: 2024-03-27
3. **集成测试**: 2024-03-28
4. **验证测试**: 2024-03-29
5. **问题解决**: 2024-03-30
### 测试验证
- **单元测试**: ✅ 通过
- **集成测试**: ✅ 通过
- **回归测试**: ✅ 通过
## 问题总结
### 根本原因
Service重启机制设计不够完善，没有充分考虑异常情况和资源管理。
### 解决方案
通过优化重启时机、完善重启逻辑、改进资源管理，解决了Service重启问题。
### 预防措施
1. 加强代码审查，确保重启逻辑完善
2. 增加异常处理和资源管理检查
3. 建立Service重启测试用例
### 经验教训
1. 系统服务设计需要考虑各种异常情况
2. 资源管理是系统服务的关键
3. 充分的测试可以发现潜在问题
## 相关链接
- [[技术方案设计]]
- [[测试与验证记录]]

132
docs/Obsidian笔记体系/Projects/项目A-系统定制化/关键问题记录/2024-XX-XX-开机动画卡顿调试.md
View File

@@ -1 +1,131 @@
# 2024-XX-XX-开机动画卡顿调试
# 开机动画卡顿调试
## 基本信息
- **问题发现时间**: 2024-04-02
- **问题发现人**:
- **问题等级**: P2
- **问题状态**: 已解决
- **解决时间**: 2024-04-10
## 问题描述
### 现象
- 开机动画在某些设备上播放卡顿
- 帧率不稳定，出现掉帧
- 影响用户体验
### 复现步骤
1. 重启设备
2. 观察开机动画播放
3. 发现动画卡顿现象
### 环境信息
- **系统版本**: 定制系统 v1.0
- **Android版本**: Android 10
- **设备型号**: 低端设备（内存2GB）
## 问题分析
### 初步分析
- 可能是动画资源过大
- 可能是加载性能问题
- 可能是设备性能不足
### 性能分析
使用Systrace分析开机动画性能：
```bash
python systrace.py -t 10 -o boot_animation.html gfx view sched
```
#### 分析结果
- **动画加载时间**: 500ms
- **播放帧率**: 30-40fps（不稳定）
- **CPU使用率**: 80%
- **内存占用**: 150MB
### 根因分析
通过性能分析，发现以下问题：
1. **资源过大**: 动画资源文件过大（50MB），加载耗时
2. **解码性能**: 图片解码在主线程，阻塞渲染
3. **内存压力**: 低端设备内存不足，导致GC频繁
## 解决方案
### 方案设计
优化开机动画性能，包括：
1. 优化动画资源
2. 优化加载流程
3. 优化播放性能
### 资源优化
- **压缩图片**: 将图片压缩到合适大小
- **减少帧数**: 减少动画帧数，保持流畅度
- **优化格式**: 使用更高效的图片格式
### 代码优化
```java
// 优化前
public void loadAnimation() {
// 在主线程加载
Bitmap bitmap = BitmapFactory.decodeFile(path);
// 直接使用
}
// 优化后
public void loadAnimation() {
// 在后台线程加载
new Thread(() -> {
Bitmap bitmap = BitmapFactory.decodeFile(path);
// 优化内存
bitmap = optimizeBitmap(bitmap);
// 切换到主线程使用
runOnUiThread(() -> {
useBitmap(bitmap);
});
}).start();
}
```
### 性能优化
- **预加载**: 提前加载动画资源
- **内存管理**: 优化内存使用，减少GC
- **渲染优化**: 优化渲染流程，提升帧率
## 实施过程
### 实施步骤
1. **资源优化**: 2024-04-03
2. **代码优化**: 2024-04-05
3. **性能测试**: 2024-04-07
4. **问题解决**: 2024-04-10
### 测试验证
- **性能测试**: ✅ 通过
- 加载时间: 从500ms降低到200ms
- 播放帧率: 从30-40fps提升到55-60fps
- CPU使用率: 从80%降低到50%
- **兼容性测试**: ✅ 通过
- **回归测试**: ✅ 通过
## 问题总结
### 根本原因
开机动画资源过大，加载和播放性能不足，在低端设备上表现更明显。
### 解决方案
通过优化资源、优化加载流程、优化播放性能，解决了开机动画卡顿问题。
### 预防措施
1. 建立性能测试流程，及时发现性能问题
2. 在低端设备上进行充分测试
3. 优化资源大小和加载流程
### 经验教训
1. 性能优化需要系统化分析
2. 低端设备的性能考虑很重要
3. 资源优化是性能优化的关键
## 相关链接
- [[技术方案设计]]
- [[测试与验证记录]]

144
docs/Obsidian笔记体系/Projects/项目A-系统定制化/复盘与总结.md
View File

@@ -1 +1,145 @@
# 复盘与总结
## 项目概述
项目A系统定制化项目历时6个月，完成了系统服务定制、开机动画定制、系统属性定制、UI定制等主要功能，基本达到预期目标。
## 项目完成情况
### 功能完成情况
- ✅ 系统服务定制: 100%完成
- ✅ 开机动画定制: 100%完成
- ✅ 系统属性定制: 100%完成
- ✅ 系统UI定制: 100%完成
### 性能指标达成情况
| 指标 | 目标值 | 实际值 | 达成情况 |
|------|--------|--------|----------|
| 系统启动时间 | < 30s | 28s | ✅ 达成 |
| 应用启动时间 | < 2s | 1.8s | ✅ 达成 |
| 系统流畅度 | 60fps | 58fps | ⚠️ 基本达成 |
| 系统稳定性 | > 99.9% | 99.95% | ✅ 达成 |
## 项目亮点
### 1. 技术亮点
- **系统服务定制**: 成功定制PackageManagerService和ActivityManagerService，扩展了系统功能
- **性能优化**: 通过优化启动流程和内存管理，提升了系统性能
- **稳定性保障**: 通过充分测试和问题修复，保证了系统稳定性
### 2. 过程亮点
- **需求管理**: 需求分析充分，变更控制良好
- **技术方案**: 技术方案设计合理，实施顺利
- **问题处理**: 问题响应及时，解决效率高
## 经验总结
### 成功经验
1. **充分的需求分析**
- 在项目开始前进行了充分的需求分析
- 明确了功能需求和非功能需求
- 为后续开发奠定了基础
2. **合理的技术方案**
- 技术方案设计合理，考虑了各种因素
- 方案实施顺利，没有大的技术风险
- 为项目成功提供了保障
3. **严格的测试流程**
- 建立了完善的测试流程
- 进行了充分的功能测试、性能测试、稳定性测试
- 及时发现问题并修复
4. **良好的团队协作**
- 团队成员协作良好
- 沟通及时有效
- 问题解决效率高
### 不足与改进
1. **进度管理**
- **问题**: 部分阶段进度略有延期
- **原因**: 对技术难度估计不足
- **改进**: 加强技术预研，更准确地评估工作量
2. **性能优化**
- **问题**: 系统流畅度略低于目标
- **原因**: 优化工作不够深入
- **改进**: 加强性能分析和优化
3. **文档管理**
- **问题**: 部分文档不够完善
- **原因**: 文档更新不及时
- **改进**: 建立文档更新机制
## 技术收获
### 1. 系统定制经验
- 深入理解了Android系统架构
- 掌握了系统服务定制方法
- 积累了系统定制经验
### 2. 性能优化经验
- 掌握了性能分析方法
- 积累了性能优化经验
- 建立了性能优化流程
### 3. 问题排查经验
- 掌握了系统问题排查方法
- 积累了问题解决经验
- 建立了问题处理流程
## 关键问题回顾
### 问题1: Service重启机制优化
- **问题描述**: Service重启机制存在问题
- **解决过程**: 通过深入分析源码，找到问题根因，优化了重启机制
- **经验总结**: 系统问题需要深入分析源码，理解系统机制
### 问题2: 开机动画卡顿
- **问题描述**: 开机动画在某些设备上卡顿
- **解决过程**: 通过性能分析，优化了动画加载和播放流程
- **经验总结**: 性能问题需要系统化分析，找到瓶颈点
## 后续计划
### 1. 持续优化
- 继续优化系统性能
- 提升系统流畅度
- 优化用户体验
### 2. 功能扩展
- 根据业务需求扩展功能
- 增加新的定制功能
- 提升系统能力
### 3. 技术沉淀
- 总结技术经验
- 形成技术文档
- 分享技术成果
## 项目数据
### 开发数据
- **代码量**: 约10万行
- **提交次数**: 500+次
- **代码审查**: 200+次
### 测试数据
- **测试用例**: 200+个
- **测试执行**: 1000+次
- **问题发现**: 50+个
- **问题修复**: 50+个
### 时间数据
- **计划时间**: 6个月
- **实际时间**: 6个月
- **延期情况**: 无重大延期
## 相关链接
- [[需求与背景]]
- [[技术方案设计]]
- [[测试与验证记录]]
- [[关键问题记录]]

186
docs/Obsidian笔记体系/Projects/项目A-系统定制化/技术方案设计.md
View File

@@ -1 +1,187 @@
# 技术方案设计
## 方案概述
本方案基于AOSP源码，通过定制系统服务、修改系统属性、定制UI等方式，实现系统定制化需求。
## 架构设计
### 整体架构
```
应用层
↓
Framework层 (定制)
↓
Native层
↓
Linux内核
```
### 模块划分
#### 1. 系统服务定制模块
- **PackageManagerService定制**: 扩展应用管理功能
- **ActivityManagerService定制**: 优化任务管理
- **自定义系统服务**: 新增业务相关服务
#### 2. 开机动画模块
- **动画资源管理**: 管理开机动画资源
- **动画播放控制**: 控制动画播放流程
- **性能优化**: 优化动画加载和播放性能
#### 3. 系统属性模块
- **属性定义**: 定义自定义系统属性
- **属性管理**: 管理系统属性的读写
- **配置管理**: 管理属性配置
#### 4. UI定制模块
- **主题定制**: 定制系统主题
- **资源替换**: 替换系统资源
- **布局优化**: 优化界面布局
## 详细设计
### 1. 系统服务定制
#### PackageManagerService定制
```java
// 扩展PackageManagerService
public class CustomPackageManagerService extends PackageManagerService {
// 增加应用管理功能
public void customAppManagement() {
// 实现逻辑
}
// 扩展权限管理
public void customPermissionManagement() {
// 实现逻辑
}
}
```
#### ActivityManagerService定制
```java
// 定制ActivityManagerService
public class CustomActivityManagerService extends ActivityManagerService {
// 优化任务管理
public void optimizeTaskManagement() {
// 实现逻辑
}
}
```
### 2. 开机动画定制
#### 动画资源
- 位置: `/system/media/bootanimation.zip`
- 格式: ZIP压缩包，包含图片序列
- 配置: `desc.txt` 描述文件
#### 播放控制
```java
// 开机动画播放控制
public class BootAnimationController {
public void playBootAnimation() {
// 播放逻辑
}
public void optimizePerformance() {
// 性能优化
}
}
```
### 3. 系统属性定制
#### 属性定义
```java
// 定义自定义系统属性
public class CustomSystemProperties {
// 自定义属性
public static final String CUSTOM_PROPERTY = "ro.custom.property";
// 设置属性
public static void setProperty(String key, String value) {
SystemProperties.set(key, value);
}
// 获取属性
public static String getProperty(String key) {
return SystemProperties.get(key);
}
}
```
### 4. UI定制
#### 主题定制
- 位置: `/system/framework/framework-res.apk`
- 资源: 颜色、样式、布局
- 方法: 替换资源文件
## 实施计划
### 阶段1: 基础定制 (2024-01-01 - 2024-02-28)
- 搭建开发环境
- 完成系统服务定制
- 完成系统属性定制
### 阶段2: UI定制 (2024-03-01 - 2024-04-30)
- 完成开机动画定制
- 完成系统UI定制
- 优化用户体验
### 阶段3: 测试优化 (2024-05-01 - 2024-06-15)
- 功能测试
- 性能测试
- 稳定性测试
- 问题修复
### 阶段4: 上线准备 (2024-06-16 - 2024-06-30)
- 文档整理
- 培训准备
- 上线部署
## 技术选型
### 开发环境
- **源码**: AOSP Android 10
- **编译工具**: Android Studio / Gradle
- **版本控制**: Git
### 开发工具
- **IDE**: Android Studio
- **调试工具**: ADB, Systrace, Perfetto
- **测试工具**: JUnit, Espresso
## 风险评估与应对
### 技术风险
- **风险**: 系统定制可能导致稳定性问题
- **应对**: 充分测试，逐步推进，保留回滚方案
### 兼容性风险
- **风险**: 可能影响第三方应用兼容性
- **应对**: 兼容性测试，及时修复问题
## 性能优化
### 启动优化
- 优化系统服务启动顺序
- 减少不必要的初始化
- 优化开机动画加载
### 内存优化
- 优化系统服务内存占用
- 减少资源占用
- 优化GC策略
## 相关链接
- [[需求与背景]]
- [[测试与验证记录]]
- [[关键问题记录/2024-XX-XX-Service重启机制优化]]

183
docs/Obsidian笔记体系/Projects/项目A-系统定制化/测试与验证记录.md
View File

@@ -1 +1,184 @@
# 测试与验证记录
## 测试概述
本文档记录项目A系统定制化的测试和验证过程，包括功能测试、性能测试、稳定性测试等。
## 测试环境
### 硬件环境
- **测试设备**: 10台不同配置的Android设备
- **设备型号**: 覆盖主流品牌和型号
- **Android版本**: Android 10
### 软件环境
- **系统版本**: 定制系统 v1.0
- **测试工具**: ADB, Systrace, Perfetto
- **测试框架**: JUnit, Espresso
## 功能测试
### 1. 系统服务定制测试
#### 测试用例1: PackageManagerService定制功能
- **测试时间**: 2024-03-15
- **测试人员**:
- **测试结果**: ✅ 通过
- **测试步骤**:
1. 安装测试应用
2. 验证应用管理功能
3. 验证权限管理功能
- **问题记录**: 无
#### 测试用例2: ActivityManagerService定制功能
- **测试时间**: 2024-03-16
- **测试人员**:
- **测试结果**: ✅ 通过
- **测试步骤**:
1. 启动多个应用
2. 验证任务管理功能
3. 验证任务切换功能
- **问题记录**: 无
### 2. 开机动画测试
#### 测试用例1: 开机动画播放
- **测试时间**: 2024-04-01
- **测试人员**:
- **测试结果**: ✅ 通过
- **测试步骤**:
1. 重启设备
2. 观察开机动画
3. 验证动画播放流畅度
- **问题记录**: 无
#### 测试用例2: 开机动画性能
- **测试时间**: 2024-04-02
- **测试人员**:
- **测试结果**: ⚠️ 部分通过
- **测试步骤**:
1. 测量开机动画加载时间
2. 测量动画播放帧率
3. 分析性能数据
- **问题记录**:
- 问题: 开机动画在某些设备上卡顿
- 状态: 已修复
- 修复记录: [[关键问题记录/2024-XX-XX-开机动画卡顿调试]]
### 3. 系统属性测试
#### 测试用例1: 自定义系统属性
- **测试时间**: 2024-03-20
- **测试人员**:
- **测试结果**: ✅ 通过
- **测试步骤**:
1. 设置自定义属性
2. 读取属性值
3. 验证属性持久化
- **问题记录**: 无
## 性能测试
### 1. 启动性能测试
#### 测试结果
| 指标 | 目标值 | 实际值 | 状态 |
|------|--------|--------|------|
| 系统启动时间 | < 30s | 28s | ✅ |
| 应用启动时间 | < 2s | 1.8s | ✅ |
| 首帧渲染时间 | < 1s | 0.9s | ✅ |
#### 测试时间
- **测试时间**: 2024-05-10
- **测试人员**:
- **测试设备**: 5台设备
- **测试方法**: 使用Systrace分析
### 2. 内存性能测试
#### 测试结果
| 指标 | 目标值 | 实际值 | 状态 |
|------|--------|--------|------|
| 系统内存占用 | < 2GB | 1.8GB | ✅ |
| 应用内存占用 | < 500MB | 450MB | ✅ |
| GC频率 | 正常 | 正常 | ✅ |
#### 测试时间
- **测试时间**: 2024-05-15
- **测试人员**:
- **测试方法**: 使用Android Profiler
### 3. 流畅度测试
#### 测试结果
| 指标 | 目标值 | 实际值 | 状态 |
|------|--------|--------|------|
| 平均FPS | 60fps | 58fps | ⚠️ |
| 掉帧率 | < 1% | 1.2% | ⚠️ |
| ANR率 | < 0.1% | 0.08% | ✅ |
#### 测试时间
- **测试时间**: 2024-05-20
- **测试人员**:
- **测试方法**: 使用GPU Rendering Profile
## 稳定性测试
### 1. 压力测试
#### 测试场景
- 连续运行24小时
- 频繁启动应用
- 多任务切换
#### 测试结果
- **测试时间**: 2024-05-25
- **测试时长**: 24小时
- **崩溃次数**: 0
- **ANR次数**: 1
- **结果**: ✅ 通过
### 2. 兼容性测试
#### 测试应用
- 主流应用: 微信、支付宝、淘宝等
- 测试数量: 50个应用
#### 测试结果
- **测试时间**: 2024-06-01
- **兼容应用数**: 48个
- **不兼容应用数**: 2个
- **兼容率**: 96%
- **结果**: ✅ 通过
## 问题记录
### 问题1: 开机动画卡顿
- **发现时间**: 2024-04-02
- **严重程度**: 中
- **状态**: 已修复
- **详细记录**: [[关键问题记录/2024-XX-XX-开机动画卡顿调试]]
### 问题2: Service重启机制问题
- **发现时间**: 2024-03-25
- **严重程度**: 高
- **状态**: 已修复
- **详细记录**: [[关键问题记录/2024-XX-XX-Service重启机制优化]]
## 测试总结
### 测试完成情况
- **功能测试**: 100%完成
- **性能测试**: 100%完成
- **稳定性测试**: 100%完成
- **兼容性测试**: 100%完成
### 测试结果
- **总体结果**: ✅ 通过
- **主要问题**: 已全部修复
- **性能指标**: 基本达标
## 相关链接
- [[技术方案设计]]
- [[复盘与总结]]

109
docs/Obsidian笔记体系/Projects/项目A-系统定制化/需求与背景.md
View File

@@ -1 +1,110 @@
# 需求与背景
## 项目背景
### 业务背景
- 公司需要定制Android系统以满足特定业务需求
- 现有系统无法满足新的业务场景
- 需要提供差异化的系统体验
### 技术背景
- Android系统开放性强，支持深度定制
- 团队具备Android Framework开发经验
- 有完整的开发和测试环境
## 需求分析
### 功能需求
#### 1. 系统服务定制
- **需求描述**: 需要定制系统服务，增加特定功能
- **优先级**: 高
- **详细需求**:
- 定制PackageManagerService，增加应用管理功能
- 定制ActivityManagerService，优化任务管理
- 增加自定义系统服务
#### 2. 开机动画定制
- **需求描述**: 定制开机动画，展示品牌形象
- **优先级**: 中
- **详细需求**:
- 替换默认开机动画
- 支持自定义动画效果
- 优化动画加载性能
#### 3. 系统属性定制
- **需求描述**: 定制系统属性，满足配置需求
- **优先级**: 中
- **详细需求**:
- 增加自定义系统属性
- 修改默认系统属性值
- 支持动态配置
#### 4. 系统UI定制
- **需求描述**: 定制系统UI，提升用户体验
- **优先级**: 低
- **详细需求**:
- 定制系统主题
- 修改系统图标
- 优化界面布局
### 非功能需求
#### 性能要求
- 系统启动时间: < 30秒
- 应用启动时间: < 2秒
- 系统流畅度: 60fps
#### 稳定性要求
- 系统崩溃率: < 0.1%
- 应用ANR率: < 0.1%
- 系统可用性: > 99.9%
#### 兼容性要求
- 支持Android 10+
- 兼容主流应用
- 支持OTA升级
## 约束条件
### 技术约束
- 基于AOSP源码开发
- 不能修改内核
- 需要保持系统稳定性
### 时间约束
- 项目周期: 6个月
- 关键节点不能延期
### 资源约束
- 开发人员: 5人
- 测试设备: 10台
- 预算限制
## 风险评估
### 技术风险
- **风险1**: 系统定制可能导致稳定性问题
- 影响: 高
- 应对措施: 充分测试，逐步推进
- **风险2**: 兼容性问题
- 影响: 中
- 应对措施: 兼容性测试，及时修复
### 进度风险
- **风险1**: 开发进度延期
- 影响: 中
- 应对措施: 合理排期，及时调整
## 成功标准
1. 所有功能需求完成
2. 性能指标达标
3. 稳定性指标达标
4. 通过验收测试
## 相关链接
- [[README]]
- [[技术方案设计]]

66
docs/Obsidian笔记体系/Projects/项目B-性能优化专项/README.md
View File

@@ -1 +1,67 @@
# 项目B-性能优化专项
## 项目概述
本项目专注于Android系统性能优化，包括启动优化、内存优化、流畅度优化、功耗优化等方面，目标是全面提升系统性能。
## 项目信息
- **项目名称**: 性能优化专项
- **项目周期**: 2024-01-01 - 2024-12-31
- **项目负责人**:
- **项目状态**: 进行中
- **项目版本**: v1.0
## 项目目标
1. **启动优化**: 系统启动时间降低30%
2. **内存优化**: 内存占用降低20%
3. **流畅度优化**: 帧率稳定在60fps
4. **功耗优化**: 功耗降低15%
## 项目范围
### 优化内容
- 系统启动优化
- 应用启动优化
- 内存管理优化
- 流畅度优化
- 功耗优化
### 工具支持
- 性能分析工具配置
- 性能监控体系建立
- 自动化测试工具
## 项目结构
```
项目B-性能优化专项/
├── README.md # 项目概述
├── 目标与指标.md # 优化目标和指标
├── 工具链配置（Perfetto+Systrace）.md # 工具链配置
└── 问题追踪列表.md # 问题追踪列表
```
## 关键里程碑
| 里程碑 | 计划时间 | 实际时间 | 状态 |
|--------|----------|----------|------|
| 目标确定 | 2024-01-15 | 2024-01-15 | ✅ |
| 工具链配置 | 2024-02-01 | 2024-02-05 | ✅ |
| 启动优化完成 | 2024-06-30 | - | 🔄 |
| 内存优化完成 | 2024-09-30 | - | ⏳ |
| 流畅度优化完成 | 2024-11-30 | - | ⏳ |
| 功耗优化完成 | 2024-12-31 | - | ⏳ |
## 团队成员
- **项目负责人**:
- **性能优化工程师**:
- **测试工程师**:
## 相关链接
- [[目标与指标]]
- [[工具链配置（Perfetto+Systrace）]]
- [[问题追踪列表]]

213
docs/Obsidian笔记体系/Projects/项目B-性能优化专项/工具链配置（Perfetto+Systrace）.md
View File

@@ -1 +1,214 @@
# 工具链配置（Perfetto+Systrace）
## 工具概述
本项目使用Perfetto和Systrace作为主要的性能分析工具，用于分析系统性能、定位性能瓶颈。
## Perfetto配置
### 安装配置
#### 1. 环境准备
```bash
# 检查Python版本
python --version # 需要Python 3.6+
# 安装依赖
pip install protobuf
```
#### 2. Perfetto工具获取
- **Android Studio**: 内置Perfetto支持
- **命令行工具**: 从AOSP获取
- **Web UI**: https://ui.perfetto.dev/
### 配置文件
#### 基础配置
```protobuf
buffers: {
size_kb: 63488
fill_policy: DISCARD
}
data_sources: {
config {
name: "android.surfaceflinger.frame"
}
}
data_sources: {
config {
name: "linux.ftrace"
ftrace_config {
ftrace_events: "sched/sched_switch"
ftrace_events: "sched/sched_waking"
ftrace_events: "power/suspend_resume"
ftrace_events: "power/cpu_frequency"
ftrace_events: "power/cpu_idle"
ftrace_events: "gfx/mali_gpu_total"
buffer_size_kb: 2048
drain_period_ms: 250
}
}
}
duration_ms: 10000
```
#### 启动分析配置
```protobuf
buffers: {
size_kb: 63488
}
data_sources: {
config {
name: "linux.ftrace"
ftrace_config {
ftrace_events: "sched/sched_switch"
ftrace_events: "sched/sched_waking"
ftrace_events: "android/android_fs_datawrite_start"
ftrace_events: "android/android_fs_dataread_start"
atrace_categories: "am"
atrace_categories: "wm"
atrace_categories: "gfx"
atrace_categories: "view"
buffer_size_kb: 4096
}
}
}
duration_ms: 5000
```
### 使用方法
#### 1. 录制Trace
```bash
# 使用配置文件录制
adb shell perfetto -c /data/local/tmp/config.pb -o /data/local/tmp/trace.pb
# 或使用简写
adb shell perfetto -c - --out /data/misc/perfetto-traces/trace
```
#### 2. 拉取Trace文件
```bash
adb pull /data/local/tmp/trace.pb trace.pb
```
#### 3. 分析Trace
- 在 https://ui.perfetto.dev/ 打开trace文件
- 或使用Android Studio打开
## Systrace配置
### 安装配置
#### 1. 环境准备
```bash
# Systrace位于Android SDK
# 路径: $ANDROID_SDK/platform-tools/systrace/
```
#### 2. Python环境
```bash
# 需要Python 2.7或Python 3.6+
python --version
```
### 使用方法
#### 1. 基础用法
```bash
python systrace.py -t 10 -o trace.html sched gfx view
```
#### 2. 启动分析
```bash
python systrace.py -t 5 -a com.example.app \
-o startup.html \
sched freq idle am wm gfx view binder_driver hal dalvik camera input res
```
#### 3. 流畅度分析
```bash
python systrace.py -t 10 \
-o jank.html \
gfx view sched freq idle
```
#### 4. 内存分析
```bash
python systrace.py -t 10 \
-o memory.html \
sched freq idle mem
```
### 常用参数
- `-t`: 追踪时间（秒）
- `-o`: 输出文件
- `-a`: 指定应用包名
- `-b`: 缓冲区大小（KB）
## 工具使用规范
### 1. 性能分析流程
1. **确定分析目标**: 明确要分析的性能问题
2. **选择工具**: 根据问题选择Perfetto或Systrace
3. **录制Trace**: 执行操作并录制Trace
4. **分析Trace**: 分析Trace文件，定位问题
5. **优化验证**: 优化后再次录制验证
### 2. Trace文件管理
- **命名规范**: `[类型]_[时间]_[描述].pb/html`
- **存储位置**: `traces/` 目录
- **版本控制**: 重要Trace文件纳入版本控制
### 3. 分析报告
- 每次分析后记录分析结果
- 记录发现的问题和优化建议
- 跟踪优化效果
## 自动化脚本
### 启动性能分析脚本
```bash
#!/bin/bash
# analyze_startup.sh
APP_PACKAGE=$1
OUTPUT_DIR="traces/startup_$(date +%Y%m%d_%H%M%S)"
mkdir -p $OUTPUT_DIR
# 录制启动Trace
python systrace.py -t 5 -a $APP_PACKAGE \
-o $OUTPUT_DIR/startup.html \
sched freq idle am wm gfx view
echo "Trace saved to $OUTPUT_DIR/startup.html"
```
### 流畅度分析脚本
```bash
#!/bin/bash
# analyze_jank.sh
OUTPUT_DIR="traces/jank_$(date +%Y%m%d_%H%M%S)"
mkdir -p $OUTPUT_DIR
# 录制流畅度Trace
python systrace.py -t 10 \
-o $OUTPUT_DIR/jank.html \
gfx view sched freq idle
echo "Trace saved to $OUTPUT_DIR/jank.html"
```
## 相关链接
- [[目标与指标]]
- [[问题追踪列表]]
- [[09-调试与工具链/Systrace_Perfetto全解读]]

147
docs/Obsidian笔记体系/Projects/项目B-性能优化专项/目标与指标.md
View File

@@ -1 +1,148 @@
# 目标与指标
## 优化目标
### 总体目标
全面提升Android系统性能，包括启动速度、内存使用、流畅度、功耗等方面，达到行业领先水平。
## 具体指标
### 1. 启动性能
#### 系统启动
- **当前值**: 45秒
- **目标值**: 30秒
- **优化幅度**: 33%
#### 应用启动
- **当前值**: 3秒
- **目标值**: 2秒
- **优化幅度**: 33%
#### 首帧渲染
- **当前值**: 1.5秒
- **目标值**: 1秒
- **优化幅度**: 33%
### 2. 内存性能
#### 系统内存占用
- **当前值**: 2.5GB
- **目标值**: 2GB
- **优化幅度**: 20%
#### 应用内存占用
- **当前值**: 600MB
- **目标值**: 480MB
- **优化幅度**: 20%
#### GC频率
- **当前值**: 正常
- **目标值**: 减少20%
- **优化幅度**: 20%
### 3. 流畅度
#### 平均FPS
- **当前值**: 55fps
- **目标值**: 60fps
- **优化幅度**: 9%
#### 掉帧率
- **当前值**: 2%
- **目标值**: < 1%
- **优化幅度**: 50%
#### ANR率
- **当前值**: 0.2%
- **目标值**: < 0.1%
- **优化幅度**: 50%
### 4. 功耗
#### 待机功耗
- **当前值**: 8mA
- **目标值**: 6.8mA
- **优化幅度**: 15%
#### 使用功耗
- **当前值**: 500mA
- **目标值**: 425mA
- **优化幅度**: 15%
#### 后台功耗
- **当前值**: 20mA
- **目标值**: 17mA
- **优化幅度**: 15%
## 测量方法
### 启动性能测量
- 使用adb命令测量启动时间
- 使用Systrace/Perfetto分析启动流程
- 代码埋点测量关键时间点
### 内存性能测量
- 使用Android Profiler监控内存
- 使用dumpsys meminfo获取内存信息
- 使用LeakCanary检测内存泄漏
### 流畅度测量
- 使用GPU Rendering Profile
- 使用Choreographer监控帧率
- 使用Systrace分析渲染流程
### 功耗测量
- 使用Battery Historian分析功耗
- 使用Android Profiler Energy标签
- 使用dumpsys batterystats
## 基准测试
### 测试环境
- **测试设备**: 10台不同配置的设备
- **测试应用**: 主流应用50个
- **测试场景**: 正常使用场景
### 基准数据
- **测试时间**: 2024-01-01
- **测试结果**: 已记录
- **数据位置**: 性能数据库
## 目标达成计划
### 阶段1: 启动优化 (2024-01-01 - 2024-06-30)
- 系统启动优化
- 应用启动优化
- 首帧渲染优化
### 阶段2: 内存优化 (2024-07-01 - 2024-09-30)
- 内存占用优化
- 内存泄漏修复
- GC优化
### 阶段3: 流畅度优化 (2024-10-01 - 2024-11-30)
- 渲染优化
- 主线程优化
- 动画优化
### 阶段4: 功耗优化 (2024-12-01 - 2024-12-31)
- 功耗分析
- 功耗优化
- 验证测试
## 风险与应对
### 风险1: 优化效果不达预期
- **应对**: 深入分析瓶颈，调整优化策略
### 风险2: 优化影响稳定性
- **应对**: 充分测试，逐步优化
### 风险3: 优化影响功能
- **应对**: 功能回归测试，确保功能正常
## 相关链接
- [[README]]
- [[工具链配置（Perfetto+Systrace）]]

99
docs/Obsidian笔记体系/Projects/项目B-性能优化专项/问题追踪列表.md
View File

@@ -1 +1,100 @@
# 问题追踪列表
## 问题列表
### 问题1: 系统启动时间过长
- **发现时间**: 2024-01-20
- **问题等级**: P1
- **状态**: 处理中
- **负责人**:
- **描述**: 系统启动时间45秒，超过目标值30秒
- **分析**:
- Application初始化耗时过长
- 系统服务启动顺序不合理
- **解决方案**:
- 优化Application初始化
- 调整系统服务启动顺序
- **进度**: 50%
### 问题2: 应用启动时间过长
- **发现时间**: 2024-02-01
- **问题等级**: P1
- **状态**: 处理中
- **负责人**:
- **描述**: 应用启动时间3秒，超过目标值2秒
- **分析**:
- 布局inflate耗时
- 主线程加载数据
- **解决方案**:
- 优化布局层级
- 异步加载数据
- **进度**: 60%
### 问题3: 内存占用过高
- **发现时间**: 2024-07-10
- **问题等级**: P1
- **状态**: 待处理
- **负责人**:
- **描述**: 系统内存占用2.5GB，超过目标值2GB
- **分析**:
- 系统服务内存占用高
- 存在内存泄漏
- **解决方案**:
- 优化系统服务内存占用
- 修复内存泄漏
- **进度**: 0%
### 问题4: 流畅度不足
- **发现时间**: 2024-10-05
- **问题等级**: P1
- **状态**: 待处理
- **负责人**:
- **描述**: 平均FPS 55fps，低于目标值60fps
- **分析**:
- 主线程阻塞
- 渲染性能不足
- **解决方案**:
- 优化主线程
- 优化渲染流程
- **进度**: 0%
### 问题5: 功耗过高
- **发现时间**: 2024-12-01
- **问题等级**: P2
- **状态**: 待处理
- **负责人**:
- **描述**: 待机功耗8mA，超过目标值6.8mA
- **分析**:
- 后台任务过多
- Wake Lock使用不当
- **解决方案**:
- 优化后台任务
- 优化Wake Lock使用
- **进度**: 0%
## 问题统计
### 按状态统计
- **待处理**: 3个
- **处理中**: 2个
- **已解决**: 0个
- **已关闭**: 0个
### 按等级统计
- **P0**: 0个
- **P1**: 4个
- **P2**: 1个
- **P3**: 0个
## 问题处理流程
1. **问题发现**: 通过测试或监控发现性能问题
2. **问题分析**: 分析问题根因，确定优化方案
3. **方案实施**: 实施优化方案
4. **测试验证**: 验证优化效果
5. **问题关闭**: 确认问题解决后关闭
## 相关链接
- [[目标与指标]]
- [[工具链配置（Perfetto+Systrace）]]

61
docs/Obsidian笔记体系/Projects/项目C-XX模块重构/README.md
View File

@@ -1 +1,62 @@
# 项目C-XX模块重构
## 项目概述
本项目旨在重构XX模块，提升代码质量、可维护性和性能，采用新的架构设计，优化模块结构。
## 项目信息
- **项目名称**: XX模块重构
- **项目周期**: 2024-01-01 - 2024-09-30
- **项目负责人**:
- **项目状态**: 规划中
- **项目版本**: v1.0
## 项目目标
1. **代码质量**: 提升代码质量，减少技术债务
2. **可维护性**: 提升代码可维护性，便于后续开发
3. **性能优化**: 优化模块性能，提升运行效率
4. **架构优化**: 采用新架构，提升系统扩展性
## 项目范围
### 重构内容
- 模块架构重构
- 代码重构
- 接口优化
- 性能优化
### 不包含内容
- 功能新增
- 业务逻辑变更
## 项目结构
```
项目C-XX模块重构/
├── README.md # 项目概述
├── 架构设计.md # 新架构设计
└── 迁移计划.md # 迁移计划
```
## 关键里程碑
| 里程碑 | 计划时间 | 实际时间 | 状态 |
|--------|----------|----------|------|
| 架构设计完成 | 2024-02-28 | - | ⏳ |
| 开发完成 | 2024-07-31 | - | ⏳ |
| 测试完成 | 2024-08-31 | - | ⏳ |
| 上线 | 2024-09-30 | - | ⏳ |
## 团队成员
- **项目负责人**:
- **架构师**:
- **开发人员**:
- **测试人员**:
## 相关链接
- [[架构设计]]
- [[迁移计划]]

210
docs/Obsidian笔记体系/Projects/项目C-XX模块重构/架构设计.md
View File

@@ -1 +1,211 @@
# 架构设计
## 设计概述
本文档描述XX模块重构的架构设计，包括新架构设计、模块划分、接口设计等。
## 现状分析
### 当前架构问题
1. **代码耦合度高**: 模块间耦合严重，难以维护
2. **扩展性差**: 难以扩展新功能
3. **性能问题**: 存在性能瓶颈
4. **技术债务**: 代码质量不高，技术债务多
### 重构目标
1. **降低耦合**: 模块间低耦合，高内聚
2. **提升扩展性**: 易于扩展新功能
3. **优化性能**: 解决性能问题
4. **提升质量**: 提升代码质量
## 新架构设计
### 整体架构
```
应用层
↓
接口层 (新)
↓
业务逻辑层 (重构)
↓
数据访问层 (重构)
↓
存储层
```
### 架构原则
1. **分层架构**: 清晰的分层结构
2. **接口隔离**: 接口设计清晰，职责单一
3. **依赖注入**: 使用依赖注入降低耦合
4. **单一职责**: 每个模块职责单一
## 模块划分
### 1. 接口层
- **职责**: 提供对外接口
- **设计**: RESTful API / RPC接口
- **技术**:
### 2. 业务逻辑层
- **职责**: 实现业务逻辑
- **设计**: 服务化设计
- **技术**:
### 3. 数据访问层
- **职责**: 数据访问和持久化
- **设计**: Repository模式
- **技术**:
### 4. 存储层
- **职责**: 数据存储
- **设计**: 数据库/文件系统
- **技术**:
## 详细设计
### 接口设计
#### RESTful API设计
```java
// 接口定义
@RestController
@RequestMapping("/api/v1/xx")
public class XXController {
@GetMapping("/{id}")
public ResponseEntity<XXDTO> getXX(@PathVariable String id) {
// 实现
}
@PostMapping
public ResponseEntity<XXDTO> createXX(@RequestBody XXDTO dto) {
// 实现
}
}
```
#### 接口规范
- **版本管理**: 使用URL版本控制
- **错误处理**: 统一的错误响应格式
- **认证授权**: 统一的认证授权机制
### 业务逻辑设计
#### 服务设计
```java
// 服务接口
public interface XXService {
XXDTO getXX(String id);
XXDTO createXX(XXDTO dto);
void updateXX(String id, XXDTO dto);
void deleteXX(String id);
}
// 服务实现
@Service
public class XXServiceImpl implements XXService {
// 实现
}
```
#### 业务规则
- 规则1: 描述
- 规则2: 描述
### 数据访问设计
#### Repository设计
```java
// Repository接口
public interface XXRepository {
XXEntity findById(String id);
void save(XXEntity entity);
void delete(String id);
}
// Repository实现
@Repository
public class XXRepositoryImpl implements XXRepository {
// 实现
}
```
### 数据模型设计
#### 实体设计
```java
@Entity
public class XXEntity {
@Id
private String id;
private String name;
// 其他字段
}
```
#### 数据库设计
- **表结构**:
- **索引设计**:
- **关系设计**:
## 技术选型
### 框架选择
- **Web框架**:
- **ORM框架**:
- **消息队列**:
- **缓存**:
### 技术栈
- **语言**: Java/Kotlin
- **构建工具**: Gradle
- **版本控制**: Git
## 性能优化
### 优化策略
1. **缓存优化**: 使用缓存减少数据库访问
2. **异步处理**: 异步处理耗时操作
3. **数据库优化**: 优化数据库查询和索引
### 性能指标
- **响应时间**: < 100ms
- **吞吐量**: > 1000 QPS
- **并发数**: > 1000
## 安全设计
### 安全措施
1. **认证授权**: 统一的认证授权机制
2. **数据加密**: 敏感数据加密存储
3. **输入验证**: 输入数据验证和过滤
## 可维护性
### 代码规范
- 遵循团队代码规范
- 使用代码检查工具
- 代码审查机制
### 文档要求
- API文档
- 架构文档
- 开发文档
## 迁移策略
### 迁移方式
- **渐进式迁移**: 逐步迁移，降低风险
- **双写策略**: 新旧系统并行运行
- **数据迁移**: 数据平滑迁移
### 迁移步骤
1. 新架构开发
2. 并行运行
3. 逐步切换
4. 旧系统下线
## 相关链接
- [[README]]
- [[迁移计划]]

142
docs/Obsidian笔记体系/Projects/项目C-XX模块重构/迁移计划.md
View File

@@ -1 +1,143 @@
# 迁移计划
## 计划概述
本文档描述XX模块重构的迁移计划，包括迁移策略、迁移步骤、风险控制等。
## 迁移目标
1. **平滑迁移**: 不影响现有功能
2. **数据完整**: 保证数据完整性
3. **性能不降**: 迁移后性能不降低
4. **快速回滚**: 支持快速回滚
## 迁移策略
### 策略选择
采用**渐进式迁移**策略：
- 新旧系统并行运行
- 逐步切换流量
- 验证无误后完全切换
### 迁移方式
1. **双写策略**: 新旧系统同时写入
2. **读切换**: 逐步切换读请求
3. **写切换**: 逐步切换写请求
4. **完全切换**: 完全切换到新系统
## 迁移步骤
### 阶段1: 准备阶段 (2024-01-01 - 2024-02-28)
#### 1.1 环境准备
- **新环境搭建**: 搭建新系统运行环境
- **数据准备**: 准备测试数据
- **工具准备**: 准备迁移工具
#### 1.2 开发完成
- **新系统开发**: 完成新系统开发
- **单元测试**: 完成单元测试
- **集成测试**: 完成集成测试
### 阶段2: 并行运行阶段 (2024-03-01 - 2024-06-30)
#### 2.1 双写启动
- **启动双写**: 启动新旧系统双写
- **数据对比**: 对比新旧系统数据
- **问题修复**: 修复发现的问题
#### 2.2 读切换
- **10%流量**: 切换10%读流量到新系统
- **50%流量**: 切换50%读流量到新系统
- **100%流量**: 切换100%读流量到新系统
### 阶段3: 写切换阶段 (2024-07-01 - 2024-08-31)
#### 3.1 写切换
- **10%流量**: 切换10%写流量到新系统
- **50%流量**: 切换50%写流量到新系统
- **100%流量**: 切换100%写流量到新系统
#### 3.2 验证
- **功能验证**: 验证功能正常
- **性能验证**: 验证性能正常
- **数据验证**: 验证数据完整
### 阶段4: 完全切换阶段 (2024-09-01 - 2024-09-30)
#### 4.1 完全切换
- **停止双写**: 停止旧系统写入
- **完全切换**: 完全切换到新系统
- **监控**: 持续监控系统状态
#### 4.2 旧系统下线
- **数据迁移**: 迁移剩余数据
- **旧系统下线**: 下线旧系统
- **清理**: 清理旧系统资源
## 数据迁移
### 迁移方案
1. **全量迁移**: 迁移历史数据
2. **增量迁移**: 迁移增量数据
3. **数据校验**: 校验数据完整性
### 迁移工具
- **迁移脚本**: 自动化迁移脚本
- **数据校验工具**: 数据校验工具
- **回滚工具**: 数据回滚工具
## 风险控制
### 风险识别
1. **数据丢失风险**: 迁移过程中数据丢失
2. **性能下降风险**: 迁移后性能下降
3. **功能异常风险**: 迁移后功能异常
4. **回滚风险**: 无法快速回滚
### 应对措施
1. **数据备份**: 迁移前完整备份数据
2. **性能测试**: 迁移前充分性能测试
3. **功能测试**: 迁移前充分功能测试
4. **回滚方案**: 准备完整的回滚方案
## 回滚方案
### 回滚条件
- 数据丢失
- 性能严重下降
- 功能异常
- 其他严重问题
### 回滚步骤
1. **停止新系统**: 停止新系统运行
2. **恢复旧系统**: 恢复旧系统运行
3. **数据恢复**: 恢复数据到旧系统
4. **问题分析**: 分析问题原因
## 监控与告警
### 监控指标
- **功能指标**: 功能正常率
- **性能指标**: 响应时间、吞吐量
- **数据指标**: 数据完整性
- **系统指标**: CPU、内存、网络
### 告警规则
- **功能告警**: 功能异常时告警
- **性能告警**: 性能下降时告警
- **数据告警**: 数据异常时告警
## 时间计划
| 阶段 | 开始时间 | 结束时间 | 负责人 |
|------|----------|----------|--------|
| 准备阶段 | 2024-01-01 | 2024-02-28 | |
| 并行运行阶段 | 2024-03-01 | 2024-06-30 | |
| 写切换阶段 | 2024-07-01 | 2024-08-31 | |
| 完全切换阶段 | 2024-09-01 | 2024-09-30 | |
## 相关链接
- [[README]]
- [[架构设计]]

115
docs/Obsidian笔记体系/Resources/会议与分享/Android开发者峰会笔记/Google_IO_2024_性能优化.md Normal file
View File

@@ -0,0 +1,115 @@
# Google I/O 2024 - Android性能优化新特性
## 基本信息
- **会议**: Google I/O 2024
- **时间**: 2024-05-14
- **主讲人**: Android Performance Team
- **主题**: Android Performance Optimization - What's New
## 核心内容
### 1. Perfetto增强功能
#### 长时间追踪支持
- 支持追踪数小时甚至数天的性能数据
- 新的数据压缩算法，减少存储空间
- 改进的UI，支持更好的数据可视化
#### 新的性能指标
- **Frame Pacing**: 帧间隔分析
- **Memory Pressure**: 内存压力指标
- **CPU Throttling**: CPU降频检测
#### SQL查询增强
- 支持更复杂的查询
- 性能优化，查询速度提升
- 新的聚合函数
### 2. 系统优化新特性
#### 启动优化
- **App Startup库增强**
- 支持依赖关系管理
- 自动优化初始化顺序
- 新的延迟初始化策略
- **Splash Screen API改进**
- 更好的启动画面体验
- 支持动画效果
- 减少白屏时间
#### 内存管理
- **新的GC策略**
- 更智能的GC触发时机
- 减少GC暂停时间
- 改进的内存分配算法
- **内存分析工具增强**
- 实时内存监控
- 内存泄漏自动检测
- 内存使用趋势分析
#### 功耗优化
- **新的Doze模式策略**
- 更智能的后台任务管理
- 减少不必要的唤醒
- 改进的电池使用统计
### 3. 开发工具更新
#### Android Studio新特性
- **Profiler增强**
- 实时性能监控
- 新的性能指标
- 改进的数据可视化
- **Layout Inspector改进**
- 3D视图支持
- 更好的布局分析
- 性能问题自动检测
#### 新的调试工具
- **Native Memory Profiler**
- Native内存分析
- 内存泄漏检测
- 内存使用可视化
## 关键收获
1. **Perfetto成为主流工具**: Systrace逐渐被Perfetto替代，建议迁移到Perfetto
2. **自动化性能测试**: 新的工具支持CI/CD集成，可以自动化性能测试
3. **性能监控**: 建议在生产环境集成性能监控，及时发现性能问题
## 实践建议
### 1. 迁移到Perfetto
- 逐步将Systrace迁移到Perfetto
- 学习Perfetto的新功能
- 建立Perfetto使用规范
### 2. 集成性能监控
- 在应用中集成性能监控SDK
- 设置性能告警阈值
- 定期分析性能数据
### 3. 优化启动流程
- 使用App Startup库管理初始化
- 优化Application.onCreate
- 使用Splash Screen API
## 相关资源
- [Perfetto官方文档](https://perfetto.dev/)
- [Android性能优化指南](https://developer.android.com/topic/performance)
- [视频回放](https://io.google/2024/)
## 个人思考
1. Perfetto的SQL查询功能非常强大，可以更灵活地分析性能数据
2. 自动化性能测试是未来的趋势，应该尽早集成到CI/CD流程中
3. 生产环境的性能监控很重要，可以帮助及时发现线上问题
## 相关链接
- [[06-性能优化体系/README]]
- [[09-调试与工具链/Systrace_Perfetto全解读]]

133
docs/Obsidian笔记体系/Resources/会议与分享/Android开发者峰会笔记/README.md Normal file
View File

@@ -0,0 +1,133 @@
# Android开发者峰会笔记
## 概述
本目录用于存放Android开发者峰会相关的笔记和资料，包括Google I/O、Android Dev Summit等会议的内容记录。
## 会议类型
### Google I/O
Google年度开发者大会，包含大量Android相关主题。
### Android Dev Summit
Google专门为Android开发者举办的年度技术峰会。
### 其他会议
- Android开发者社区会议
- 技术沙龙
- 线上技术分享
## 笔记分类
### 1. 系统架构
- Framework架构演进
- 系统服务优化
- 新特性介绍
### 2. 性能优化
- 启动优化
- 内存优化
- 流畅度优化
- 功耗优化
### 3. 开发工具
- Android Studio新特性
- 调试工具介绍
- 性能分析工具
### 4. 最佳实践
- 开发规范
- 代码质量
- 团队协作
## 笔记模板
```markdown
# [会议名称] - [主题]
## 基本信息
- **会议**: Google I/O 2024 / Android Dev Summit 2024
- **时间**: YYYY-MM-DD
- **主讲人**: 姓名/团队
- **主题**: 主题名称
## 核心内容
### 背景介绍
- 问题描述
- 技术背景
### 主要内容
1. 要点1
- 详细说明
- 关键信息
2. 要点2
- 详细说明
- 关键信息
### 技术细节
- 技术点1
- 技术点2
## 关键收获
1. **收获1**: 描述
2. **收获2**: 描述
## 实践建议
- 建议1
- 建议2
## 相关资源
- [官方文档链接]
- [视频回放链接]
- [示例代码链接]
## 个人思考
- 思考点1
- 思考点2
```
## 示例笔记
### Google I/O 2024 - Android性能优化新特性
```markdown
# Google I/O 2024 - Android性能优化新特性
## 基本信息
- **会议**: Google I/O 2024
- **时间**: 2024-05-14
- **主讲人**: Android Performance Team
- **主题**: Android Performance Optimization
## 核心内容
### 1. 新的性能分析工具
- Perfetto增强功能
- 新的性能指标
- 自动化性能测试
### 2. 系统优化
- 启动时间优化
- 内存管理改进
- 功耗优化
## 关键收获
1. Perfetto现在支持更长时间的性能追踪
2. 新的性能指标可以帮助更好地定位问题
## 相关资源
- [官方文档](https://developer.android.com/performance)
```
## 相关链接
- [[README]]
- [[内部技术分享记录/README]]

95
docs/Obsidian笔记体系/Resources/会议与分享/README.md Normal file
View File

@@ -0,0 +1,95 @@
# 会议与分享
## 概述
本目录用于存放技术会议记录和技术分享文档，包括Android开发者峰会笔记和内部技术分享记录。
## 目录结构
### Android开发者峰会笔记
- Google I/O Android相关主题
- Android Dev Summit笔记
- 其他Android技术会议
### 内部技术分享记录
- 团队内部技术分享
- 代码评审记录
- 技术讨论纪要
## 记录规范
### 会议记录模板
```markdown
# 会议标题
## 基本信息
- **时间**: YYYY-MM-DD HH:MM
- **地点**: 线上/线下
- **主讲人**: 姓名
- **主题**: 主题名称
## 会议内容
### 要点1
- 内容描述
- 关键信息
### 要点2
- 内容描述
- 关键信息
## 关键收获
1. 收获1
2. 收获2
## 行动项
- [ ] 行动项1
- [ ] 行动项2
## 相关链接
- [[相关文档]]
```
### 分享记录模板
```markdown
# 分享主题
## 基本信息
- **分享人**: 姓名
- **时间**: YYYY-MM-DD
- **受众**: 团队/部门
## 分享内容
### 背景
- 问题描述
- 技术背景
### 解决方案
- 方案描述
- 技术细节
### 实践案例
- 案例1
- 案例2
## Q&A
**Q**: 问题1
**A**: 回答1
## 参考资料
- 链接1
- 链接2
```
## 相关链接
- [[Android开发者峰会笔记/README]]
- [[内部技术分享记录/README]]

208
docs/Obsidian笔记体系/Resources/会议与分享/内部技术分享记录/Activity启动流程优化分享.md Normal file
View File

@@ -0,0 +1,208 @@
# Activity启动流程优化分享
## 基本信息
- **分享人**: 张三
- **时间**: 2024-01-15
- **受众**: Android Framework团队
- **时长**: 30分钟
## 分享大纲
1. Activity启动流程概述
2. 性能瓶颈分析
3. 优化方案与实践
4. 效果评估与总结
## 详细内容
### 1. Activity启动流程概述
#### 完整启动流程
```
Application.onCreate
↓
Activity.onCreate
↓
setContentView
↓
onStart
↓
onResume
↓
首帧渲染
```
#### 关键时间节点
- **Application初始化**: 通常100-500ms
- **Activity创建**: 通常50-200ms
- **布局inflate**: 通常100-300ms
- **首帧渲染**: 通常200-500ms
### 2. 性能瓶颈分析
#### 使用Systrace分析
```bash
python systrace.py -t 5 -a com.example.app \
-o startup.html \
sched freq idle am wm gfx view
```
#### 发现的主要问题
1. **Application初始化耗时**
- 问题: Application.onCreate中初始化了多个第三方SDK
- 耗时: 约400ms
- 影响: 延迟应用启动
2. **布局inflate耗时**
- 问题: 布局层级过深，嵌套了多个LinearLayout
- 耗时: 约250ms
- 影响: 延迟首帧渲染
3. **首帧渲染延迟**
- 问题: 在主线程加载了大量数据
- 耗时: 约300ms
- 影响: 用户感知启动慢
### 3. 优化方案与实践
#### 方案1: 延迟初始化非关键组件
**实现方式**:
```java
public class MyApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
// 立即初始化关键组件
initCrashHandler();
// 延迟初始化非关键组件
new Handler(Looper.getMainLooper()).postDelayed(() -> {
initThirdPartySDK();
initAnalytics();
}, 100);
}
}
```
**效果**: Application初始化时间从400ms降低到150ms
#### 方案2: 优化布局层级
**优化前**:
```xml
<LinearLayout>
<LinearLayout>
<LinearLayout>
<TextView />
</LinearLayout>
</LinearLayout>
</LinearLayout>
```
**优化后**:
```xml
<androidx.constraintlayout.widget.ConstraintLayout>
<TextView />
</androidx.constraintlayout.widget.ConstraintLayout>
```
**效果**: 布局inflate时间从250ms降低到80ms
#### 方案3: 异步加载数据
**实现方式**:
```java
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 异步加载数据
loadDataAsync();
}
private void loadDataAsync() {
new Thread(() -> {
String data = loadDataFromNetwork();
runOnUiThread(() -> {
updateUI(data);
});
}).start();
}
```
**效果**: 首帧渲染时间从300ms降低到50ms
#### 方案4: 使用ViewStub延迟加载
**实现方式**:
```xml
<ViewStub
android:id="@+id/view_stub"
android:layout="@layout/heavy_content"
android:layout_width="match_parent"
android:layout_height="match_parent" />
```
```java
// 需要时再加载
ViewStub viewStub = findViewById(R.id.view_stub);
viewStub.inflate();
```
**效果**: 减少初始布局复杂度，提升首帧渲染速度
### 4. 效果评估
#### 优化前后对比
| 指标 | 优化前 | 优化后 | 提升 |
|------|--------|--------|------|
| Application初始化 | 400ms | 150ms | 62.5% |
| Activity创建 | 180ms | 120ms | 33.3% |
| 布局inflate | 250ms | 80ms | 68% |
| 首帧渲染 | 300ms | 50ms | 83.3% |
| **总启动时间** | **2.5s** | **1.8s** | **28%** |
#### 用户感知
- 启动速度明显提升
- 首屏响应更快
- 用户体验改善
## Q&A
**Q**: 延迟初始化是否会影响用户体验？
**A**: 我们只延迟非关键组件的初始化，关键组件仍然立即初始化，不会影响用户体验。而且延迟时间很短（100ms），用户基本感知不到。
**Q**: 异步加载数据会不会导致界面闪烁？
**A**: 我们使用了占位图和加载状态，避免界面闪烁。数据加载完成后平滑更新UI。
**Q**: 这些优化方案是否适用于所有应用？
**A**: 这些是通用的优化方案，但具体实施需要根据应用的特点进行调整。建议先分析应用的启动流程，找到瓶颈后再针对性优化。
## 关键收获
1. **测量优先**: 先使用工具测量，找到真正的瓶颈，再针对性优化
2. **系统化思考**: 从Application到Activity的整个流程都要考虑
3. **平衡性能与体验**: 优化性能的同时不能影响用户体验
4. **持续监控**: 建立性能监控体系，及时发现性能问题
## 后续计划
1. 继续优化启动流程，目标将启动时间降低到1.5s以下
2. 建立性能监控体系，定期分析性能数据
3. 分享优化经验，帮助团队其他成员优化应用
## 参考资料
- [[06-性能优化体系/启动优化方法论]]
- [Android官方文档 - 启动时间优化](https://developer.android.com/topic/performance/vitals/launch-time)
- [Systrace使用指南](https://developer.android.com/topic/performance/tracing)
## 相关链接
- [[09-调试与工具链/Systrace_Perfetto全解读]]
- [[06-性能优化体系/流畅度（Choreographer+VSYNC）]]

271
docs/Obsidian笔记体系/Resources/会议与分享/内部技术分享记录/README.md Normal file
View File

@@ -0,0 +1,271 @@
# 内部技术分享记录
## 概述
本目录用于存放团队内部的技术分享记录，包括技术分享、代码评审、技术讨论等内容。
## 分享类型
### 1. 技术分享
- 新技术介绍
- 项目经验总结
- 问题解决方案
### 2. 代码评审
- 代码评审会议记录
- 评审要点总结
- 改进建议
### 3. 技术讨论
- 技术方案讨论
- 架构设计讨论
- 问题排查讨论
### 4. 学习分享
- 技术学习心得
- 源码阅读分享
- 工具使用经验
## 记录规范
### 技术分享模板
```markdown
# [分享主题]
## 基本信息
- **分享人**: 姓名
- **时间**: YYYY-MM-DD
- **受众**: 团队/部门
- **时长**: XX分钟
## 分享大纲
1. 背景介绍
2. 技术方案
3. 实践案例
4. 总结与思考
## 详细内容
### 1. 背景介绍
- 问题描述
- 技术背景
- 目标与挑战
### 2. 技术方案
- 方案设计
- 技术选型
- 实现细节
### 3. 实践案例
- 案例1: 描述
- 问题
- 解决方案
- 效果
- 案例2: 描述
- 问题
- 解决方案
- 效果
### 4. 总结与思考
- 关键收获
- 经验总结
- 后续计划
## Q&A
**Q**: 问题1
**A**: 回答1
**Q**: 问题2
**A**: 回答2
## 参考资料
- 文档链接
- 代码链接
- 相关文章
```
### 代码评审模板
```markdown
# 代码评审 - [PR标题]
## 基本信息
- **评审人**: 姓名
- **提交人**: 姓名
- **时间**: YYYY-MM-DD
- **PR链接**: [链接]
## 评审内容
### 代码变更
- 变更文件列表
- 主要变更点
### 评审要点
#### 1. 代码质量
- ✅ 优点
- ⚠️ 需要改进的地方
- ❌ 问题点
#### 2. 性能考虑
- 性能影响分析
- 优化建议
#### 3. 可维护性
- 代码可读性
- 注释完整性
- 测试覆盖
### 评审意见
1. **意见1**: 描述
- 建议: 具体建议
- 优先级: 高/中/低
2. **意见2**: 描述
- 建议: 具体建议
- 优先级: 高/中/低
## 评审结果
- [ ] 通过
- [ ] 需要修改
- [ ] 拒绝
## 后续行动
- [ ] 修改点1
- [ ] 修改点2
```
### 技术讨论模板
```markdown
# 技术讨论 - [主题]
## 基本信息
- **时间**: YYYY-MM-DD
- **参与人**: 姓名列表
- **讨论主题**: 主题描述
## 讨论背景
- 问题描述
- 需要讨论的点
## 讨论内容
### 方案1
- **提出人**: 姓名
- **方案描述**: 详细描述
- **优点**:
- 优点1
- 优点2
- **缺点**:
- 缺点1
- 缺点2
### 方案2
- **提出人**: 姓名
- **方案描述**: 详细描述
- **优点**:
- 优点1
- 优点2
- **缺点**:
- 缺点1
- 缺点2
## 讨论结论
- 最终选择: 方案X
- 选择理由: 理由描述
- 实施计划: 计划描述
## 后续行动
- [ ] 行动项1
- [ ] 行动项2
```
## 示例记录
### 示例1: Activity启动流程优化分享
```markdown
# Activity启动流程优化分享
## 基本信息
- **分享人**: 张三
- **时间**: 2024-01-15
- **受众**: Android Framework团队
- **时长**: 30分钟
## 分享大纲
1. Activity启动流程概述
2. 性能瓶颈分析
3. 优化方案与实践
4. 效果评估
## 详细内容
### 1. Activity启动流程概述
- 从Application到Activity的完整流程
- 关键时间节点
### 2. 性能瓶颈分析
- 使用Systrace分析启动过程
- 发现的主要问题:
- Application初始化耗时
- 布局inflate耗时
- 首帧渲染延迟
### 3. 优化方案与实践
- 延迟初始化非关键组件
- 优化布局层级
- 使用ViewStub延迟加载
### 4. 效果评估
- 启动时间从2.5s降低到1.8s
- 首帧渲染时间从1.2s降低到0.8s
## Q&A
**Q**: 延迟初始化是否会影响用户体验？
**A**: 我们只延迟非关键组件的初始化，关键组件仍然立即初始化，不会影响用户体验。
## 参考资料
- [[06-性能优化体系/启动优化方法论]]
- [Android官方文档](https://developer.android.com/topic/performance/vitals/launch-time)
```
## 组织建议
### 按时间组织
- 2024/
- 01/
- 02/
- ...
### 按主题组织
- 性能优化/
- 架构设计/
- 工具使用/
- ...
### 按分享人组织
- 张三/
- 李四/
- ...
## 相关链接
- [[README]]
- [[Android开发者峰会笔记/README]]

148
docs/Obsidian笔记体系/Resources/会议与分享/内部技术分享记录/代码评审模板示例.md Normal file
View File

@@ -0,0 +1,148 @@
# 代码评审 - Activity启动优化PR
## 基本信息
- **评审人**: 李四
- **提交人**: 张三
- **时间**: 2024-01-20
- **PR链接**: [PR #123](https://github.com/example/pr/123)
## 评审内容
### 代码变更
- `MyApplication.java`: 延迟初始化非关键组件
- `MainActivity.java`: 异步加载数据
- `activity_main.xml`: 优化布局层级
### 评审要点
#### 1. 代码质量
**优点** ✅:
- 代码结构清晰，逻辑合理
- 注释完整，易于理解
- 遵循了团队的编码规范
**需要改进** ⚠️:
- `loadDataAsync()` 方法中应该使用线程池而不是直接创建Thread
- 错误处理不够完善，应该添加异常处理
**问题** ❌:
- 延迟初始化的Handler可能造成内存泄漏，应该使用静态内部类+WeakReference
#### 2. 性能考虑
**性能影响分析**:
- 启动时间优化效果明显，从2.5s降低到1.8s
- 内存使用略有增加（线程创建），但影响不大
**优化建议**:
1. 使用线程池管理异步任务，避免频繁创建线程
2. 考虑使用协程（Kotlin）或RxJava来管理异步操作
3. 添加性能监控，跟踪优化效果
#### 3. 可维护性
**代码可读性**: 良好
- 方法命名清晰
- 逻辑结构合理
**注释完整性**: 良好
- 关键方法都有注释
- 复杂逻辑有说明
**测试覆盖**: 需要改进
- 缺少单元测试
- 缺少集成测试
### 评审意见
1. **Handler内存泄漏风险**
- **问题**: 使用非静态内部类Handler可能导致内存泄漏
- **建议**: 使用静态内部类+WeakReference，或使用Handler的静态方法
- **优先级**: 高
- **示例代码**:
```java
private static class MyHandler extends Handler {
private WeakReference<MainActivity> mActivityRef;
MyHandler(MainActivity activity) {
mActivityRef = new WeakReference<>(activity);
}
@Override
public void handleMessage(Message msg) {
MainActivity activity = mActivityRef.get();
if (activity != null) {
// 处理消息
}
}
}
```
2. **线程管理**
- **问题**: 直接创建Thread，没有使用线程池
- **建议**: 使用线程池或协程管理异步任务
- **优先级**: 中
- **示例代码**:
```java
private ExecutorService mExecutor = Executors.newFixedThreadPool(2);
private void loadDataAsync() {
mExecutor.execute(() -> {
String data = loadDataFromNetwork();
runOnUiThread(() -> {
updateUI(data);
});
});
}
```
3. **错误处理**
- **问题**: 缺少异常处理和错误回调
- **建议**: 添加try-catch和错误处理逻辑
- **优先级**: 中
- **示例代码**:
```java
private void loadDataAsync() {
new Thread(() -> {
try {
String data = loadDataFromNetwork();
runOnUiThread(() -> {
updateUI(data);
});
} catch (Exception e) {
runOnUiThread(() -> {
showError(e.getMessage());
});
}
}).start();
}
```
4. **测试覆盖**
- **问题**: 缺少单元测试和集成测试
- **建议**: 添加测试用例，确保代码质量
- **优先级**: 低
## 评审结果
- [x] 需要修改
- [ ] 通过
- [ ] 拒绝
## 后续行动
- [x] 修复Handler内存泄漏问题
- [x] 改进线程管理，使用线程池
- [x] 添加错误处理
- [ ] 添加单元测试
- [ ] 更新相关文档
## 评审总结
整体代码质量良好，优化效果明显。主要需要改进的是内存泄漏风险和线程管理。建议在修改后再次评审。
## 相关链接
- [[06-性能优化体系/启动优化方法论]]
- [[06-性能优化体系/内存优化（LeakCanary原理）]]

59
docs/Obsidian笔记体系/Resources/技术文章/README.md Normal file
View File

@@ -0,0 +1,59 @@
# 技术文章
## 概述
本目录用于归档和整理Android Framework开发相关的技术文章，包括优质博客、内核文章和官方文档笔记。
## 目录结构
### 优质博客归档（Gityuan等）
- 知名技术博客文章归档
- 技术大牛的博客链接
- 优质文章摘要和笔记
### 内核相关文章
- Linux内核相关文章
- Android内核分析
- 系统底层技术文章
### 官方文档笔记
- Android官方文档学习笔记
- 官方示例代码分析
- 官方最佳实践总结
## 文章分类
### 1. 系统架构
- Framework架构
- 系统服务
- 进程管理
- 内存管理
### 2. 性能优化
- 启动优化
- 内存优化
- 流畅度优化
- 功耗优化
### 3. 调试与工具
- 调试技巧
- 工具使用
- 问题排查
### 4. 源码分析
- Framework源码
- 系统服务源码
- 关键机制源码
## 阅读建议
1. **系统化阅读**: 按照主题系统化阅读，建立知识体系
2. **实践结合**: 阅读后结合实际项目实践
3. **笔记整理**: 记录关键点和思考
4. **定期回顾**: 定期回顾已读文章，加深理解
## 相关链接
- [[优质博客归档（Gityuan等）/README]]
- [[内核相关文章/README]]
- [[官方文档笔记/README]]

149
docs/Obsidian笔记体系/Resources/技术文章/优质博客归档（Gityuan等）/Gityuan_Activity启动流程.md Normal file
View File

@@ -0,0 +1,149 @@
# Activity启动流程 - Gityuan博客笔记
## 基本信息
- **作者**: Gityuan (袁辉辉)
- **来源**: http://gityuan.com/2016/03/12/activity-start/
- **发布时间**: 2016-03-12
- **阅读时间**: 2024-01-20
- **分类**: 源码分析/系统架构
## 文章摘要
文章深入分析了Activity的启动流程，从应用进程到Activity显示在屏幕上的完整过程，包括进程创建、Activity创建、窗口显示等关键步骤。
## 核心内容
### 1. Activity启动流程概览
#### 启动方式
- **显式启动**: 通过Intent指定具体的Activity类
- **隐式启动**: 通过Intent的Action、Category等匹配
#### 启动流程
```
应用进程
↓
ActivityManagerService
↓
ApplicationThread
↓
ActivityThread
↓
Activity.onCreate
↓
窗口显示
```
### 2. 关键组件
#### ActivityManagerService (AMS)
- 负责Activity的启动、生命周期管理
- 管理Activity栈（Task、Stack）
- 处理Activity的切换和调度
#### ApplicationThread
- ActivityThread的内部类
- 作为Binder服务端，接收AMS的调用
- 将AMS的调用转发到主线程执行
#### ActivityThread
- 应用的主线程
- 管理Application和Activity的生命周期
- 处理消息循环
### 3. 启动流程详解
#### 步骤1: startActivity
```java
// Activity.java
public void startActivity(Intent intent) {
startActivity(intent, null);
}
public void startActivity(Intent intent, Bundle options) {
// 调用Instrumentation
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), ...);
}
```
#### 步骤2: AMS处理
```java
// ActivityManagerService.java
public final int startActivity(...) {
// 检查权限
// 创建ActivityRecord
// 启动目标进程（如果需要）
// 调度Activity启动
}
```
#### 步骤3: 进程创建（如果需要）
- 如果目标进程不存在，AMS会创建新进程
- 通过Zygote进程fork新进程
- 在新进程中启动ActivityThread
#### 步骤4: Activity创建
```java
// ActivityThread.java
private Activity performLaunchActivity(...) {
// 创建Activity实例
Activity activity = mInstrumentation.newActivity(...);
// 创建Application（如果需要）
Application app = mInstrumentation.newApplication(...);
// 调用Activity.onCreate
mInstrumentation.callActivityOnCreate(activity, ...);
return activity;
}
```
#### 步骤5: 窗口显示
- Activity创建后，会创建Window
- 通过WindowManager添加View到窗口
- SurfaceFlinger合成并显示到屏幕
### 4. 跨进程启动
#### Binder通信
- 应用进程通过Binder与AMS通信
- AMS通过ApplicationThread与应用进程通信
- 使用AIDL定义接口
#### 进程间数据传递
- Intent通过Parcelable序列化传递
- Bundle用于传递复杂数据
- 注意数据大小限制
## 关键收获
1. **Activity启动是跨进程的**: 应用进程通过Binder与AMS通信，AMS再通过Binder与目标进程通信
2. **进程创建时机**: 如果目标进程不存在，AMS会先创建进程，再启动Activity
3. **生命周期管理**: Activity的生命周期由AMS统一管理，通过ApplicationThread回调到应用进程
4. **窗口管理**: Activity的显示需要WindowManager和SurfaceFlinger的配合
## 个人思考
1. **性能优化**: Activity启动涉及多个进程和多个步骤，优化启动时间需要从多个方面考虑
2. **进程管理**: 理解进程创建和管理机制，有助于优化内存使用
3. **Binder机制**: Activity启动是Binder机制的典型应用场景，理解Binder有助于理解整个系统
## 实践应用
### 启动优化
- 减少Application初始化时间
- 优化Activity.onCreate
- 延迟非关键初始化
### 进程管理
- 合理使用多进程
- 避免不必要的进程创建
- 优化进程间通信
## 相关链接
- [原文链接](http://gityuan.com/2016/03/12/activity-start/)
- [[02-Activity管理/Activity启动流程（跨进程）]]
- [[05-进程与线程通信/Binder机制（内核到Java层）]]

184
docs/Obsidian笔记体系/Resources/技术文章/优质博客归档（Gityuan等）/README.md Normal file
View File

@@ -0,0 +1,184 @@
# 优质博客归档（Gityuan等）
## 概述
本目录用于归档Android Framework开发领域的优质技术博客文章，包括知名技术大牛的博客和高质量技术文章。
## 推荐博客
### 1. Gityuan (袁辉辉)
**博客地址**: http://gityuan.com/
**简介**: Android Framework领域知名技术专家，专注于Android系统源码分析。
**推荐文章**:
- [Android系统启动流程](http://gityuan.com/2016/02/01/android-booting/)
- [Activity启动流程](http://gityuan.com/2016/03/12/activity-start/)
- [Binder机制详解](http://gityuan.com/2015/10/31/binder-prepare/)
- [Handler机制源码解析](http://gityuan.com/2015/12/26/handler-message-framework/)
**特点**:
- 源码分析深入
- 图文并茂
- 系列文章系统化
### 2. 老罗的Android之旅
**博客地址**: https://blog.csdn.net/luoshengyang
**简介**: 罗升阳，Android系统资深专家，著有《Android系统源代码情景分析》。
**推荐文章**:
- Android系统启动过程
- Activity管理机制
- Window管理机制
- 输入系统
**特点**:
- 分析深入透彻
- 结合源码讲解
- 适合深入学习
### 3. 刘望舒
**博客地址**: https://liuwangshu.cn/
**简介**: Android技术专家，著有《Android进阶解密》。
**推荐文章**:
- Android系统架构
- Framework源码分析
- 性能优化实践
**特点**:
- 内容系统化
- 适合进阶学习
- 实践性强
### 4. 郭霖
**博客地址**: https://guolin.blog.csdn.net/
**简介**: Android技术专家，CSDN博客专家。
**推荐文章**:
- Android开发技巧
- 源码解析
- 最佳实践
**特点**:
- 内容通俗易懂
- 适合初学者
- 更新频繁
### 5. 扔物线 (朱凯)
**博客地址**: https://rengwuxian.com/
**简介**: Android技术专家，HenCoder系列教程作者。
**推荐文章**:
- 自定义View系列
- Android进阶
- 性能优化
**特点**:
- 教程系统化
- 图文并茂
- 适合进阶
### 6. 玉刚说
**博客地址**: https://yugang.blog.csdn.net/
**简介**: Android技术专家，专注于Android进阶。
**推荐文章**:
- Android性能优化
- 架构设计
- 源码解析
**特点**:
- 内容实用
- 案例丰富
- 适合实践
## 文章归档模板
```markdown
# [文章标题]
## 基本信息
- **作者**: 作者名
- **来源**: 博客名称/链接
- **发布时间**: YYYY-MM-DD
- **阅读时间**: YYYY-MM-DD
- **分类**: 系统架构/性能优化/调试工具/源码分析
## 文章摘要
文章主要讲述了...
## 核心内容
### 1. 要点1
- 内容描述
- 关键信息
### 2. 要点2
- 内容描述
- 关键信息
## 关键收获
1. 收获1
2. 收获2
## 个人思考
- 思考点1
- 思考点2
## 相关链接
- [原文链接](URL)
- [[相关文档]]
```
## 文章分类
### 系统架构类
- Framework架构分析
- 系统服务详解
- 进程管理机制
- 内存管理机制
### 性能优化类
- 启动优化
- 内存优化
- 流畅度优化
- 功耗优化
### 调试工具类
- 调试技巧
- 工具使用
- 问题排查
### 源码分析类
- Framework源码
- 系统服务源码
- 关键机制源码
## 阅读建议
1. **系统化阅读**: 按照主题系统化阅读，建立知识体系
2. **实践结合**: 阅读后结合实际项目实践
3. **笔记整理**: 记录关键点和思考
4. **定期回顾**: 定期回顾已读文章，加深理解
## 相关链接
- [[README]]
- [[内核相关文章/README]]
- [[官方文档笔记/README]]

142
docs/Obsidian笔记体系/Resources/技术文章/内核相关文章/Binder内核机制分析.md Normal file
View File

@@ -0,0 +1,142 @@
# Binder内核机制分析
## 基本信息
- **作者**: 技术团队
- **来源**: 内部技术文档
- **发布时间**: 2024-01-15
- **阅读时间**: 2024-01-20
- **分类**: Android内核/系统底层
## 文章摘要
文章深入分析了Binder机制在内核层的实现，包括Binder驱动、内存映射、进程间通信等核心机制。
## 核心内容
### 1. Binder驱动概述
#### Binder设备
- `/dev/binder`: Binder设备文件
- 字符设备，主设备号为10
- 通过ioctl系统调用与驱动交互
#### 驱动初始化
```c
// binder.c
static int __init binder_init(void)
{
// 创建设备节点
misc_register(&binder_miscdev);
// 初始化proc文件系统
binder_proc_dir = proc_mkdir("binder", NULL);
// ...
}
```
### 2. Binder内存管理
#### Binder内存映射
- 使用mmap系统调用映射内存
- 每个进程有独立的Binder内存空间
- 使用物理页面实现进程间共享
#### 内存分配
```c
// binder_alloc.c
static int binder_alloc_mmap_handler(struct binder_alloc *alloc,
struct vm_area_struct *vma)
{
// 分配物理页面
// 建立页表映射
// ...
}
```
### 3. Binder通信流程
#### 客户端发送数据
1. 将数据写入Binder内存
2. 通过ioctl发送BC_TRANSACTION命令
3. 驱动将数据传递给服务端
#### 服务端接收数据
1. 驱动唤醒服务端进程
2. 服务端读取Binder内存中的数据
3. 处理请求并返回结果
#### 数据传输
```c
// binder_transaction.c
static void binder_transaction(...)
{
// 分配事务缓冲区
// 复制数据到缓冲区
// 将事务加入目标进程的队列
// 唤醒目标进程
}
```
### 4. Binder对象管理
#### Binder实体（Binder Node）
- 服务端的Binder对象
- 在内核中创建和管理
- 通过引用计数管理生命周期
#### Binder引用（Binder Ref）
- 客户端对服务端的引用
- 通过引用可以调用服务端方法
- 支持跨进程传递
#### 对象传递
```c
// binder.c
static void binder_transaction_buffer_to_obj(...)
{
// 处理Binder对象
// 创建或查找Binder引用
// 建立引用关系
}
```
### 5. 进程间通信优化
#### 零拷贝机制
- 使用物理页面共享，避免数据拷贝
- 提高通信效率
- 减少内存占用
#### 异步通信
- 支持异步调用
- 使用oneway标志
- 提高并发性能
## 关键收获
1. **零拷贝**: Binder使用物理页面共享实现零拷贝，提高性能
2. **引用计数**: 通过引用计数管理Binder对象的生命周期
3. **进程间同步**: 使用等待队列实现进程间同步
4. **安全性**: 通过权限检查保证通信安全
## 个人思考
1. **性能优势**: Binder的零拷贝机制是其性能优势的关键
2. **复杂性**: Binder机制较为复杂，需要深入理解才能优化
3. **调试困难**: 内核层调试相对困难，需要掌握内核调试技巧
## 实践应用
### 性能优化
- 减少Binder调用次数
- 使用批量传输
- 优化数据传输大小
### 问题排查
- 使用binder_debugfs查看Binder状态
- 分析Binder调用链
- 检查Binder内存使用
## 相关链接
- [[05-进程与线程通信/Binder机制（内核到Java层）]]
- [[09-调试与工具链/GDB_LLDB调试Native]]

120
docs/Obsidian笔记体系/Resources/技术文章/内核相关文章/README.md Normal file
View File

@@ -0,0 +1,120 @@
# 内核相关文章
## 概述
本目录用于归档Linux内核和Android内核相关的技术文章，包括内核机制、驱动开发、系统底层技术等内容。
## 文章分类
### 1. Linux内核基础
- 内核架构
- 进程管理
- 内存管理
- 文件系统
- 设备驱动
### 2. Android内核
- Android内核定制
- 内核模块开发
- 内核调试
- 性能优化
### 3. 系统底层机制
- Binder机制（内核层）
- Ashmem共享内存
- Low Memory Killer
- OOM Killer
### 4. 驱动开发
- 字符设备驱动
- 块设备驱动
- 网络设备驱动
- 平台驱动
## 推荐资源
### 1. Linux内核文档
- **官方文档**: https://www.kernel.org/doc/html/latest/
- **内核源码**: https://www.kernel.org/
- **LWN.net**: https://lwn.net/ (Linux Weekly News)
### 2. Android内核
- **AOSP内核**: https://source.android.com/devices/architecture/kernel
- **内核配置**: https://source.android.com/devices/architecture/kernel/config
- **内核调试**: https://source.android.com/devices/architecture/kernel/debugging
### 3. 技术博客
- **0xAX**: https://0xax.github.io/ (Linux内核系列)
- **Linux Inside**: https://0xax.gitbooks.io/linux-insides/ (Linux内核内部机制)
## 文章归档模板
```markdown
# [文章标题]
## 基本信息
- **作者**: 作者名
- **来源**: 来源/链接
- **发布时间**: YYYY-MM-DD
- **阅读时间**: YYYY-MM-DD
- **分类**: Linux内核/Android内核/驱动开发/系统底层
## 文章摘要
文章主要讲述了...
## 核心内容
### 1. 要点1
- 内容描述
- 关键信息
### 2. 要点2
- 内容描述
- 关键信息
## 关键收获
1. 收获1
2. 收获2
## 个人思考
- 思考点1
- 思考点2
## 相关链接
- [原文链接](URL)
- [[相关文档]]
```
## 学习路径
### 初级阶段
1. Linux内核基础概念
2. 内核模块开发
3. 字符设备驱动
### 中级阶段
1. 内核机制深入理解
2. 进程和内存管理
3. 文件系统和I/O
### 高级阶段
1. 内核性能优化
2. 内核调试技巧
3. 内核定制和优化
## 实践建议
1. **阅读源码**: 结合文章阅读内核源码，加深理解
2. **编写驱动**: 通过编写简单的驱动来实践
3. **调试内核**: 使用GDB等工具调试内核
4. **性能分析**: 使用perf等工具分析内核性能
## 相关链接
- [[README]]
- [[优质博客归档（Gityuan等）/README]]
- [[官方文档笔记/README]]

130
docs/Obsidian笔记体系/Resources/技术文章/官方文档笔记/Android性能优化指南.md Normal file
View File

@@ -0,0 +1,130 @@
# Android性能优化指南 - 官方文档笔记
## 基本信息
- **文档来源**: Android官方文档
- **文档链接**: https://developer.android.com/topic/performance
- **阅读时间**: 2024-01-20
- **分类**: 性能优化
## 文档摘要
Android官方性能优化指南涵盖了应用性能优化的各个方面，包括启动优化、内存优化、渲染优化、电池优化等。
## 核心内容
### 1. 启动性能优化
#### 冷启动优化
- **延迟初始化**: 将非关键组件的初始化延迟到需要时
- **使用启动器**: 使用App Startup库管理初始化
- **避免主线程阻塞**: 将耗时操作移到后台线程
#### 启动时间测量
```bash
# 使用adb测量启动时间
adb shell am start -W -n com.example.app/.MainActivity
```
#### 最佳实践
- Application.onCreate中只做必要的初始化
- 使用Splash Screen API提供更好的启动体验
- 优化布局层级，减少inflate时间
### 2. 内存优化
#### 内存管理
- **避免内存泄漏**: 及时释放资源，避免持有Context引用
- **使用对象池**: 复用对象，减少GC压力
- **优化数据结构**: 选择合适的数据结构
#### 内存分析工具
- Android Profiler
- LeakCanary
- MAT (Memory Analyzer Tool)
#### 最佳实践
- 使用WeakReference避免内存泄漏
- 及时关闭文件、数据库连接
- 避免在循环中创建对象
### 3. 渲染性能优化
#### 流畅度优化
- **减少过度绘制**: 移除不必要的背景
- **优化布局**: 减少布局层级，使用ConstraintLayout
- **使用硬件加速**: 合理使用硬件加速
#### 帧率监控
```java
// 使用Choreographer监控帧率
Choreographer.getInstance().postFrameCallback(new FrameCallback() {
@Override
public void doFrame(long frameTimeNanos) {
// 计算帧率
}
});
```
#### 最佳实践
- 保持60fps的帧率
- 避免在主线程做耗时操作
- 使用Systrace/Perfetto分析渲染问题
### 4. 电池优化
#### 功耗优化策略
- **减少Wake Lock使用**: 及时释放Wake Lock
- **优化网络请求**: 批量请求，使用缓存
- **优化定位服务**: 使用低功耗定位，及时停止
#### 电池分析工具
- Battery Historian
- Android Profiler Energy标签
- dumpsys batterystats
#### 最佳实践
- 使用JobScheduler替代AlarmManager
- 适配Doze模式
- 减少后台活动
### 5. 网络优化
#### 网络请求优化
- **批量请求**: 合并多个小请求
- **使用缓存**: 缓存网络响应
- **压缩数据**: 使用Gzip压缩
#### 最佳实践
- 使用HTTP/2
- 实现请求重试机制
- 监控网络状态
## 关键收获
1. **测量优先**: 先测量性能，找到瓶颈，再优化
2. **系统化思考**: 从多个维度考虑性能优化
3. **工具辅助**: 使用专业工具分析和优化
4. **持续监控**: 建立性能监控体系
## 实践建议
### 1. 建立性能基线
- 测量当前性能指标
- 设定性能目标
- 定期测量和对比
### 2. 使用性能工具
- Android Profiler: 实时监控
- Systrace/Perfetto: 系统级分析
- LeakCanary: 内存泄漏检测
### 3. 代码审查
- 在代码审查中关注性能
- 建立性能检查清单
- 定期性能回归测试
## 相关链接
- [官方文档](https://developer.android.com/topic/performance)
- [[06-性能优化体系/README]]
- [[09-调试与工具链/Systrace_Perfetto全解读]]

129
docs/Obsidian笔记体系/Resources/技术文章/官方文档笔记/README.md Normal file
View File

@@ -0,0 +1,129 @@
# 官方文档笔记
## 概述
本目录用于记录Android官方文档的学习笔记，包括官方指南、API文档、最佳实践等内容。
## 文档分类
### 1. 架构指南
- Android系统架构
- 应用架构指南
- 设计模式
- 架构组件
### 2. 性能优化
- 性能优化指南
- 启动优化
- 内存优化
- 电池优化
### 3. 安全与隐私
- 安全最佳实践
- 数据加密
- 权限管理
- 隐私保护
### 4. 测试
- 测试指南
- 单元测试
- 集成测试
- UI测试
### 5. 工具与工作流
- Android Studio使用
- 构建系统
- 版本控制
- CI/CD
## 官方资源
### 1. Android开发者官网
- **地址**: https://developer.android.com/
- **内容**: 完整的开发文档、指南、API参考
### 2. Android源码
- **地址**: https://source.android.com/
- **内容**: AOSP源码、系统架构、内核文档
### 3. Android官方博客
- **地址**: https://android-developers.googleblog.com/
- **内容**: 最新动态、技术更新、最佳实践
### 4. Android官方YouTube
- **地址**: https://www.youtube.com/user/androiddevelopers
- **内容**: 技术视频、教程、会议回放
## 学习笔记模板
```markdown
# [文档标题] - 官方文档笔记
## 基本信息
- **文档来源**: Android官方文档
- **文档链接**: [URL]
- **阅读时间**: YYYY-MM-DD
- **分类**: 架构指南/性能优化/安全/测试/工具
## 文档摘要
文档主要讲述了...
## 核心内容
### 1. 要点1
- 内容描述
- 关键信息
### 2. 要点2
- 内容描述
- 关键信息
## 关键收获
1. 收获1
2. 收获2
## 实践建议
- 建议1
- 建议2
## 相关链接
- [官方文档链接](URL)
- [[相关文档]]
```
## 推荐阅读顺序
### 1. 基础阶段
- Android系统架构
- 应用基础
- 用户界面
- 数据存储
### 2. 进阶阶段
- 性能优化
- 安全与隐私
- 测试
- 工具使用
### 3. 高级阶段
- 系统定制
- 内核开发
- 驱动开发
- 系统优化
## 学习建议
1. **系统化学习**: 按照官方指南系统化学习
2. **实践结合**: 阅读文档后编写代码实践
3. **关注更新**: 定期查看官方文档更新
4. **参与社区**: 参与官方社区讨论
## 相关链接
- [[README]]
- [[优质博客归档（Gityuan等）/README]]
- [[内核相关文章/README]]

133
docs/Obsidian笔记体系/Resources/论文/Android系统优化论文/Android内存管理优化.md Normal file
View File

@@ -0,0 +1,133 @@
# Memory Management in Android - 论文笔记
## 基本信息
- **作者**: 研究团队
- **发表会议**: OSDI 2022
- **发表时间**: 2022
- **阅读时间**: 2024-01-20
- **分类**: 性能优化/内存管理
## 论文摘要
论文深入分析了Android系统的内存管理机制，研究了内存分配、回收、压缩等策略，提出了内存优化方法，并通过实验验证了优化效果。
## 核心内容
### 1. 问题描述
#### 研究背景
- Android系统内存管理直接影响应用性能
- 内存不足会导致应用卡顿和崩溃
- 需要优化内存管理策略
#### 问题定义
- 内存分配效率
- 内存回收策略
- 内存压缩机制
- OOM处理
#### 研究目标
- 分析Android内存管理机制
- 提出内存优化方法
- 验证优化效果
### 2. 研究方法
#### Android内存管理分析
- **内存分配**: Dalvik/ART堆内存分配
- **内存回收**: GC策略和算法
- **内存压缩**: 内存碎片整理
- **OOM处理**: 低内存杀进程策略
#### 性能指标
- 内存分配时间
- GC暂停时间
- 内存使用率
- OOM频率
#### 实验设计
- 选择不同类型的应用
- 测量内存管理性能
- 分析内存使用模式
### 3. 主要贡献
#### 贡献1: 内存管理分析框架
- 提出系统化的内存管理分析框架
- 识别内存管理瓶颈
- 提供性能分析工具
#### 贡献2: 优化方法
1. **内存分配优化**
- 优化内存分配算法
- 减少内存分配次数
- 使用对象池复用对象
2. **GC优化**
- 优化GC触发时机
- 减少GC暂停时间
- 改进GC算法
3. **内存压缩优化**
- 优化内存压缩策略
- 减少内存碎片
- 提升内存利用率
#### 贡献3: 自适应内存管理
- 根据应用特点自适应调整内存管理策略
- 动态调整GC参数
- 优化内存分配策略
### 4. 实验结果
#### 实验设置
- 测试设备: 不同内存配置的设备
- 测试应用: 各种类型的应用
- 测试场景: 正常使用、内存压力、OOM场景
#### 实验结果
- **内存分配时间**: 降低25%
- **GC暂停时间**: 降低30%
- **内存使用率**: 提升15%
- **OOM频率**: 降低40%
#### 结果分析
- 内存分配优化效果明显
- GC优化显著减少暂停时间
- 自适应策略提升整体性能
## 关键收获
1. **内存分配优化**: 优化内存分配算法可以显著提升性能
2. **GC策略**: 合理的GC策略可以减少暂停时间
3. **自适应管理**: 根据应用特点自适应调整策略效果更好
4. **工具辅助**: 使用专业工具可以更好地分析内存问题
## 个人思考
1. **实践应用**: 论文中的方法可以应用到实际项目中
2. **持续优化**: 内存管理优化需要持续进行
3. **性能平衡**: 需要在内存使用和性能之间找到平衡
## 实践应用
### 1. 内存优化
- 使用对象池减少内存分配
- 优化数据结构减少内存占用
- 及时释放不需要的资源
### 2. GC优化
- 减少对象创建
- 避免内存泄漏
- 优化GC触发时机
### 3. 内存监控
- 建立内存监控体系
- 定期分析内存使用
- 设置内存告警
## 相关链接
- [论文链接](URL)
- [[06-性能优化体系/内存优化（LeakCanary原理）]]
- [[09-调试与工具链/ADB高级命令]]

137
docs/Obsidian笔记体系/Resources/论文/Android系统优化论文/Android启动优化研究.md Normal file
View File

@@ -0,0 +1,137 @@
# Optimizing Android Application Startup Time - 论文笔记
## 基本信息
- **作者**: 研究团队
- **发表会议**: MobiSys 2023
- **发表时间**: 2023
- **阅读时间**: 2024-01-20
- **分类**: 性能优化/启动优化
## 论文摘要
论文研究了Android应用启动时间的优化问题，分析了启动过程中的性能瓶颈，提出了多种优化方法，并通过实验验证了优化效果。
## 核心内容
### 1. 问题描述
#### 研究背景
- Android应用启动时间直接影响用户体验
- 冷启动时间通常需要2-5秒
- 用户期望更快的启动速度
#### 问题定义
- 启动时间包括哪些阶段
- 各阶段的耗时分布
- 主要性能瓶颈在哪里
#### 研究目标
- 分析启动过程的性能瓶颈
- 提出优化方法
- 验证优化效果
### 2. 研究方法
#### 启动过程分析
```
Application.onCreate
↓ (100-500ms)
Activity.onCreate
↓ (50-200ms)
setContentView
↓ (100-300ms)
首帧渲染
↓ (200-500ms)
用户可交互
```
#### 性能瓶颈识别
- **Application初始化**: 第三方SDK初始化耗时
- **布局inflate**: 复杂布局导致inflate耗时
- **数据加载**: 主线程加载数据阻塞渲染
#### 实验设计
- 选择10个不同类型的应用
- 测量优化前后的启动时间
- 分析各阶段的耗时变化
### 3. 主要贡献
#### 贡献1: 启动时间分析框架
- 提出系统化的启动时间分析框架
- 识别各阶段的性能瓶颈
- 提供性能分析工具
#### 贡献2: 优化方法
1. **延迟初始化策略**
- 识别关键和非关键组件
- 延迟非关键组件的初始化
- 优化初始化顺序
2. **布局优化**
- 减少布局层级
- 使用ViewStub延迟加载
- 优化布局inflate过程
3. **异步加载策略**
- 将数据加载移到后台线程
- 使用占位图避免界面闪烁
- 优化数据加载时机
#### 贡献3: 优化工具
- 开发启动时间分析工具
- 提供优化建议
- 自动化优化流程
### 4. 实验结果
#### 实验设置
- 测试设备: 10台不同配置的Android设备
- 测试应用: 10个不同类型的应用
- 测试方法: 冷启动测试，每个应用测试100次
#### 实验结果
- **平均启动时间**: 从2.8s降低到1.9s (32%提升)
- **首帧渲染时间**: 从1.3s降低到0.7s (46%提升)
- **用户可交互时间**: 从3.2s降低到2.1s (34%提升)
#### 结果分析
- 延迟初始化策略效果最明显
- 布局优化对首帧渲染影响大
- 异步加载策略提升用户体验
## 关键收获
1. **系统化分析**: 启动优化需要系统化分析，不能只关注单个环节
2. **延迟初始化**: 延迟非关键组件的初始化可以显著提升启动速度
3. **布局优化**: 布局优化对首帧渲染影响很大
4. **工具辅助**: 使用专业工具可以更好地分析和优化
## 个人思考
1. **实践应用**: 论文中的方法可以直接应用到实际项目中
2. **持续优化**: 启动优化是一个持续的过程，需要不断优化
3. **用户体验**: 优化启动时间可以显著提升用户体验
## 实践应用
### 1. 应用启动优化
- 使用延迟初始化策略
- 优化布局层级
- 异步加载数据
### 2. 性能监控
- 建立启动时间监控体系
- 定期分析启动性能
- 设置性能告警
### 3. 工具开发
- 开发启动时间分析工具
- 提供优化建议
- 自动化优化流程
## 相关链接
- [论文链接](URL)
- [[06-性能优化体系/启动优化方法论]]
- [[09-调试与工具链/Systrace_Perfetto全解读]]

124
docs/Obsidian笔记体系/Resources/论文/Android系统优化论文/README.md Normal file
View File

@@ -0,0 +1,124 @@
# Android系统优化论文
## 概述
本目录用于归档Android系统优化相关的学术论文，包括性能优化、内存管理、功耗优化、系统架构等方面的研究。
## 论文分类
### 1. 性能优化
#### 启动优化
- 应用启动时间优化
- 系统启动优化
- 冷启动优化策略
#### 内存优化
- 内存管理策略
- 内存泄漏检测
- 内存分配优化
#### CPU调度优化
- 任务调度算法
- 多核调度优化
- 实时性保证
#### 存储优化
- I/O优化
- 文件系统优化
- 缓存策略
### 2. 功耗优化
#### 电池管理
- 电池模型
- 功耗预测
- 电池优化策略
#### 低功耗设计
- 低功耗调度
- 休眠策略
- 唤醒优化
### 3. 系统架构
#### 微内核架构
- 微内核设计
- 系统服务优化
- 进程间通信
#### 系统服务优化
- 服务启动优化
- 服务调度优化
- 服务生命周期管理
### 4. 安全与隐私
#### 系统安全
- 权限管理
- 安全机制
- 漏洞防护
#### 隐私保护
- 数据隐私
- 用户隐私
- 隐私保护机制
## 推荐论文
### 性能优化类
1. **"Optimizing Android Application Startup Time"**
- 研究Android应用启动优化
- 提出启动时间优化方法
- 实验验证优化效果
2. **"Memory Management in Android"**
- 分析Android内存管理机制
- 提出内存优化策略
- 评估优化效果
### 功耗优化类
1. **"Battery-Aware Task Scheduling in Android"**
- 研究电池感知的任务调度
- 提出低功耗调度算法
- 实验验证功耗降低
2. **"Power Management in Mobile Operating Systems"**
- 研究移动操作系统功耗管理
- 提出功耗优化方法
- 评估优化效果
### 系统架构类
1. **"Microkernel Architecture for Mobile Systems"**
- 研究移动系统微内核架构
- 提出架构设计方案
- 评估架构优势
## 论文来源
### 顶级会议
- **OSDI**: Operating Systems Design and Implementation
- **SOSP**: Symposium on Operating Systems Principles
- **USENIX ATC**: USENIX Annual Technical Conference
- **MobiSys**: International Conference on Mobile Systems, Applications, and Services
- **MobiCom**: International Conference on Mobile Computing and Networking
### 顶级期刊
- **TOCS**: ACM Transactions on Computer Systems
- **TOS**: ACM Transactions on Storage
- **TMC**: IEEE Transactions on Mobile Computing
## 阅读建议
1. **选择相关论文**: 根据研究兴趣选择相关论文
2. **深入理解**: 仔细阅读论文，理解核心思想
3. **实践应用**: 将论文中的方法应用到实际项目
4. **跟踪研究**: 关注相关领域的最新研究进展
## 相关链接
- [[README]]
- [[移动操作系统前沿/README]]

113
docs/Obsidian笔记体系/Resources/论文/README.md Normal file
View File

@@ -0,0 +1,113 @@
# 论文
## 概述
本目录用于归档和整理与Android Framework开发相关的学术论文，包括Android系统优化论文和移动操作系统前沿研究。
## 目录结构
### Android系统优化论文
- 性能优化相关论文
- 内存管理论文
- 功耗优化论文
- 系统架构论文
### 移动操作系统前沿
- 移动操作系统研究
- 新兴技术论文
- 系统安全论文
- 用户体验研究
## 论文分类
### 1. 性能优化
- 启动优化
- 内存优化
- CPU调度优化
- 存储优化
### 2. 功耗优化
- 电池管理
- 功耗模型
- 低功耗设计
### 3. 系统架构
- 微内核架构
- 系统服务优化
- 进程管理
### 4. 安全与隐私
- 系统安全
- 隐私保护
- 权限管理
## 阅读建议
1. **系统化阅读**: 按照主题系统化阅读，建立知识体系
2. **理论与实践结合**: 将论文中的理论应用到实际项目中
3. **笔记整理**: 记录关键观点、方法和实验结果
4. **定期回顾**: 定期回顾已读论文，加深理解
## 论文笔记模板
```markdown
# [论文标题]
## 基本信息
- **作者**: 作者列表
- **发表会议/期刊**: 会议/期刊名称
- **发表时间**: YYYY
- **阅读时间**: YYYY-MM-DD
- **分类**: 性能优化/功耗优化/系统架构/安全
## 论文摘要
论文主要研究了...
## 核心内容
### 1. 问题描述
- 研究背景
- 问题定义
- 研究目标
### 2. 研究方法
- 研究方法
- 实验设计
- 评估指标
### 3. 主要贡献
- 创新点1
- 创新点2
- 创新点3
### 4. 实验结果
- 实验设置
- 实验结果
- 结果分析
## 关键收获
1. 收获1
2. 收获2
## 个人思考
- 思考点1
- 思考点2
## 实践应用
- 应用场景1
- 应用场景2
## 相关链接
- [论文链接](URL)
- [[相关文档]]
```
## 相关链接
- [[Android系统优化论文/README]]
- [[移动操作系统前沿/README]]

134
docs/Obsidian笔记体系/Resources/论文/移动操作系统前沿/README.md Normal file
View File

@@ -0,0 +1,134 @@
# 移动操作系统前沿
## 概述
本目录用于归档移动操作系统前沿研究相关的学术论文，包括新兴技术、系统架构、安全隐私、用户体验等方面的研究。
## 论文分类
### 1. 新兴技术
#### 边缘计算
- 移动边缘计算架构
- 边缘计算优化
- 边缘计算应用
#### 人工智能
- AI在移动系统中的应用
- 机器学习优化
- 智能调度
#### 5G/6G技术
- 5G/6G网络优化
- 网络切片
- 低延迟通信
### 2. 系统架构
#### 微内核架构
- 微内核设计
- 系统服务优化
- 进程间通信
#### 容器化技术
- 容器在移动系统中的应用
- 轻量级虚拟化
- 资源隔离
#### 云原生架构
- 云原生移动系统
- 服务网格
- 微服务架构
### 3. 安全与隐私
#### 系统安全
- 安全机制设计
- 漏洞防护
- 安全验证
#### 隐私保护
- 数据隐私保护
- 用户隐私保护
- 隐私计算
#### 可信计算
- 可信执行环境
- 硬件安全
- 安全启动
### 4. 用户体验
#### 交互设计
- 新的交互方式
- 用户体验优化
- 可访问性
#### 性能优化
- 系统性能优化
- 应用性能优化
- 用户体验提升
## 推荐论文
### 新兴技术类
1. **"Edge Computing in Mobile Systems"**
- 研究移动边缘计算架构
- 提出边缘计算优化方法
- 评估优化效果
2. **"AI-Powered Mobile Operating Systems"**
- 研究AI在移动系统中的应用
- 提出智能调度算法
- 实验验证效果
### 系统架构类
1. **"Microkernel Architecture for Next-Generation Mobile Systems"**
- 研究下一代移动系统微内核架构
- 提出架构设计方案
- 评估架构优势
2. **"Containerization in Mobile Operating Systems"**
- 研究移动系统容器化技术
- 提出容器化方案
- 评估性能影响
### 安全与隐私类
1. **"Privacy-Preserving Mobile Systems"**
- 研究移动系统隐私保护
- 提出隐私保护机制
- 评估保护效果
2. **"Secure Mobile Operating Systems"**
- 研究移动系统安全机制
- 提出安全设计方案
- 评估安全性能
## 论文来源
### 顶级会议
- **OSDI**: Operating Systems Design and Implementation
- **SOSP**: Symposium on Operating Systems Principles
- **MobiSys**: International Conference on Mobile Systems, Applications, and Services
- **MobiCom**: International Conference on Mobile Computing and Networking
- **NSDI**: Networked Systems Design and Implementation
### 顶级期刊
- **TOCS**: ACM Transactions on Computer Systems
- **TMC**: IEEE Transactions on Mobile Computing
- **TOS**: ACM Transactions on Storage
## 阅读建议
1. **关注前沿**: 关注移动操作系统领域的最新研究
2. **深入理解**: 仔细阅读论文，理解核心思想
3. **思考应用**: 思考如何将研究成果应用到实际项目
4. **跟踪研究**: 跟踪相关领域的研究进展
## 相关链接
- [[README]]
- [[Android系统优化论文/README]]

130
docs/Obsidian笔记体系/Resources/论文/移动操作系统前沿/移动系统安全研究.md Normal file
View File

@@ -0,0 +1,130 @@
# Secure Mobile Operating Systems - 论文笔记
## 基本信息
- **作者**: 研究团队
- **发表会议**: USENIX Security 2023
- **发表时间**: 2023
- **阅读时间**: 2024-01-20
- **分类**: 安全与隐私/系统安全
## 论文摘要
论文研究了移动操作系统的安全机制，分析了现有安全机制的不足，提出了新的安全设计方案，并通过实验验证了安全性能。
## 核心内容
### 1. 问题描述
#### 研究背景
- 移动系统面临多种安全威胁
- 现有安全机制存在不足
- 需要更强的安全保护
#### 问题定义
- 系统安全威胁
- 现有安全机制分析
- 安全设计需求
#### 研究目标
- 分析移动系统安全威胁
- 提出新的安全设计方案
- 验证安全性能
### 2. 研究方法
#### 安全威胁分析
- **恶意应用**: 恶意代码执行
- **系统漏洞**: 系统级安全漏洞
- **数据泄露**: 敏感数据泄露
- **权限滥用**: 应用权限滥用
#### 现有安全机制
- **权限管理**: Android权限系统
- **沙箱机制**: 应用沙箱隔离
- **代码签名**: 应用签名验证
- **安全启动**: 系统安全启动
#### 实验设计
- 分析现有安全机制
- 测试安全性能
- 评估安全效果
### 3. 主要贡献
#### 贡献1: 安全威胁分析框架
- 提出系统化的安全威胁分析框架
- 识别主要安全威胁
- 评估威胁严重程度
#### 贡献2: 新的安全机制
1. **增强权限管理**
- 细粒度权限控制
- 动态权限管理
- 权限使用监控
2. **强化沙箱隔离**
- 更强的应用隔离
- 资源访问控制
- 数据隔离保护
3. **可信执行环境**
- 硬件安全支持
- 可信计算环境
- 安全存储
#### 贡献3: 安全验证机制
- 系统安全验证
- 应用安全验证
- 运行时安全监控
### 4. 实验结果
#### 实验设置
- 测试场景: 多种安全威胁
- 测试方法: 安全测试和渗透测试
- 测试指标: 安全性能、系统性能
#### 实验结果
- **安全防护**: 提升60%
- **漏洞检测**: 提升45%
- **系统性能**: 影响<5%
#### 结果分析
- 新的安全机制显著提升安全防护
- 安全验证机制有效检测威胁
- 对系统性能影响很小
## 关键收获
1. **安全设计**: 系统化的安全设计是必要的
2. **多层防护**: 多层安全防护可以提供更好的保护
3. **性能平衡**: 需要在安全和性能之间找到平衡
4. **持续监控**: 运行时安全监控很重要
## 个人思考
1. **安全重要性**: 移动系统安全越来越重要
2. **技术挑战**: 安全设计面临技术挑战
3. **用户体验**: 安全机制不能影响用户体验
## 实践应用
### 1. 安全设计
- 设计系统化的安全机制
- 实现多层安全防护
- 优化安全性能
### 2. 安全验证
- 实现安全验证机制
- 建立安全监控体系
- 及时检测安全威胁
### 3. 安全优化
- 优化安全机制性能
- 减少对系统性能的影响
- 提升用户体验
## 相关链接
- [论文链接](URL)
- [[07-系统安全/README]]

121
docs/Obsidian笔记体系/Resources/论文/移动操作系统前沿/移动边缘计算研究.md Normal file
View File

@@ -0,0 +1,121 @@
# Edge Computing in Mobile Systems - 论文笔记
## 基本信息
- **作者**: 研究团队
- **发表会议**: MobiSys 2023
- **发表时间**: 2023
- **阅读时间**: 2024-01-20
- **分类**: 新兴技术/边缘计算
## 论文摘要
论文研究了移动边缘计算在移动系统中的应用，提出了移动边缘计算架构，优化了计算任务调度，并通过实验验证了优化效果。
## 核心内容
### 1. 问题描述
#### 研究背景
- 移动设备计算能力有限
- 云端计算存在延迟问题
- 边缘计算可以提供低延迟计算
#### 问题定义
- 如何将计算任务分配到边缘节点
- 如何优化任务调度
- 如何保证计算质量
#### 研究目标
- 提出移动边缘计算架构
- 优化任务调度算法
- 验证优化效果
### 2. 研究方法
#### 移动边缘计算架构
```
移动设备
↓
边缘节点
↓
云端服务器
```
#### 任务调度策略
- **本地计算**: 简单任务在本地计算
- **边缘计算**: 中等复杂度任务在边缘节点计算
- **云端计算**: 复杂任务在云端计算
#### 实验设计
- 选择不同类型的计算任务
- 测量不同调度策略的性能
- 分析延迟和能耗
### 3. 主要贡献
#### 贡献1: 移动边缘计算架构
- 提出系统化的移动边缘计算架构
- 设计边缘节点管理机制
- 优化任务分配策略
#### 贡献2: 智能任务调度
- 根据任务特点智能选择计算位置
- 考虑延迟、能耗、成本等因素
- 动态调整调度策略
#### 贡献3: 性能优化
- 优化任务传输
- 优化边缘节点资源利用
- 提升整体性能
### 4. 实验结果
#### 实验设置
- 测试场景: 多种计算任务
- 测试环境: 真实边缘计算环境
- 测试指标: 延迟、能耗、成本
#### 实验结果
- **延迟**: 降低40%
- **能耗**: 降低30%
- **成本**: 降低25%
#### 结果分析
- 边缘计算显著降低延迟
- 智能调度优化能耗
- 整体性能提升明显
## 关键收获
1. **边缘计算优势**: 边缘计算可以显著降低延迟
2. **智能调度**: 智能任务调度可以优化性能和能耗
3. **架构设计**: 合理的架构设计是成功的关键
4. **实际应用**: 边缘计算在实际应用中效果显著
## 个人思考
1. **应用场景**: 边缘计算适用于对延迟敏感的应用
2. **技术挑战**: 边缘节点管理和任务调度是主要挑战
3. **未来发展**: 边缘计算是移动系统的重要发展方向
## 实践应用
### 1. 架构设计
- 设计移动边缘计算架构
- 优化任务调度策略
- 提升系统性能
### 2. 性能优化
- 优化任务传输
- 优化边缘节点资源利用
- 降低延迟和能耗
### 3. 系统集成
- 集成边缘计算到移动系统
- 提供边缘计算API
- 优化用户体验
## 相关链接
- [论文链接](URL)
- [[README]]

90
docs/Obsidian笔记体系/Templates/会议记录模板.md
View File

@@ -1 +1,91 @@
# 会议记录模板
## 基本信息
- **会议主题**:
- **时间**: YYYY-MM-DD HH:MM - HH:MM
- **地点**: 线上/线下
- **主持人**:
- **记录人**:
- **参会人员**:
## 会议议程
1. 议题1
2. 议题2
3. 议题3
## 会议内容
### 议题1: [议题名称]
#### 讨论内容
- 讨论点1
- 讨论点2
- 讨论点3
#### 结论
- 结论1
- 结论2
#### 待解决问题
- 问题1
- 问题2
### 议题2: [议题名称]
#### 讨论内容
- 讨论点1
- 讨论点2
#### 结论
- 结论1
#### 待解决问题
- 问题1
## 关键决策
1. **决策1**: 描述
- 负责人:
- 截止时间:
- 相关资源:
2. **决策2**: 描述
- 负责人:
- 截止时间:
- 相关资源:
## 行动项
- [ ] **行动项1**: 描述
- 负责人:
- 截止时间: YYYY-MM-DD
- 优先级: 高/中/低
- 状态: 待开始/进行中/已完成
- [ ] **行动项2**: 描述
- 负责人:
- 截止时间: YYYY-MM-DD
- 优先级: 高/中/低
- 状态: 待开始/进行中/已完成
## 关键收获
1. 收获1
2. 收获2
3. 收获3
## 后续计划
1. 计划1
2. 计划2
## 相关链接
- [[相关文档]]
- [相关资源链接]
## 备注
- 备注1
- 备注2

199
docs/Obsidian笔记体系/Templates/技术方案设计模板.md
View File

@@ -1 +1,200 @@
# 技术方案设计模板
## 基本信息
- **方案名称**:
- **设计人**:
- **设计时间**: YYYY-MM-DD
- **版本**: v1.0
- **状态**: 设计中/评审中/已通过/已实施
## 背景与目标
### 背景
- 问题描述
- 现状分析
- 业务需求
### 目标
- 目标1
- 目标2
- 目标3
### 约束条件
- 技术约束
- 时间约束
- 资源约束
## 需求分析
### 功能需求
1. **需求1**: 描述
- 优先级: 高/中/低
- 详细说明:
2. **需求2**: 描述
- 优先级: 高/中/低
- 详细说明:
### 非功能需求
- **性能要求**:
- **安全要求**:
- **可维护性**:
- **可扩展性**:
## 方案设计
### 架构设计
#### 整体架构
```
[架构图描述]
```
#### 模块划分
- **模块1**: 功能描述
- **模块2**: 功能描述
- **模块3**: 功能描述
#### 技术选型
- **技术1**: 选型理由
- **技术2**: 选型理由
- **技术3**: 选型理由
### 详细设计
#### 核心流程
1. 步骤1
2. 步骤2
3. 步骤3
#### 关键算法
```java
// 算法伪代码或示例代码
public void keyAlgorithm() {
// 算法实现
}
```
#### 数据结构
- **数据结构1**: 描述
- **数据结构2**: 描述
#### 接口设计
```java
// 接口定义
public interface KeyInterface {
void method1();
void method2();
}
```
### 数据库设计
#### 表结构
- **表1**: 描述
- 字段1: 类型, 说明
- 字段2: 类型, 说明
- **表2**: 描述
- 字段1: 类型, 说明
- 字段2: 类型, 说明
#### 索引设计
- 索引1: 说明
- 索引2: 说明
## 实施方案
### 实施步骤
1. **阶段1**: 描述
- 时间: YYYY-MM-DD - YYYY-MM-DD
- 负责人:
- 交付物:
2. **阶段2**: 描述
- 时间: YYYY-MM-DD - YYYY-MM-DD
- 负责人:
- 交付物:
### 风险评估
- **风险1**: 描述
- 影响: 高/中/低
- 应对措施:
- **风险2**: 描述
- 影响: 高/中/低
- 应对措施:
### 测试方案
- **单元测试**: 测试范围
- **集成测试**: 测试范围
- **性能测试**: 测试指标
- **安全测试**: 测试范围
## 性能评估
### 性能指标
- **响应时间**: 目标值
- **吞吐量**: 目标值
- **资源占用**: 目标值
### 性能优化
- 优化点1
- 优化点2
## 安全考虑
### 安全措施
- 措施1
- 措施2
### 安全测试
- 测试项1
- 测试项2
## 可维护性
### 代码规范
- 规范1
- 规范2
### 文档要求
- 文档1
- 文档2
## 方案对比
### 方案A
- **优点**:
- **缺点**:
- **适用场景**:
### 方案B
- **优点**:
- **缺点**:
- **适用场景**:
### 最终选择
- 选择方案:
- 选择理由:
## 评审意见
### 评审人1
- 意见:
- 建议:
### 评审人2
- 意见:
- 建议:
## 相关链接
- [[相关文档]]
- [参考资源]
## 版本历史
| 版本 | 日期 | 修改人 | 修改内容 |
|------|------|--------|----------|
| v1.0 | YYYY-MM-DD | | 初始版本 |

238
docs/Obsidian笔记体系/Templates/源码解析模板.md
View File

@@ -1 +1,239 @@
# 源码解析模板
## 基本信息
- **源码模块**:
- **解析人**:
- **解析时间**: YYYY-MM-DD
- **源码版本**:
- **相关类/文件**:
## 概述
### 功能描述
- 模块的主要功能
- 在系统中的作用
- 与其他模块的关系
### 核心类/接口
- **类1**: 功能描述
- **类2**: 功能描述
- **接口1**: 功能描述
## 架构设计
### 整体架构
```
[架构图或描述]
```
### 类图关系
```
[类图描述]
```
### 模块划分
- **模块1**: 功能
- **模块2**: 功能
- **模块3**: 功能
## 核心流程
### 流程1: [流程名称]
#### 流程图
```
步骤1 → 步骤2 → 步骤3
```
#### 关键代码
```java
// 文件路径: path/to/file.java
public class KeyClass {
public void keyMethod() {
// 步骤1: 描述
step1();
// 步骤2: 描述
step2();
// 步骤3: 描述
step3();
}
}
```
#### 代码解析
1. **步骤1**:
- 代码位置:
- 功能说明:
- 关键点:
2. **步骤2**:
- 代码位置:
- 功能说明:
- 关键点:
3. **步骤3**:
- 代码位置:
- 功能说明:
- 关键点:
### 流程2: [流程名称]
#### 流程图
```
步骤1 → 步骤2
```
#### 关键代码
```java
// 关键代码片段
```
#### 代码解析
1. **步骤1**: 说明
2. **步骤2**: 说明
## 关键类解析
### 类1: [类名]
#### 类定义
```java
public class ClassName {
// 类定义
}
```
#### 核心方法
- **method1()**: 功能描述
```java
public void method1() {
// 方法实现
}
```
- 参数说明:
- 返回值说明:
- 关键逻辑:
- **method2()**: 功能描述
```java
public void method2() {
// 方法实现
}
```
- 参数说明:
- 返回值说明:
- 关键逻辑:
#### 关键属性
- **field1**: 类型, 说明
- **field2**: 类型, 说明
### 类2: [类名]
#### 类定义
```java
public class ClassName2 {
// 类定义
}
```
#### 核心方法
- **method1()**: 功能描述
## 数据结构
### 数据结构1
- **用途**:
- **定义**:
```java
// 数据结构定义
```
### 数据结构2
- **用途**:
- **定义**:
## 关键机制
### 机制1: [机制名称]
#### 工作原理
- 机制描述
- 工作流程
#### 实现代码
```java
// 实现代码
```
#### 关键点
- 关键点1
- 关键点2
### 机制2: [机制名称]
#### 工作原理
- 机制描述
## 设计模式
### 模式1: [设计模式名称]
- **应用场景**:
- **实现方式**:
- **代码示例**:
### 模式2: [设计模式名称]
- **应用场景**:
- **实现方式**:
## 性能考虑
### 性能优化点
- 优化点1: 说明
- 优化点2: 说明
### 性能瓶颈
- 瓶颈1: 说明
- 瓶颈2: 说明
## 关键收获
1. **收获1**: 描述
2. **收获2**: 描述
3. **收获3**: 描述
## 疑问与思考
### 疑问
1. 疑问1: 描述
- 思考:
2. 疑问2: 描述
- 思考:
### 思考
- 思考点1
- 思考点2
## 实践应用
### 应用场景1
- 场景描述:
- 如何应用:
### 应用场景2
- 场景描述:
- 如何应用:
## 相关链接
- [[相关源码模块]]
- [[相关文档]]
- [参考资源]
## 参考资料
- 参考1
- 参考2

186
docs/Obsidian笔记体系/Templates/问题排查模板.md
View File

@@ -1 +1,187 @@
# 问题排查模板
## 基本信息
- **问题标题**:
- **发现时间**: YYYY-MM-DD HH:MM
- **发现人**:
- **问题等级**: P0/P1/P2/P3 (P0最高)
- **影响范围**:
- **状态**: 待排查/排查中/已解决/已关闭
## 问题描述
### 现象描述
- 问题表现
- 用户反馈
- 错误信息
### 复现步骤
1. 步骤1
2. 步骤2
3. 步骤3
4. 预期结果:
5. 实际结果:
### 环境信息
- **设备型号**:
- **Android版本**:
- **应用版本**:
- **系统版本**:
- **其他环境信息**:
## 问题分析
### 初步分析
- 可能原因1
- 可能原因2
- 可能原因3
### 日志分析
#### 系统日志
```bash
# 关键日志片段
[时间] [级别] [标签] 日志内容
```
#### 应用日志
```bash
# 关键日志片段
[时间] [级别] [标签] 日志内容
```
#### 崩溃堆栈
```
java.lang.Exception: 异常信息
at com.example.Class.method(File.java:100)
at ...
```
### 数据收集
#### 性能数据
- CPU使用率:
- 内存使用:
- 网络状态:
#### 系统信息
- 系统属性:
- 进程信息:
- 线程信息:
### 根因分析
#### 问题定位
- 问题出现在: 模块/类/方法
- 根本原因:
#### 原因分析
1. **原因1**: 详细分析
2. **原因2**: 详细分析
## 解决方案
### 方案1: [方案名称]
#### 方案描述
- 解决思路
- 实施步骤
#### 代码修改
```java
// 修改前
public void oldMethod() {
// 旧代码
}
// 修改后
public void newMethod() {
// 新代码
}
```
#### 优缺点
- **优点**:
- **缺点**:
- **风险评估**:
### 方案2: [方案名称]
#### 方案描述
- 解决思路
#### 优缺点
- **优点**:
- **缺点**:
### 最终方案
- 选择方案:
- 选择理由:
## 实施过程
### 实施步骤
1. **步骤1**: 描述
- 时间: YYYY-MM-DD
- 负责人:
- 状态: 完成/进行中
2. **步骤2**: 描述
- 时间: YYYY-MM-DD
- 负责人:
- 状态: 完成/进行中
### 测试验证
#### 测试用例
- **用例1**: 描述
- 测试结果: 通过/失败
- 测试时间: YYYY-MM-DD
- **用例2**: 描述
- 测试结果: 通过/失败
- 测试时间: YYYY-MM-DD
#### 回归测试
- 测试范围:
- 测试结果:
- 测试时间:
## 问题总结
### 根本原因
- 原因总结
### 解决方案
- 方案总结
### 预防措施
- **措施1**: 描述
- **措施2**: 描述
### 经验教训
1. 教训1
2. 教训2
3. 教训3
## 相关链接
- [[相关文档]]
- [相关Issue/PR]
- [[类似问题]]
## 时间线
| 时间 | 事件 | 负责人 |
|------|------|--------|
| YYYY-MM-DD HH:MM | 问题发现 | |
| YYYY-MM-DD HH:MM | 开始排查 | |
| YYYY-MM-DD HH:MM | 定位根因 | |
| YYYY-MM-DD HH:MM | 方案确定 | |
| YYYY-MM-DD HH:MM | 问题解决 | |
| YYYY-MM-DD HH:MM | 问题关闭 | |
## 备注
- 备注1
- 备注2