-

「Generated by Manus, instructions issued by binbinwang」

本章将探讨Android开发中的高级主题和最佳实践，并与iOS的对应技术进行对比。作为一名iOS开发者，了解Android平台的高级特性将帮助你更好地设计和优化跨平台应用。

9.1 性能优化

Android性能优化技巧

Android应用性能优化涉及多个方面，包括UI渲染、内存管理、电池使用和应用启动时间：

UI渲染优化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
// 1. 使用Systrace分析UI性能
// 在命令行中执行
// $ python systrace.py -t 10 -a com.example.app gfx view res

// 2. 避免过度绘制
// 在开发者选项中启用"显示过度绘制区域"

// 3. 使用Hierarchy Viewer分析视图层次结构
// 在Android Studio中使用Layout Inspector

// 4. 优化布局
// 使用ConstraintLayout减少嵌套
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    
    <TextView
        android:id="@+id/title"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="Title"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent" />
    
    <ImageView
        android:id="@+id/image"
        android:layout_width="0dp"
        android:layout_height="200dp"
        app:layout_constraintTop_toBottomOf="@id/title"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent" />
    
    <!-- 更多视图 -->
    
</androidx.constraintlayout.widget.ConstraintLayout>

// 5. 使用ViewHolder模式优化RecyclerView
class MyAdapter : RecyclerView.Adapter<MyAdapter.ViewHolder>() {
    
    class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        val titleView: TextView = view.findViewById(R.id.title)
        val imageView: ImageView = view.findViewById(R.id.image)
        // 缓存视图引用
    }
    
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        // 仅在需要时创建新视图
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_layout, parent, false)
        return ViewHolder(view)
    }
    
    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        // 使用缓存的视图引用，避免findViewById
        holder.titleView.text = data[position].title
        holder.imageView.load(data[position].imageUrl)
    }
}

// 6. 使用硬件加速
// 在AndroidManifest.xml中启用
<application
    android:hardwareAccelerated="true"
    ...>
</application>

// 7. 使用自定义视图时优化onDraw方法
class CustomView : View {
    
    private val paint = Paint()
    private val path = Path()
    
    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        
        // 避免在onDraw中创建对象
        // 错误示例：val paint = Paint()
        
        // 避免在onDraw中进行复杂计算
        // 错误示例：calculateComplexPath()
        
        // 正确示例：使用预先计算的路径
        canvas.drawPath(path, paint)
    }
    
    // 在尺寸变化时预计算路径
    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        super.onSizeChanged(w, h, oldw, oldh)
        calculatePath(w, h)
    }
    
    private fun calculatePath(width: Int, height: Int) {
        // 计算路径
        path.reset()
        // 添加路径点
    }
}

内存优化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
// 1. 使用Memory Profiler分析内存使用
// 在Android Studio中使用Memory Profiler

// 2. 避免内存泄漏
// 常见内存泄漏：静态Activity引用
class MainActivity : AppCompatActivity() {
    
    companion object {
        // 错误示例：静态Activity引用
        private var instance: MainActivity? = null
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 错误示例：保存Activity引用
        instance = this
    }
}

// 3. 使用弱引用避免内存泄漏
class MainActivity : AppCompatActivity() {
    
    companion object {
        // 正确示例：使用弱引用
        private var weakReference: WeakReference<MainActivity>? = null
        
        fun getInstance(): MainActivity? {
            return weakReference?.get()
        }
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 使用弱引用
        weakReference = WeakReference(this)
    }
}

// 4. 避免匿名内部类导致的内存泄漏
class MainActivity : AppCompatActivity() {
    
