Day 1：环境搭建

安装 Android Studio

Android Studio 是 Google 官方推出的 Android 集成开发环境（IDE），基于 IntelliJ IDEA 构建，整合了代码编辑、编译构建、调试、性能分析和模拟器，是 Android 开发的标准工具。

系统要求

在安装前先确认机器是否满足最低配置。Windows 平台的最低要求是 64 位 Windows 10、8 GB 内存（如需同时运行模拟器建议 16 GB）、8 GB 可用磁盘空间（带模拟器则需 16 GB）。CPU 需要支持虚拟化技术（Intel VT-x 或 AMD-V）并在 BIOS 中开启，否则模拟器无法正常启动。

下载安装与启动配置

访问 developer.android.com/studio 下载最新版 Android Studio。Windows 平台推荐下载 .exe 安装包，双击运行后按向导操作即可。安装完成后首次启动，如果之前装过旧版本，会提示是否导入旧配置，如果是全新安装，选择 "Do not import settings" 继续。接着进入 Setup Wizard，选择安装类型为 Custom（自定义安装）进入自定义安装界面，在这个界面中我们只修改Android SDK的下载路径，默认的下载路径在 C 盘用户文件夹下，我们需要将这个路径修改到其他盘，最后确认 SDK 组件列表，点击 Finish。Android Studio 会自动下载缺失的 SDK 组件，这个过程可能需要几分钟，取决于网络状况。

安装 SDK

Android SDK（Software Development Kit）不是单一的东西，而是一组工具的集合，包括各版本 Android 平台库、构建工具、平台工具（adb 等）、模拟器镜像等。第一步安装 Android Studio 时已经下载了基础组件，但通常还需要按需追加。

SDK Manager

在 Android Studio 欢迎页点击 "More Actions" → "SDK Manager"，或者进入项目后从菜单栏选择 Tools → SDK Manager。SDK Manager 分三个标签页，按需配置即可。

SDK Platforms 列出所有可用的 Android 版本，建议至少勾选两个：最新正式版（当前是 Android 17, API Level 37）用于编译和调用最新 API，以及一个与项目 minSdk 一致的较低版本（比如 Android 7.0, API Level 24），便于在低版本模拟器上验证兼容性。

SDK Tools 控制与 Android 版本无关的独立工具，有三项必须保持安装：

工具	说明
Android SDK Build-Tools	编译打包核心，保持最新版本即可
Android Emulator	模拟器本体，必装
Android SDK Platform-Tools	包含 adb、fastboot 等命令行工具，必装

SDK Update Sites 是 SDK 组件的更新源地址，通常不需要动。只有网络无法直连 Google 时，才需要在这里添加国内镜像源（如东软信息学院或中科大的 Android SDK 镜像）。

配置完成后点击 Apply → OK，Android Studio 会下载并安装所选组件，过程中如有防火墙或杀毒软件提示，允许访问网络即可。

创建第一个项目

环境准备就绪之后，开始创建第一个 Android 项目。

1. 在 Android Studio 欢迎页点击 New Project。
2. 左侧选择 Phone and Tablet ，右侧模板选择 Empty Views Activity。这个模板只包含一个空白 Activity 和一个 "Hello World" 标签，很适合从零开始理解项目结构。不要被其他花哨的模板吸引，在搞清楚基础之前，多出来的代码只会增加困惑。
3. 点击 Next 进入项目配置：

配置项	填写
Name	HelloAndroid（项目名，也是默认的应用显示名）
Package name	com.example.helloandroid（应用唯一标识，反域名格式）
Save location	选择一个你方便管理的路径
Language	Kotlin
Minimum SDK	API 24: Android 7.0 (Nougat)

Minimum SDK 决定了应用最低能运行在哪个 Android 版本上。API 24 覆盖了绝大多数活跃设备，同时不至于牺牲太多新特性，点击 "Help me choose" 可以看到各版本的设备覆盖率分布图，选之前可以参考一下。

4. Build configuration language 保持默认的 Kotlin DSL （即 build.gradle.kts），不要选 Groovy。Kotlin DSL 是当前推荐的 Gradle 脚本编写方式，与工程语言统一。

