Activity #

一、Activity概述 #

Activity是Android四大组件之一，是用户与应用程序交互的入口点。一个Activity通常对应一个屏幕，用户可以在这个屏幕上进行操作。

1.1 Activity的特点 #

提供用户界面
管理用户交互
具有生命周期
可以相互跳转

1.2 Activity的注册 #

所有Activity必须在AndroidManifest.xml中注册：

xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myapp">

    <application>
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        
        <activity
            android:name=".SecondActivity"
            android:exported="false" />
    </application>

</manifest>

1.3 Activity属性 #

属性	说明
android:name	Activity类名
android:label	Activity标题
android:icon	Activity图标
android:theme	Activity主题
android:exported	是否可被其他应用启动
android:launchMode	启动模式
android:screenOrientation	屏幕方向
android:configChanges	配置变化处理

二、Activity生命周期 #

2.1 生命周期图解 #

text

                    创建
                      │
                      ▼
              ┌───────────────┐
              │   onCreate()  │
              └───────┬───────┘
                      │
                      ▼
              ┌───────────────┐
              │   onStart()   │
              └───────┬───────┘
                      │
                      ▼
              ┌───────────────┐
         ┌────│  onResume()   │◄───────────┐
         │    └───────────────┘            │
         │             │                   │
         │             ▼                   │
         │    ┌───────────────┐            │
         │    │   运行中       │            │
         │    └───────────────┘            │
         │             │                   │
         │             ▼                   │
         │    ┌───────────────┐            │
         │    │   onPause()   │────────────┘
         │    └───────┬───────┘
         │            │
         │            ▼
         │    ┌───────────────┐
         │    │   onStop()    │
         │    └───────┬───────┘
         │            │
         │            ▼
         │    ┌───────────────┐
         └───►│  onDestroy()  │
              └───────────────┘

2.2 生命周期方法 #

kotlin

class MainActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        Log.d("MainActivity", "onCreate")
    }
    
    override fun onStart() {
        super.onStart()
        Log.d("MainActivity", "onStart")
    }
    
    override fun onResume() {
        super.onResume()
        Log.d("MainActivity", "onResume")
    }
    
    override fun onPause() {
        super.onPause()
        Log.d("MainActivity", "onPause")
    }
    
    override fun onStop() {
        super.onStop()
        Log.d("MainActivity", "onStop")
    }
    
    override fun onDestroy() {
        super.onDestroy()
        Log.d("MainActivity", "onDestroy")
    }
    
    override fun onRestart() {
        super.onRestart()
        Log.d("MainActivity", "onRestart")
    }
}

2.3 生命周期说明 #

方法	说明	典型操作
onCreate()	Activity创建时调用	初始化、加载布局
onStart()	Activity变为可见时调用	注册广播接收器
onResume()	Activity获得焦点时调用	恢复动画、相机预览
onPause()	Activity失去焦点时调用	暂停动画、保存草稿
onStop()	Activity不可见时调用	释放资源、注销广播
onDestroy()	Activity销毁时调用	释放所有资源
onRestart()	Activity从停止状态重启	恢复数据

2.4 典型场景生命周期 #

启动Activity #

text

onCreate() -> onStart() -> onResume()

打开新Activity（当前Activity进入后台） #

text

onPause() -> onStop()

返回到Activity #

text

onRestart() -> onStart() -> onResume()

关闭Activity #

text

onPause() -> onStop() -> onDestroy()

屏幕旋转 #

text

onPause() -> onStop() -> onDestroy() -> onCreate() -> onStart() -> onResume()

2.5 保存和恢复状态 #

kotlin

class MainActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // 恢复数据
        savedInstanceState?.let {
            val score = it.getInt("score", 0)
            updateScore(score)
        }
    }
    
    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        // 保存数据
        outState.putInt("score", currentScore)
    }
    
    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
        super.onRestoreInstanceState(savedInstanceState)
        // 恢复数据
        val score = savedInstanceState.getInt("score", 0)
        updateScore(score)
    }
}

三、Activity启动模式 #

3.1 四种启动模式 #

模式	说明
standard	默认模式，每次启动创建新实例
singleTop	栈顶复用，如果已在栈顶则复用
singleTask	栈内复用，清除其上方所有Activity
singleInstance	单实例模式，独占一个任务栈

3.2 配置启动模式 #

xml

<activity
    android:name=".MainActivity"
    android:launchMode="singleTop" />

或使用Intent标志：

kotlin

val intent = Intent(this, MainActivity::class.java)
intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
startActivity(intent)

3.3 standard模式 #

每次启动都创建新实例：

text

任务栈: [A]
启动B: [A, B]
启动B: [A, B, B]
启动B: [A, B, B, B]

3.4 singleTop模式 #

如果目标Activity已在栈顶，则复用：

text

任务栈: [A, B]
启动B: [A, B]  // 复用栈顶B，调用onNewIntent()
启动C: [A, B, C]
启动B: [A, B, C, B]

kotlin

class MainActivity : AppCompatActivity() {
    
    override fun onNewIntent(intent: Intent?) {
        super.onNewIntent(intent)
        // 处理新Intent
        val data = intent?.getStringExtra("data")
    }
}

3.5 singleTask模式 #

如果任务栈中已存在，则复用并清除其上方所有Activity：

text

任务栈: [A, B, C, D]
启动B: [A, B]  // C、D被清除