    private val handler = Handler(Looper.getMainLooper())
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 错误示例：匿名内部类持有Activity引用
        button.setOnClickListener {
            handler.postDelayed({
                // 这里持有Activity引用
                updateUI()
            }, 10000) // 10秒后执行
        }
    }
    
    // 正确示例：使用静态内部类和弱引用
    private class MyHandler(activity: MainActivity) : Handler(Looper.getMainLooper()) {
        private val weakReference = WeakReference(activity)
        
        override fun handleMessage(msg: Message) {
            val activity = weakReference.get()
            if (activity != null) {
                activity.updateUI()
            }
        }
    }
    
    private val myHandler = MyHandler(this)
    
    // 正确示例：在onDestroy中移除回调
    override fun onDestroy() {
        super.onDestroy()
        handler.removeCallbacksAndMessages(null)
    }
}

// 5. 使用SparseArray代替HashMap
// 错误示例：使用HashMap<Integer, Object>
val map = HashMap<Int, String>()

// 正确示例：使用SparseArray
val sparseArray = SparseArray<String>()

// 6. 使用对象池复用对象
class ObjectPool<T>(
    private val maxSize: Int,
    private val factory: () -> T,
    private val reset: (T) -> Unit
) {
    private val pool = ArrayDeque<T>(maxSize)
    
    fun acquire(): T {
        return if (pool.isEmpty()) {
            factory()
        } else {
            pool.removeFirst()
        }
    }
    
    fun release(obj: T) {
        if (pool.size < maxSize) {
            reset(obj)
            pool.addLast(obj)
        }
    }
}

// 使用对象池
val rectPool = ObjectPool(
    maxSize = 50,
    factory = { Rect() },
    reset = { it.setEmpty() }
)

// 获取对象
val rect = rectPool.acquire()
// 使用对象
// ...
// 释放对象
rectPool.release(rect)

电池优化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
// 1. 使用Battery Historian分析电池使用
// 在命令行中执行
// $ adb bugreport > bugreport.zip
// 然后上传到Battery Historian

// 2. 优化后台任务
// 使用WorkManager代替直接使用Service
val uploadWorkRequest = OneTimeWorkRequestBuilder<UploadWorker>()
    .setConstraints(
        Constraints.Builder()
            .setRequiredNetworkType(NetworkType.UNMETERED)
            .setRequiresBatteryNotLow(true)
            .build()
    )
    .build()

WorkManager.getInstance(context).enqueue(uploadWorkRequest)

// 3. 批量处理网络请求
class SyncManager {
    
    private val pendingRequests = mutableListOf<Request>()
    private val handler = Handler(Looper.getMainLooper())
    private val syncRunnable = Runnable { performSync() }
    
    fun scheduleRequest(request: Request) {
        pendingRequests.add(request)
        
        // 取消之前的同步
        handler.removeCallbacks(syncRunnable)
        
        // 延迟5秒后执行同步，允许批量处理
        handler.postDelayed(syncRunnable, 5000)
    }
    
    private fun performSync() {
        if (pendingRequests.isEmpty()) return
        
        // 批量处理请求
        val requests = ArrayList(pendingRequests)
        pendingRequests.clear()
        
        // 执行批量请求
        executeBatchRequest(requests)
    }
}

// 4. 使用JobScheduler延迟非关键任务
val jobScheduler = context.getSystemService(Context.JOB_SCHEDULER_SERVICE) as JobScheduler

val jobInfo = JobInfo.Builder(JOB_ID, ComponentName(context, SyncJobService::class.java))
    .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED)
    .setRequiresCharging(true)
    .setPersisted(true)
    .build()

jobScheduler.schedule(jobInfo)

// 5. 使用Doze模式和App Standby
// 在AndroidManifest.xml中请求忽略电池优化
<uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />

// 检查是否忽略电池优化
val powerManager = getSystemService(POWER_SERVICE) as PowerManager
val isIgnoringBatteryOptimizations = powerManager.isIgnoringBatteryOptimizations(packageName)

// 请求忽略电池优化
if (!isIgnoringBatteryOptimizations) {
    val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
        data = Uri.parse("package:$packageName")
    }
    startActivity(intent)
}

应用启动优化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
// 1. 使用App Startup库初始化组件
// 添加依赖
// implementation "androidx.startup:startup-runtime:1.1.0"

// 创建初始化器
class TimberInitializer : Initializer<Unit> {
    