5. 点击 Finish。Android Studio 开始生成项目文件并进行 Gradle 同步（Sync）。底部状态栏会显示进度，首次同步会下载 Gradle 发行版和项目声明的依赖（Kotlin 标准库、AndroidX 核心库等），可能需要几分钟。

同步完成后，app/src/main/java/com/example/helloandroid/MainActivity.kt 就是你的第一个 Kotlin 文件，app/src/main/res/layout/activity_main.xml 是布局文件。此时你看到的是一个可编译、可运行的最小 Android 应用。

模拟器使用

模拟器让你无需真机就能在电脑上运行和调试 Android 应用，Android Emulator 是一台完整的虚拟 Android 设备，支持自定义屏幕尺寸、API 级别和硬件配置。

创建虚拟设备

1. 点击工具栏上的 Device Manager 图标（手机图标），或从菜单选择 View → Tool Windows → Device Manager。
2. 在 Device Manager 面板中点击 Add a new device （或 "+" 号），然后选择 Create Virtual Device。
3. 在 Add Device 窗口中，左侧选 Phone，然后从列表中选择一台设备，比如 Pixel 7 Pro。这个选择决定了模拟器的屏幕尺寸和分辨率，对布局调试很重要，点击 Next。
4. 在 配置设备 界面，初次使用需要先点击 Download 下载对应 API Level 的系统镜像。推荐选择 API 37，Services 选带 "Google Play Store" 的版本（包含了 Google Play 服务和一些调试工具）。下载过程可能较长（镜像约 2 GB），取决于网络速度。其他配置根据自己的需求选择，默认值一般够用。
5. 点击 Finish，模拟器就创建完成了，并会出现在 Device Manager 列表中。

启动与使用

在 Device Manager 中，点击刚创建的设备右侧的 ▶ 按钮即可启动模拟器。首次启动需要完成完整的开机过程，后续使用 Quick boot 会快很多。

实践：Hello Android

创建并运行项目

前面已经创建了 HelloAndroid 项目，现在直接运行看效果。确保模拟器已经启动，在 Android Studio 顶部的运行配置下拉菜单中选择 app，点击绿色 ▶ 按钮（或 Shift+F10）。Gradle 会先编译项目、生成 APK，再通过 adb 推送到模拟器安装并启动，首次编译较慢，后续增量编译会快很多。几秒后模拟器上应该出现一个白底屏幕，正中央有一行 "Hello World!" 文字。

如果运行按钮是灰的，检查两件事：底部状态栏的 Gradle Sync 是否已经完成，以及 Device Manager 中模拟器状态是否为 "Connected"。

修改文字和颜色

默认的文字和颜色都在资源文件里集中管理，找到它们并修改，就能看到即时变化。

修改文字 ：打开 app/src/main/res/values/strings.xml，找到 app_name 对应的 <string> 标签：

<resources>
    <string name="app_name">我的第一个应用</string>
</resources>

将 app_name 的值改为 我的第一个应用。这个字符串是应用的显示名，会出现在启动器的应用图标下方。

要修改屏幕中间那行文字，需要去布局文件 app/src/main/res/layout/activity_main.xml 找到 android:text="Hello World!"，把它删掉，然后在 strings.xml 中新增一个名为 hello_text 的字符串，再在布局中引用它：

<string name="hello_text">你好，Android！</string>

然后回到 activity_main.xml，将 TextView 的 android:text 改为：

android:text="@string/hello_text"

这样做的好处是所有界面文字集中在 strings.xml 管理，后续做国际化翻译、统一替换都很方便。直接在布局里写死字符串（硬编码）是 Android 开发里需要避免的习惯。

修改颜色 ：打开 app/src/main/res/values/themes.xml（或 themes.xml (night) 用于暗色模式），找到 @color/... 的引用，再到 res/values/colors.xml 中新增颜色值：

<color name="blue">#FF1565C0</color>

改为你喜欢的颜色，比如深蓝 #FF1565C0。颜色值格式是 #AARRGGBB，前两位 AA 是透明度（FF 完全不透明）。修改完成后再次 Run，模拟器上的颜色和文字就会更新。也可以点击 Run 按钮旁边的闪电图标 Apply Changes，这个功能只推送改动的代码和资源，不需要重新安装 APK，速度更快，适合快速迭代 UI。

