深入分析 Android Activity (五)

文章目录

- - 深入分析 Android Activity (五)
  - 1. Activity 的进程和线程模型
  - - 1.1 主线程与 UI 操作
    - 1.2 使用 AsyncTask
    - 1.3 使用 Handler 和 Looper
  - 2. Activity 的内存优化
  - - 2.1 避免内存泄漏
    - 2.2 使用内存分析工具
    - 2.3 优化 Bitmap 使用
  - 3. Activity 的跨进程通信（IPC）
  - - 3.1 使用 AIDL
  - 4. 深入理解 Activity 的配置变化处理
  - - 4.1 在 Manifest 文件中声明配置变化
    - 4.2 重写 `onConfigurationChanged` 方法
  - 5. Activity 的调试和日志记录
  - - 5.1 使用 Logcat
    - 5.2 使用调试工具
  - 6. Activity 的单元测试和 UI 测试
  - - 6.1 使用 JUnit 进行单元测试
    - 6.2 使用 Espresso 进行 UI 测试
  - 总结

深入分析 Android Activity (五)

1. Activity 的进程和线程模型

在 Android 中，Activity 默认在主线程（也称为 UI 线程）中运行。理解进程和线程模型对于开发响应迅速且无阻塞的应用程序至关重要。

1.1 主线程与 UI 操作

所有 UI 操作必须在主线程中执行，以避免并发问题和 UI 不一致性。长时间的操作应在工作线程中完成，并使用主线程处理结果。

// Performing a long-running operation on a background thread
new Thread(new Runnable() {
    @Override
    public void run() {
        // Long-running operation
        final String result = performOperation();
        
        // Post result back to the main thread
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                // Update UI with the result
                textView.setText(result);
            }
        });
    }
}).start();

1.2 使用 AsyncTask

AsyncTask 是一种方便的方式，可以在后台线程中执行操作，并在主线程中处理结果。不过，由于其容易导致内存泄漏和其他问题，现在更推荐使用 ExecutorService 或 RxJava。

private class MyAsyncTask extends AsyncTask<Void, Void, String> {
    @Override
    protected String doInBackground(Void... voids) {
        return performOperation();
    }

    @Override
    protected void onPostExecute(String result) {
        textView.setText(result);
    }
}

// Execute the AsyncTask
new MyAsyncTask().execute();

1.3 使用 Handler 和 Looper

Handler 和 Looper 提供了一种灵活的方法来管理线程间通信。

// Creating a Handler on the main thread
Handler handler = new Handler(Looper.getMainLooper());

// Running code on the main thread
handler.post(new Runnable() {
    @Override
    public void run() {
        // Update UI
        textView.setText("Updated from background thread");
    }
});

2. Activity 的内存优化

内存管理是 Android 开发中的一个重要方面，特别是在设备资源有限的情况下。以下是一些常见的内存优化技巧。

2.1 避免内存泄漏

使用弱引用和上下文的短生命周期对象可以避免内存泄漏。避免在 Activity 和 Fragment 中直接引用长生命周期对象，如单例模式。

// Use WeakReference to avoid memory leaks
private static class MyHandler extends Handler {
    private final WeakReference<MyActivity> mActivity;

    MyHandler(MyActivity activity) {
        mActivity = new WeakReference<>(activity);
    }

    @Override
    public void handleMessage(Message msg) {
        MyActivity activity = mActivity.get();
        if (activity != null) {
            // Handle message
        }
    }
}

2.2 使用内存分析工具

Android Studio 提供了内存分析工具，可以帮助检测和解决内存泄漏。

// Use Android Profiler to detect memory leaks

2.3 优化 Bitmap 使用

Bitmaps 是常见的内存消耗大户。使用适当的压缩和回收策略来优化 Bitmap 使用。

// Decode bitmap with inSampleSize to reduce memory usage
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 2;
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.large_image, options);

// Recycle bitmap to free memory
bitmap.recycle();

3. Activity 的跨进程通信（IPC）

在 Android 中，跨进程通信通常使用 AIDL（Android Interface Definition Language）、Messenger 或 ContentProvider 来实现。

3.1 使用 AIDL

AIDL 提供了一种定义接口以便在不同进程之间通信的方法。

// IMyAidlInterface.aidl
interface IMyAidlInterface {
    void performAction();
}

实现 AIDL 接口：

public class MyService extends Service {
    private final IMyAidlInterface.Stub mBinder = new IMyAidlInterface.Stub() {
        @Override
        public void performAction() {
            // Perform action
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
}

在客户端绑定服务：

private IMyAidlInterface mService;

private ServiceConnection mConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName className, IBinder service) {
        mService = IMyAidlInterface.Stub.asInterface(service);
    }

    @Override
    public void onServiceDisconnected(ComponentName className) {
        mService = null;
    }
};

// Bind to the service
Intent intent = new Intent(this, MyService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);

4. 深入理解 Activity 的配置变化处理

配置变化（如屏幕旋转、语言更改等）会导致 Activity 被销毁并重新创建。开发者可以通过重写 onConfigurationChanged 方法来处理特定配置变化，避免 Activity 重新创建。

4.1 在 Manifest 文件中声明配置变化

<activity android:name=".MyActivity"
    android:configChanges="orientation|screenSize|keyboardHidden">
</activity>

4.2 重写 `onConfigurationChanged` 方法

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    // Handle configuration changes
    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        // Handle landscape orientation
    } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) {
        // Handle portrait orientation
    }
}

5. Activity 的调试和日志记录

5.1 使用 Logcat

Logcat 是 Android 提供的日志记录工具，开发者可以使用 Log 类来记录调试信息。

// Log debug information
Log.d("MyActivity", "Debug message");

// Log error information
Log.e("MyActivity", "Error message", throwable);

5.2 使用调试工具

Android Studio 提供了强大的调试工具，包括断点调试、内存分析、性能分析等。

// Use breakpoints to debug the application

6. Activity 的单元测试和 UI 测试

测试是确保应用程序质量的关键环节，Android 提供了多种测试框架和工具来进行单元测试和 UI 测试。

6.1 使用 JUnit 进行单元测试

JUnit 是一个常用的 Java 单元测试框架，Android 提供了对 JUnit 的支持。

// Example unit test
public class MyActivityTest {
    @Test
    public void addition_isCorrect() {
        assertEquals(4, 2 + 2);
    }
}

6.2 使用 Espresso 进行 UI 测试

Espresso 是一个用于编写 UI 测试的框架。

// Example UI test
@RunWith(AndroidJUnit4.class)
public class MyActivityTest {
    @Rule
    public ActivityTestRule<MyActivity> activityRule =
            new ActivityTestRule<>(MyActivity.class);

    @Test
    public void ensureTextChangesWork() {
        onView(withId(R.id.editText))
                .perform(typeText("Hello"), closeSoftKeyboard());
        onView(withId(R.id.changeTextButton)).perform(click());
        onView(withId(R.id.textView)).check(matches(withText("Hello")));
    }
}