    override fun create(context: Context) {
        if (BuildConfig.DEBUG) {
            Timber.plant(Timber.DebugTree())
        }
    }
    
    override fun dependencies(): List<Class<out Initializer<*>>> {
        return emptyList()
    }
}

// 在AndroidManifest.xml中配置
<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data
        android:name="com.example.app.TimberInitializer"
        android:value="androidx.startup" />
</provider>

// 2. 延迟初始化非关键组件
class MyApplication : Application() {
    
    override fun onCreate() {
        super.onCreate()
        
        // 仅初始化关键组件
        initCriticalComponents()
        
        // 延迟初始化非关键组件
        Handler(Looper.getMainLooper()).postDelayed({
            initNonCriticalComponents()
        }, 3000)
    }
    
    private fun initCriticalComponents() {
        // 初始化关键组件
    }
    
    private fun initNonCriticalComponents() {
        // 初始化非关键组件
    }
}

// 3. 使用懒加载
class MyApplication : Application() {
    
    // 懒加载组件
    val analyticsManager by lazy {
        AnalyticsManager(this)
    }
    
    val databaseHelper by lazy {
        DatabaseHelper(this)
    }
}

// 4. 使用ContentProvider延迟初始化
class AppInitProvider : ContentProvider() {
    
    override fun onCreate(): Boolean {
        val context = context ?: return false
        
        // 在ContentProvider.onCreate中初始化
        // 这会在Application.onCreate之前执行
        
        return true
    }
    
    // 其他必须实现的方法
    override fun query(...) = null
    override fun getType(...) = null
    override fun insert(...) = null
    override fun delete(...) = 0
    override fun update(...) = 0
}

// 5. 使用异步初始化
class MyApplication : Application() {
    
    override fun onCreate() {
        super.onCreate()
        
        // 在后台线程初始化
        Thread {
            // 初始化耗时组件
        }.start()
    }
}

与iOS性能优化对比

iOS的性能优化技巧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
// UI渲染优化

// 1. 使用Instruments分析UI性能
// 在Xcode中使用Instruments的Core Animation工具

// 2. 避免离屏渲染
// Objective-C
- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 错误示例：导致离屏渲染
    self.imageView.layer.cornerRadius = 10.0;
    self.imageView.layer.masksToBounds = YES;
    
    // 正确示例：使用图片处理代替
    UIImage *originalImage = [UIImage imageNamed:@"profile"];
    UIImage *roundedImage = [self roundedImage:originalImage cornerRadius:10.0];
    self.imageView.image = roundedImage;
}

// 3. 优化视图层次结构
// 使用Xcode的View Debugger分析视图层次

// 4. 使用UITableViewCell重用机制
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    static NSString *CellIdentifier = @"Cell";
    
    // 重用单元格
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    
    if (cell == nil) {
        // 仅在需要时创建新单元格
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier];
    }
    
    // 配置单元格
    cell.textLabel.text = [self.dataArray objectAtIndex:indexPath.row];
    
    return cell;
}

// 5. 使用CALayer代替复杂的UIView
// 使用CALayer绘制简单图形，而不是创建自定义UIView

// 内存优化

// 1. 使用Instruments分析内存使用
// 在Xcode中使用Instruments的Allocations和Leaks工具

// 2. 避免循环引用
// 错误示例：循环引用
@interface MyViewController ()
@property (nonatomic, strong) MyHelper *helper;
@end

@implementation MyViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.helper = [[MyHelper alloc] init];
    self.helper.viewController = self; // 循环引用
}
@end

// 正确示例：使用弱引用
@interface MyHelper : NSObject
@property (nonatomic, weak) MyViewController *viewController;
@end

// 3. 使用自动释放池减少内存峰值
- (void)processLargeArray:(NSArray *)array {
    @autoreleasepool {
        for (id obj in array) {
            // 处理对象
            // 自动释放池会在每次循环后释放临时对象
        }
    }
}