Project 结构

在开始写更多代码之前，有必要先理解 Android 项目的目录结构。Android Studio 左侧的 Project 窗格默认以 Android 视图显示，这个视图按功能模块组织文件，隐藏了不会直接编辑的内部文件。你可以通过下拉菜单切换到 Project 视图，它显示的是磁盘上的真实文件布局。

以下是 Day1 项目的完整结构：

Day1/
├── .gitignore
├── .gradle/                     # Gradle 缓存，自动生成
├── .idea/                       # IDE 工程配置
├── .kotlin/                     # Kotlin 插件缓存
├── app/                         # 主模块
│   ├── .gitignore
│   ├── build.gradle.kts         # 模块级构建脚本
│   └── src/
│       ├── androidTest/java/com/example/helloandroid/
│       │   └── ExampleInstrumentedTest.kt
│       ├── main/
│       │   ├── AndroidManifest.xml
│       │   ├── java/com/example/helloandroid/
│       │   │   └── MainActivity.kt
│       │   ├── keepRules/
│       │   │   └── rules.keep
│       │   └── res/
│       │       ├── drawable/
│       │       │   ├── ic_launcher_background.xml
│       │       │   └── ic_launcher_foreground.xml
│       │       ├── layout/
│       │       │   └── activity_main.xml
│       │       ├── mipmap-anydpi-v26/
│       │       ├── mipmap-hdpi/
│       │       ├── mipmap-mdpi/
│       │       ├── mipmap-xhdpi/
│       │       ├── mipmap-xxhdpi/
│       │       ├── mipmap-xxxhdpi/
│       │       ├── values/
│       │       │   ├── colors.xml
│       │       │   ├── strings.xml
│       │       │   └── themes.xml
│       │       ├── values-night/
│       │       │   └── themes.xml
│       │       └── xml/
│       │           ├── backup_rules.xml
│       │           └── data_extraction_rules.xml
│       └── test/java/com/example/helloandroid/
│           └── ExampleUnitTest.kt
├── build/                        # 根项目编译输出
├── build.gradle.kts              # 项目级构建脚本
├── gradle.properties
├── gradle/
│   ├── libs.versions.toml
│   └── wrapper/
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── local.properties
└── settings.gradle.kts

下面从根目录开始，自上而下逐一讲解每个文件和目录的作用。

根目录文件与目录

根目录下的文件大致分四类，性质和处理方式各不相同。

首先是自动生成的缓存目录，完全不需要手动操作，也不应该提交到 Git。.gradle/ 存放 Gradle 的构建配置缓存、文件哈希和 VCS 信息；.idea/ 是 IDE 的工程配置，记录了代码风格、运行配置、编译器设置等（团队协作时只提交代码风格相关的文件，其余走 .gitignore）；.kotlin/ 是 Kotlin 编译器插件的会话缓存。如果 Gradle 构建行为异常（比如缓存了旧依赖版本），关闭 Android Studio 删掉 .gradle/ 和 build/ 再重新 Sync 通常能解决。.gitignore 也在根目录------Android Studio 生成了根目录和 app/ 各一份，根目录的那份负责声明所有不该提交的内容。

其次是 Gradle 构建脚本。settings.gradle.kts 是 Gradle 启动时最先读取的文件，负责定义项目名称、声明子模块（include(":app")）、配置插件和依赖的仓库来源。根目录下的 build.gradle.kts 则声明整个项目使用的插件版本，统一用 apply false 管理------在这里锁定版本但不直接启用，留给各子模块按需 apply，防止不同模块各用各的版本。

然后是两个配置文件，处理方式截然相反。gradle.properties 是团队共享的构建参数，常用来调整 JVM 堆大小（org.gradle.jvmargs=-Xmx2048m）、配置代理、启用 AndroidX 等，适合提交到版本控制。local.properties 则只记录当前机器的 SDK 路径：

sdk.dir=C\:\\Users\\Administrator\\AppData\\Local\\Android\\Sdk

