Android 是如何进行状态管理的？当程序中某个状态改变后，如何通知与这个状态关联的 UI 进行更新？

最新推荐文章于 2024-07-24 21:35:56 发布

zsy_2020

最新推荐文章于 2024-07-24 21:35:56 发布

阅读量797

点赞数 18

文章标签： android ui kotlin 设计模式 java

本文链接：https://blog.csdn.net/zsy_2020/article/details/139656297

版权

在 Android 中，状态管理可以通过以下几种方式来实现：

使用变量：你可以在程序中定义一个变量来表示状态，并在需要的时候改变它。当状态变化时，你可以调用相关方法来通知 UI 进行更新。例如，你可以在 Activity 中定义一个布尔变量来表示某个状态，然后在状态改变时，在相应的方法中调用 `invalidate()` 或者 `requestLayout()` 方法来触发 UI 的重新绘制。
使用观察者模式：Android 提供了观察者模式来支持状态管理。你可以定义一个被观察者对象，并让 UI 类作为观察者来注册监听。当状态改变时，被观察者会通知所有注册的观察者进行更新。你可以使用 `Observable` 类和 `Observer` 接口来实现这一机制。
使用 LiveData：LiveData 是 Android 架构组件中的一个类，它使数据的观察和更新变得更加简单。你可以将 LiveData 对象与 UI 绑定，当 LiveData 对象中的数据发生变化时，UI 会自动更新。你可以使用 LiveData 的 `observe()` 方法来注册观察者，并在观察者的回调方法中进行 UI 的更新。
使用 ViewModel：ViewModel 是 Android 架构组件中的一个类，它用于处理与 UI 相关的数据和逻辑。你可以将状态保存在 ViewModel 中，并通过观察 ViewModel 中的 LiveData 对象来实现状态的更新和 UI 的更新。ViewModel 可以在配置变化（如屏幕旋转）后保持数据的一致性，确保状态不会丢失。

下面是一个使用变量进行状态管理的示例代码：

public class MainActivity extends AppCompatActivity {

    private boolean isPlaying = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Button playButton = findViewById(R.id.play_button);
        final TextView statusText = findViewById(R.id.status_text);

        playButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (isPlaying) {
                    isPlaying = false;
                    // 停止播放逻辑
                    statusText.setText("已停止播放");
                } else {
                    isPlaying = true;
                    // 播放逻辑
                    statusText.setText("正在播放");
                }
            }
        });
    }
}

在这个示例中，我们定义了一个 boolean 类型的变量 isPlaying来表示当前是否正在播放。当用户点击播放按钮时，根据 isPlaying 的值来执行相应的逻辑。如果 isPlaying 为 true，则表示当前正在播放，我们将其设置为 false，并执行停止播放逻辑；反之，如果 isPlaying 为 false，则表示当前未播放，我们将其设置为 true，并执行播放逻辑。

同时，我们还使用了一个 TextView 来显示当前的播放状态，当播放状态发生变化时，我们更新 TextView 的文本内容。

下面是一个使用观察者模式进行Android状态管理的示例：

1. 创建一个观察者接口，用于定义观察者的操作方法：

public interface Observer {
    void update(String state);
}

2. 创建一个被观察者类，用于管理状态并通知观察者：

public class Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }

    private void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}

3. 创建观察者类，实现Observer接口，并在update方法中处理被观察者通知的状态变化：

public class MyObserver implements Observer {
    @Override
    public void update(String state) {
        // 处理状态变化
        Log.d("Observer", "State changed: " + state);
    }
}

4. 在Activity或Fragment中使用观察者模式进行状态管理：

public class MainActivity extends AppCompatActivity {
    private Subject subject;
    private MyObserver observer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        subject = new Subject();
        observer = new MyObserver();
        subject.addObserver(observer);

        // 模拟状态变化
        subject.setState("New state");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        subject.removeObserver(observer);
    }
}

在这个示例中，Subject类是被观察者，负责管理状态并通知观察者。MyObserver类是观察者，实现Observer接口，在update方法中处理被观察者通知的状态变化。在Activity的onCreate方法中，创建被观察者和观察者，并将观察者添加到被观察者的观察者列表中。然后通过调用被观察者的setState方法，模拟状态变化并通知观察者。在Activity的onDestroy方法中，从被观察者的观察者列表中移除观察者，防止内存泄漏。

