父Activity结束子Activity方法及加载屏实现优化咨询

嗨，针对你的问题，我会分两部分解答：首先是实现从MainActivity关闭子Activity的具体方法，然后聊聊这种加载屏方案是否是最优选择。

一、实现从MainActivity关闭LoadingActivity的几种方式 #

1. 使用本地广播（推荐，无内存泄漏风险） #

这种方式是最安全的，不需要持有Activity的强引用，通过广播机制来传递关闭信号：

• 在LoadingActivity中注册广播接收器：

class LoadingActivity : AppCompatActivity() {
    private lateinit var finishReceiver: BroadcastReceiver

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_loading)

        // 注册接收关闭信号的广播
        finishReceiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent?) {
                if (intent?.action == "ACTION_FINISH_LOADING_SCREEN") {
                    finish() // 收到信号后关闭自身
                }
            }
        }
        registerReceiver(finishReceiver, IntentFilter("ACTION_FINISH_LOADING_SCREEN"))
    }

    override fun onDestroy() {
        super.onDestroy()
        // 销毁时必须注销广播，避免内存泄漏
        unregisterReceiver(finishReceiver)
    }
}

• 在MainActivity中，数据加载完成后发送广播：

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 启动加载屏
        startActivity(Intent(this, LoadingActivity::class.java))

        // 模拟后端数据加载流程
        fetchDataFromBackend()
    }

    private fun fetchDataFromBackend() {
        // 用协程模拟异步网络请求，实际项目替换为你的网络框架逻辑
        CoroutineScope(Dispatchers.IO).launch {
            delay(3000) // 模拟加载耗时
            // 回到主线程发送广播
            runOnUiThread {
                sendBroadcast(Intent("ACTION_FINISH_LOADING_SCREEN"))
            }
        }
    }
}

2. 使用静态Activity实例（需警惕内存泄漏） #

这种方式更直接，但必须注意内存泄漏问题，一定要在LoadingActivity销毁时清空静态引用：

• 在LoadingActivity中维护静态实例：

class LoadingActivity : AppCompatActivity() {
    companion object {
        var activeInstance: LoadingActivity? = null
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_loading)
        activeInstance = this
    }

    override fun onDestroy() {
        super.onDestroy()
        activeInstance = null // 销毁时清空引用，防止内存泄漏
    }
}

• 在MainActivity中直接调用finish方法：

private fun fetchDataFromBackend() {
    CoroutineScope(Dispatchers.IO).launch {
        delay(3000)
        runOnUiThread {
            LoadingActivity.activeInstance?.finish()
        }
    }
}

二、这种多Activity加载屏方案是否更优？ #

答案是不推荐使用这种方案，原因主要有三点：

• 额外性能开销：启动新Activity会带来进程资源分配、页面切换动画等开销，相比在当前Activity内显示加载View，流畅度会明显下降。
• 生命周期管理复杂：两个Activity的生命周期交织，容易出现LoadingActivity未及时关闭、内存泄漏等问题，增加维护成本。
• 用户体验割裂：Activity切换的动画会让用户感觉到“页面跳转”，而非连贯的“加载中”状态，体验不够顺滑。

更优的替代方案：在MainActivity内嵌入加载布局 #

目前主流的做法是在MainActivity的布局中直接嵌入加载界面，通过控制View的显示/隐藏来实现加载状态，既简单又高效：

1. 修改MainActivity的布局文件：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <!-- 主内容布局，默认隐藏 -->
    <LinearLayout
        android:id="@+id/layout_main_content"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone">
        <!-- 这里放置你的主界面内容 -->
    </LinearLayout>

    <!-- 加载屏布局，默认显示 -->
    <LinearLayout
        android:id="@+id/layout_loading"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:orientation="vertical">

        <ProgressBar
            android:layout_width="wrap_content"
            android:layout_height="wrap_content" />

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="正在加载数据..."
            android:layout_marginTop="16dp" />
    </LinearLayout>
</RelativeLayout>

2. 在MainActivity中控制加载状态：

class MainActivity : AppCompatActivity() {
    private lateinit var mainContentLayout: LinearLayout
    private lateinit var loadingLayout: LinearLayout

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        mainContentLayout = findViewById(R.id.layout_main_content)
        loadingLayout = findViewById(R.id.layout_loading)

        fetchDataFromBackend()
    }

    private fun fetchDataFromBackend() {
        CoroutineScope(Dispatchers.IO).launch {
            delay(3000) // 模拟加载耗时
            runOnUiThread {
                // 加载完成，隐藏加载屏，显示主内容
                loadingLayout.visibility = View.GONE
                mainContentLayout.visibility = View.VISIBLE
                // 这里更新主界面的数据
            }
        }
    }
}

这种方案既避免了多Activity的复杂问题，又能给用户提供连贯的加载体验，是目前Android开发中加载状态的标准实现方式。

内容的提问来源于stack exchange，提问作者Kavin-K