这个文件绝对不能提交 ------每台机器的路径不同，一旦提交，其他人拉取代码后构建会直接失败。模板的 .gitignore 已默认排除了它，但换项目时最好再确认一次。

最后是 Gradle Wrapper 相关的文件。gradlew（Unix）和 gradlew.bat（Windows）是 Wrapper 入口脚本，首次执行时会自动下载项目声明的 Gradle 版本，不需要手动安装，也保证了团队所有成员用同一版本构建。gradle/ 目录下的 libs.versions.toml 是 Version Catalog，集中管理所有第三方依赖的版本号，在 build.gradle.kts 中按别名引用，避免多模块版本不一致；wrapper/gradle-wrapper.properties 声明了当前使用的 Gradle 版本和分发 URL，升级 Gradle 只需改这里的 URL，Android Studio 也支持通过 File → Project Structure → Project → Gradle Version 修改。

模块目录：app/

app/ 是项目当前唯一的模块，存放所有源码、资源和构建配置。大型项目会有多个模块（如 :lib_base、:feature_login），每个结构都和 app/ 类似，各自独立编译。

模块根目录下有两个文件：app/.gitignore 负责忽略编译产物 app/build/，模板同时在根目录和模块目录各放一份，是为了保证模块拆出去独立运行时 .gitignore 依然有效。app/build.gradle.kts 是模块最核心的配置文件，声明了插件（com.android.application 表明这是一个可安装的 App，对应的是 com.android.library 用于组件库）、Android 编译参数（compileSdk、minSdk、targetSdk、versionCode 等）以及所有第三方依赖。每次添加新库、调整支持版本范围，都在这里改。后面的 Gradle 章节会逐块拆解它的内容。

源码目录：app/src/

app/src/ 包含三个独立的源码集（Source Set）：main/ 是主体代码和资源所在地，日常开发几乎都在这里；test/ 是本地单元测试，跑在 JVM 上，执行速度极快，不需要启动 Android 设备；androidTest/ 是仪表化测试，必须在真机或模拟器上运行，用于测试依赖 Android 系统的功能。三者包名结构一致，但各自独立编译，互不干扰。

主源码集：app/src/main/

这里是整个项目真正的工作区，三个关键文件撟起了最小可运行应用的骨架。

AndroidManifest.xml 是应用的"身份证"，声明了包名、所需权限（网络、相机、定位等）、四大组件（Activity、Service、BroadcastReceiver、ContentProvider）以及设备兼容性约束。每个 Activity 都必须在这里注册，否则启动时系统会直接抛出 ActivityNotFoundException 崩溃。当前模板的 Manifest 很简洁，只注册了 MainActivity 并配置了启动入口的 intent-filter。

java/com/example/helloandroid/MainActivity.kt 是第一个 Kotlin 源文件，也是应用唯一的 Activity。模板使用了 Jetpack Compose，用声明式代码构建 UI，不再依赖 XML 和 findViewById：

package com.example.helloandroid

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.ui.Modifier
import com.example.helloandroid.ui.theme.HelloAndroidTheme

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            HelloAndroidTheme {
                Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
                    Text("Hello Android!")
                }
            }
        }
    }
}

onCreate() 是 Activity 的生命周期入口，setContent {} 是 Compose 的入口，替代了传统的 setContentView()。HelloAndroidTheme 和 Surface 提供 Material Design 3 的主题外观，Text("Hello Android!") 就是模拟器上显示的那行字。把它改成 Text("你好！") 然后点 Apply Changes，文字会立刻更新，连重新安装 APK 都省了。

还有一个 keepRules/rules.keep，是 R8 混淆的保留规则文件。开启 Release 混淆（isMinifyEnabled = true）后，R8 会激进地删除未被直接引用的类和方法，通过反射调用的代码（如 Gson 反序列化、依赖注入框架等）因无法被静态分析到，误删后会在运行时崩溃。rules.keep 就是用来声明"这些类无论如何不能删"。模板里这个文件是空的，因为目前没有需要保护的类。

资源目录：app/src/main/res/