// 4. 使用NSCache代替NSDictionary缓存对象
@interface ImageCache : NSObject
@property (nonatomic, strong) NSCache *imageCache;
@end

@implementation ImageCache
- (instancetype)init {
    self = [super init];
    if (self) {
        _imageCache = [[NSCache alloc] init];
        _imageCache.countLimit = 100; // 限制缓存对象数量
        _imageCache.totalCostLimit = 10 * 1024 * 1024; // 限制缓存大小（10MB）
    }
    return self;
}

- (UIImage *)imageForKey:(NSString *)key {
    return [_imageCache objectForKey:key];
}

- (void)setImage:(UIImage *)image forKey:(NSString *)key {
    [_imageCache setObject:image forKey:key cost:image.size.width * image.size.height * 4];
}
@end

// 电池优化

// 1. 使用Energy Gauge分析电池使用
// 在Xcode中使用Energy Gauge工具

// 2. 优化后台任务
// 使用后台任务API
- (void)scheduleBackgroundTask {
    BGTaskScheduler *scheduler = [BGTaskScheduler sharedScheduler];
    
    BGAppRefreshTaskRequest *request = [[BGAppRefreshTaskRequest alloc] initWithIdentifier:@"com.example.refresh"];
    request.earliestBeginDate = [NSDate dateWithTimeIntervalSinceNow:3600]; // 1小时后执行
    
    NSError *error = nil;
    if (![scheduler submitTaskRequest:request error:&error]) {
        NSLog(@"Failed to schedule task: %@", error);
    }
}

// 3. 批量处理网络请求
@interface SyncManager : NSObject
@property (nonatomic, strong) NSMutableArray *pendingRequests;
@property (nonatomic, strong) NSTimer *syncTimer;
@end

@implementation SyncManager
- (instancetype)init {
    self = [super init];
    if (self) {
        _pendingRequests = [NSMutableArray array];
    }
    return self;
}

- (void)scheduleRequest:(id)request {
    [self.pendingRequests addObject:request];
    
    // 取消之前的同步
    [self.syncTimer invalidate];
    
    // 延迟5秒后执行同步，允许批量处理
    self.syncTimer = [NSTimer scheduledTimerWithTimeInterval:5.0
                                                      target:self
                                                    selector:@selector(performSync)
                                                    userInfo:nil
                                                     repeats:NO];
}

- (void)performSync {
    if ([self.pendingRequests count] == 0) return;
    
    // 批量处理请求
    NSArray *requests = [NSArray arrayWithArray:self.pendingRequests];
    [self.pendingRequests removeAllObjects];
    
    // 执行批量请求
    [self executeBatchRequest:requests];
}
@end

// 应用启动优化

// 1. 使用Instruments分析启动时间
// 在Xcode中使用Instruments的Time Profiler工具

// 2. 延迟初始化非关键组件
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // 仅初始化关键组件
    [self initCriticalComponents];
    
    // 延迟初始化非关键组件
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        [self initNonCriticalComponents];
    });
    
    return YES;
}

// 3. 使用懒加载
@interface AppDelegate ()
@property (nonatomic, strong, readonly) AnalyticsManager *analyticsManager;
@end

@implementation AppDelegate
- (AnalyticsManager *)analyticsManager {
    if (!_analyticsManager) {
        _analyticsManager = [[AnalyticsManager alloc] init];
    }
    return _analyticsManager;
}
@end

// 4. 使用异步初始化
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // 在后台队列初始化
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 初始化耗时组件
    });
    
    return YES;
}

主要差异：

  1. Android使用Systrace和Memory Profiler，而iOS使用Instruments
  2. Android的UI渲染优化关注过度绘制和视图层次，而iOS关注离屏渲染
  3. Android使用WorkManager和JobScheduler优化后台任务，而iOS使用BGTaskScheduler
  4. Android的内存优化使用SparseArray和对象池，而iOS使用NSCache和自动释放池
  5. Android的应用启动优化使用ContentProvider和App Startup，而iOS主要依赖懒加载和异步初始化