下面是一个使用LiveData进行状态管理的Android示例：

首先，创建一个名为ViewState的数据类，用于保存界面的状态信息。例如，ViewState可以包含一个loading状态的布尔值和一个错误消息的字符串。

data class ViewState(
    val isLoading: Boolean = false,
    val errorMessage: String? = null
)

接下来，在ViewModel中创建一个LiveData对象来保存ViewState的实例，并提供公共的访问方法。

class MyViewModel : ViewModel() {
    private val _viewState = MutableLiveData<ViewState>()
    val viewState: LiveData<ViewState> = _viewState

    fun setLoading(isLoading: Boolean) {
        _viewState.value = _viewState.value?.copy(isLoading = isLoading)
    }

    fun setErrorMessage(errorMessage: String?) {
        _viewState.value = _viewState.value?.copy(errorMessage = errorMessage)
    }
}

在Activity或Fragment中，将ViewModel与LiveData连接起来，以便在界面上观察并响应状态的变化。

class MyActivity : AppCompatActivity() {
    private lateinit var viewModel: MyViewModel

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

        viewModel = ViewModelProvider(this).get(MyViewModel::class.java)

        // 观察ViewState的变化并更新界面
        viewModel.viewState.observe(this, Observer { state ->
            state?.apply {
                progressBar.visibility = if (isLoading) View.VISIBLE else View.GONE
                errorMessageTextView.text = errorMessage
            }
        })

        // 模拟加载数据的操作
        loadData()
    }

    private fun loadData() {
        viewModel.setLoading(true)

        // 模拟异步加载数据
        Handler().postDelayed({
            viewModel.setLoading(false)
            val success = Random().nextBoolean()

            if (success) {
                // 加载成功
                viewModel.setErrorMessage(null)
            } else {
                // 加载失败
                viewModel.setErrorMessage("加载失败")
            }
        }, 2000)
    }
}

在上面的示例中，当加载数据时，首先设置loading状态为true，然后进行异步加载数据的操作，加载完成后更新loading状态，并根据加载结果设置错误消息。

此外，你还可以在ViewModel中添加其他方法来处理其他业务逻辑，例如处理用户交互或其他数据操作。通过LiveData进行状态管理，可以很好地将数据和界面解耦，提高代码的可维护性和可测试性。

下面是一个基本的Android应用程序，使用ViewModel进行状态管理的示例：

首先，在build.gradle文件中添加ViewModel的依赖项：

implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0"

然后，在MainActivity类中创建一个ViewModel类：

class MainViewModel : ViewModel() {
    private val _count = MutableLiveData<Int>()
    val count: LiveData<Int> get() = _count

    init {
        _count.value = 0
    }

    fun incrementCount() {
        _count.value = (_count.value ?: 0) + 1
    }
}

接下来，在MainActivity中引入ViewModel，并在onCreate方法中初始化：

class MainActivity : AppCompatActivity() {
    private lateinit var viewModel: MainViewModel

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

        viewModel = ViewModelProvider(this).get(MainViewModel::class.java)

        viewModel.count.observe(this, Observer {
            countTextView.text = it.toString()
        })

        incrementButton.setOnClickListener {
            viewModel.incrementCount()
        }
    }
}

在布局文件activity_main.xml中添加一个TextView和一个Button来显示和增加计数：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center_horizontal">

    <TextView
        android:id="@+id/countTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="24sp"
        android:text="0" />

    <Button
        android:id="@+id/incrementButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Increment" />

</LinearLayout>

现在，每当用户点击按钮时，计数将自动递增，并且TextView将显示最新的计数值。ViewModel将保留与Activity的关联，并在配置更改（如屏幕旋转）时保持状态。

Android中的ViewModel和LiveData都是为了帮助开发者更好地管理应用程序的状态。下面是它们之间的区别：

ViewModel：

ViewModel是一个可观察的类，用于存储和管理与UI相关的数据。
ViewModel的存在时间比Activity或Fragment更长，它们会在配置更改（如旋转屏幕）时保持不变。这使得ViewModel非常适合存储和管理应用程序状态。
ViewModel不直接与UI交互，而是通过LiveData或其他观察者模式来通知UI层数据的更改。
ViewModel通常与Repository一起使用，用于从网络、数据库或其他数据源获取数据。

LiveData：