res/ 是 Android 资源系统的核心，所有非代码的静态内容------布局、字符串、颜色、图片、图标------集中在这里，通过目录名的限定符后缀实现多配置自动适配。

图标资源分两套体系共存。drawable/ 下的 ic_launcher_background.xml 和 ic_launcher_foreground.xml 是矢量文件，定义了自适应图标（Adaptive Icon）的背景层（纯色方块）和前景层（图标主体），系统根据设备 OEM 的图标形状自动裁切前景层，保证在不同厂商手机上风格统一。layout/activity_main.xml 是布局文件，但在这个 Compose 项目里只是一个空壳，根节点只有一个 ComposeView，真正的 UI 全由 setContent {} 代码定义。

mipmap-anydpi-v26/ 存放 API 26 及以上的自适应图标入口文件，不包含图像数据，只是告诉系统去 drawable/ 中合成；API 26 以下的设备则回退到五个密度级别的位图目录（mdpi ~160dpi、hdpi 1.5x、xhdpi 2x、xxhdpi 3x、xxxhdpi 4x），系统自动选择最匹配的版本加载。

values/ 目录下的三个 XML 管理着应用所有的视觉"参数"。colors.xml 定义颜色常量，集中管理主题色和强调色，避免在布局里散落硬编码色値；strings.xml 存放所有用户可见文字，通过 @string/xxx 引用------这既便于统一修改，也是国际化的基础（新建 values-zh/strings.xml 就能适配中文，其他语言同理）；themes.xml 声明应用全局的 Material Design 3 视觉样式，颜色方案、状态栏颜色、默认字体等全在这里，子组件没有自己指定样式时会自动继承。values-night/themes.xml 是暗色模式的覆盖版本，-night 限定符让系统在深色主题时自动从这里加载资源，颜色値换成暗色调，不需要手写任何条件判断逻辑。

xml/ 下的两个文件控制数据备份行为。backup_rules.xml 是 Android 6.0+ 的云备份规则，data_extraction_rules.xml 是 Android 12+ 的扩展版，还涵盖设备间迁移。默认配置允许应用数据全部参与备份，如果存储了 token、密码等敏感信息，需要用 <exclude> 明确排除。下面是 backup_rules.xml 的默认结构示例：

<data-extraction-rules>
    <cloud-backup>
        <include domain="sharedpref" path="."/>
        <include domain="database" path="."/>
        <include domain="file" path="."/>
    </cloud-backup>
</data-extraction-rules>

测试目录

test/ 下的 ExampleUnitTest.kt 是本地单元测试示例，跑在开发机 JVM 上，毫秒级执行，适合测试 ViewModel 业务逻辑、数据转换、工具方法等纯 Kotlin 代码，不需要启动 Android 设备。androidTest/ 下的 ExampleInstrumentedTest.kt 是仪表化测试示例，必须在真机或模拟器上运行，适合测试 Activity 启动流程、Fragment 交互、Room 数据库等依赖 Android 运行时的功能。两个示例都只做最基础的验证，目的是确认测试框架已正常搭建好。

---

重点：Gradle 基本概念

Gradle 是 Android 项目的构建系统，负责把 Kotlin 源码、资源文件、第三方库整合编译成可安装的 APK。理解 Gradle 不需要从零学会 Groovy 或 Kotlin DSL 语法，先把几个核心概念和文件的关系搞清楚就足够入门了。

三个关键文件

settings.gradle.kts 是 Gradle 的入口。它定义项目名称和包含哪些模块：

pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

rootProject.name = "HelloAndroid"
include(":app")

include(":app") 告诉 Gradle 这个项目有一个叫 app 的子模块。大型项目中可能有多个模块（如 :lib_base、:feature_login），都在这里声明。

pluginManagement 和 dependencyResolutionManagement 分别控制插件和依赖的仓库来源。google() 和 mavenCentral() 是 Android 开发中两个几乎必加的仓库------Google 自家的库（AndroidX、Material Design 等）在 google 仓库，Kotlin 和其他开源库在 Maven Central。

项目级 build.gradle.kts（根目录下的）声明全局的 Gradle 插件：

plugins {
    id("com.android.application") version "8.2.0" apply false
    id("org.jetbrains.kotlin.android") version "1.9.20" apply false
}