3.6 singleInstance模式 #

Activity独占一个任务栈：

text

任务栈1: [A, B]
启动C(singleInstance):
任务栈1: [A, B]
任务栈2: [C]

3.7 Intent标志 #

标志	说明
FLAG_ACTIVITY_NEW_TASK	新任务中启动
FLAG_ACTIVITY_SINGLE_TOP	相当于singleTop
FLAG_ACTIVITY_CLEAR_TOP	清除目标上方所有Activity
FLAG_ACTIVITY_NO_HISTORY	不保留在任务栈中
FLAG_ACTIVITY_CLEAR_TASK	启动时清除任务栈

四、Activity跳转与数据传递 #

4.1 基本跳转 #

kotlin

// 显式Intent
val intent = Intent(this, SecondActivity::class.java)
startActivity(intent)

// 隐式Intent
val intent = Intent(Intent.ACTION_VIEW)
intent.data = Uri.parse("https://www.example.com")
startActivity(intent)

4.2 传递数据 #

kotlin

// 发送数据
val intent = Intent(this, SecondActivity::class.java).apply {
    putExtra("name", "Kotlin")
    putExtra("age", 10)
    putExtra("isStudent", true)
}
startActivity(intent)

// 接收数据
class SecondActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        val name = intent.getStringExtra("name")
        val age = intent.getIntExtra("age", 0)
        val isStudent = intent.getBooleanExtra("isStudent", false)
    }
}

4.3 传递对象 #

kotlin

// 实现Parcelable接口
@Parcelize
data class User(val id: Int, val name: String) : Parcelable

// 发送
val user = User(1, "Kotlin")
val intent = Intent(this, SecondActivity::class.java).apply {
    putExtra("user", user)
}
startActivity(intent)

// 接收
val user = intent.getParcelableExtra<User>("user")

4.4 startActivityForResult（已废弃） #

kotlin

// 发送请求
val intent = Intent(this, SecondActivity::class.java)
startActivityForResult(intent, REQUEST_CODE)

// 接收结果
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode == REQUEST_CODE && resultCode == RESULT_OK) {
        val result = data?.getStringExtra("result")
    }
}

// 返回结果
class SecondActivity : AppCompatActivity() {
    fun returnResult() {
        val intent = Intent().apply {
            putExtra("result", "Success")
        }
        setResult(RESULT_OK, intent)
        finish()
    }
}

4.5 Activity Result API（推荐） #

kotlin

class MainActivity : AppCompatActivity() {
    
    private val startForResult = registerForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) { result ->
        if (result.resultCode == RESULT_OK) {
            val data = result.data?.getStringExtra("result")
        }
    }
    
    fun openSecondActivity() {
        val intent = Intent(this, SecondActivity::class.java)
        startForResult.launch(intent)
    }
}

4.6 请求权限 #

kotlin

private val requestPermission = registerForActivityResult(
    ActivityResultContracts.RequestPermission()
) { isGranted ->
    if (isGranted) {
        // 权限已授予
    } else {
        // 权限被拒绝
    }
}

fun requestCameraPermission() {
    requestPermission.launch(Manifest.permission.CAMERA)
}

五、任务栈管理 #

5.1 任务栈概念 #

任务栈（Task）是一组Activity的集合，按照打开顺序排列。后打开的Activity位于栈顶。

5.2 查看任务栈 #

kotlin

// 获取任务信息
val manager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
val tasks = manager.appTasks

for (task in tasks) {
    Log.d("Task", "Task ID: ${task.taskInfo.id}")
    Log.d("Task", "Base Activity: ${task.taskInfo.baseActivity}")
}

5.3 清除任务栈 #

kotlin

// 清除任务栈并启动新Activity
val intent = Intent(this, MainActivity::class.java).apply {
    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
}
startActivity(intent)

六、Activity最佳实践 #

6.1 使用ViewModel保存数据 #

kotlin

class MainViewModel : ViewModel() {
    private val _score = MutableLiveData<Int>()
    val score: LiveData<Int> = _score
    
    fun updateScore(newScore: Int) {
        _score.value = newScore
    }
}

class MainActivity : AppCompatActivity() {
    private val viewModel: MainViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        viewModel.score.observe(this) { score ->
            updateScoreUI(score)
        }
    }
}

6.2 处理配置变化 #

xml

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

kotlin

override fun onConfigurationChanged(newConfig: Configuration) {
    super.onConfigurationChanged(newConfig)
    when (newConfig.orientation) {
        Configuration.ORIENTATION_LANDSCAPE -> {
            // 横屏处理
        }
        Configuration.ORIENTATION_PORTRAIT -> {
            // 竖屏处理
        }
    }
}

6.3 避免内存泄漏 #

kotlin

class MainActivity : AppCompatActivity() {
    private var handler: Handler? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        handler = Handler(Looper.getMainLooper())
    }
    
    override fun onDestroy() {
        super.onDestroy()
        // 移除所有消息
        handler?.removeCallbacksAndMessages(null)
        handler = null
    }
}

七、总结 #

本章详细介绍了Activity：

Activity的基本概念和注册
生命周期的各个阶段
四种启动模式
Activity之间的跳转和数据传递
任务栈管理
最佳实践

Activity是Android开发的基础，理解其生命周期和启动模式对于开发高质量应用至关重要。