apply false 表示插件在此声明了版本，但并不会应用到项目本身，而是留给子模块按需 apply。这样做的好处是整个项目的插件版本在根脚本里统一管理，不会出现不同模块引用不同版本的问题。

模块级 build.gradle.kts （app/build.gradle.kts）定义真正模块级别的编译配置：

plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
}

android {
    namespace = "com.example.helloandroid"
    compileSdk = 35

    defaultConfig {
        applicationId = "com.example.helloandroid"
        minSdk = 24
        targetSdk = 35
        versionCode = 1
        versionName = "1.0"
    }

    buildTypes {
        release {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }

    kotlinOptions {
        jvmTarget = "17"
    }
}

dependencies {
    implementation("androidx.core:core-ktx:1.12.0")
    implementation("androidx.appcompat:appcompat:1.6.1")
    implementation("com.google.android.material:material:1.11.0")
}

逐块来看：plugins 块真正应用了根脚本声明的插件，com.android.application 表明这是一个可安装运行的 App 模块，如果是组件库则用 com.android.library。android {} 块是 Android 编译参数的集中地。namespace 是代码层面的包命名空间，applicationId 是设备上安装时的唯一标识，通常二者相同，打渠道包时可以不同。compileSdk 设为最新版本以调用最新 API；minSdk 决定最低支持的 Android 版本，低于此版本的设备无法安装；targetSdk 声明已充分测试的目标版本，Google Play 要求这个值不能太旧，否则拒绝上架。versionCode 是每次发版递增的内部整数，versionName 是展示给用户的版本字符串。buildTypes 定义构建类型，release 块中的 isMinifyEnabled 控制是否开启 R8 代码混淆，proguardFiles 指定混淆规则文件。

dependencies {} 块声明第三方库。implementation 是最常用的依赖方式，库只对当前模块可见，不向外传递。core-ktx 提供大量 Kotlin 扩展函数，让原本 Java 风格的 API 更符合 Kotlin 习惯；appcompat 提供向后兼容的 Activity 基类；material 是 Google 的 Material Design 组件库。

Gradle Sync 是在做什么

每次修改 build.gradle.kts 或新增依赖后，Android Studio 顶部会弹出黄色提示条 "Gradle files have changed since last project sync"，提示你需要同步。

Sync 的过程是 Gradle 根据你声明的插件、依赖和配置，从远程仓库下载对应的 JAR/AAR 文件到本地缓存（~/.gradle/caches/），并生成 IDE 可识别的项目模型。同步完成后，Android Studio 才有新依赖的代码补全、语法检查和跳转能力。

这也是为什么每次加一个新库都要先 Sync 然后等一会儿------Gradle 要去下载这个库以及它传递依赖的所有库。

Gradle Wrapper

项目根目录下的 gradlew（Windows 上还有一个 gradlew.bat）就是 Gradle Wrapper。它是一个脚本，会在首次执行时自动下载项目指定的 Gradle 版本，不需要你手动安装 Gradle。你可以用它在命令行中执行构建任务：

./gradlew assembleDebug    # 编译 debug 版 APK
./gradlew assembleRelease  # 编译 release 版 APK
./gradlew clean            # 清理编译产物

同一个项目团队里的所有人都用 Wrapper 构建，可以保证 Gradle 版本一致，从根本上避免"我这能编译你那不行"的问题。

依赖冲突怎么办

刚入门的项目一般不会遇到，但提前知道这个概念没坏处。当 A 库依赖 X 的 v1.0，B 库依赖 X 的 v2.0 时，Gradle 默认会选择最高版本（v2.0）来解决冲突。大多数情况下这个策略是合理的，但如果 v2.0 与 v1.0 之间存在不兼容的 API 变更，运行时可能崩溃。

排查这类问题的方法是：在 Android Studio 右侧打开 Gradle 面板，找到 app → Tasks → help → dependencies，双击执行，控制台会打印完整的依赖树。找到冲突的库，用 implementation("xxx") { exclude(group = "...", module = "...") } 排除掉不需要的版本，或者用 constraints 强制指定版本。