LiveData detallado de los componentes de Android Jetpack

PD: El texto original se publicó por primera vez en la cuenta pública de WeChat: Jongxingzhi (jzman-blog)

LiveData es una clase de contenedor de datos observables. A diferencia de los observables normales, LiveData es consciente del ciclo de vida. LiveData también es parte del componente Android Jetpack. Este artículo aprenderá LiveData de los siguientes aspectos:

1. Que es LiveData
2. Ventajas de LiveData
3. Uso de LiveData
4. Livedata personalizado
5. Conversión de LiveData

Que es LiveData

LiveData es una clase de contenedor de datos observable. A diferencia de los Observables regulares, LiveData puede percibir el ciclo de vida de Actividad, Fragmento y Servicio, lo que garantiza que LiveData solo actualice los observadores de componentes en el estado del ciclo de vida activo.

Si el estado de un observador de componentes de la aplicación es INICIADO o REANUDADO, LiveData considera que el componente está activo y el componente recibirá actualizaciones de datos de LiveData, mientras que otros observadores de componentes registrados no recibirán ninguna actualización de datos.

Ventajas de LiveData

• Mantenga la interfaz de usuario y los datos consistentes : LiveData sigue el patrón de diseño del observador. Cuando el ciclo de vida cambia, LiveData notificará al componente de la aplicación correspondiente (Observer) y actualizará la interfaz de usuario cuando los datos cambien.
• Evite pérdidas de memoria : este observador está vinculado a los objetos del ciclo de vida. Una vez que se destruye el ciclo de vida del objeto del ciclo de vida, estos observadores también se limpiarán automáticamente.
• Evite fallar cuando la Actividad está en un estado inactivo : si el Observador está en un estado inactivo, el Observador no recibirá ningún evento de LiveData.
• Sin manejo manual del ciclo de vida : los componentes de la interfaz de usuario solo observan los datos relacionados y no detendrán ni reanudarán la observación. LiveData se administrará automáticamente según los cambios en el ciclo de vida específico.
• Conserve siempre los datos más recientes : si el ciclo de vida está inactivo, los datos más recientes se recibirán cuando el estado inactivo cambie al estado activo, como cambiar del fondo al primer plano para recibir automáticamente los datos más recientes.
• Manejar correctamente los cambios de configuración : si la actividad o el fragmento se vuelven a crear debido a cambios en la configuración del dispositivo, como la rotación de la pantalla, etc., volverá a recibir inmediatamente los datos más recientes.
• Servicios compartidos : con la ayuda de las capacidades de observación de datos de LiveData, los servicios se pueden conectar o desconectar en cualquier momento de acuerdo con el estado del ciclo de vida de Livecycle.

Uso de LiveData

Definir los datos LiveData en una clase ViewModel específica, y luego observar los cambios en los datos LiveData en la Actividad o Fragmento correspondiente. El uso de LiveData hace que no guardemos los datos en la Actividad o Fragmento, sino los datos almacenados en el objeto LiveData Guardar en ViewModel reduce la carga de trabajo de Activity y Fragment, por lo que Activity y Fragment solo son responsables de la administración y visualización de la interfaz, en lugar de guardar datos, y los datos no se ven afectados cuando se cambia la configuración.

Resumen del uso de LiceData:

1. Cree una instancia de LiveData específica para almacenar datos en ViewModel, de la siguiente manera:

public class MViewModel extends ViewModel {
    
    
    private MutableLiveData<String> data;
    public LiveData<String> getData(){
    
    
        if (data == null){
    
    
            data = new MutableLiveData<>();
            data.postValue(DataUtil.getData());
        }
        return data;
    }
}

2. Utilice el método observe u observeForever del objeto LiveData para agregar la Actividad o Fragmento correspondiente como observador del objeto LiveData, de la siguiente manera:

@Override
protected void onCreate(Bundle savedInstanceState) {
    
    
    super.onCreate(savedInstanceState);
    binding = DataBindingUtil.setContentView(this,R.layout.activity_main);
    MViewModel mViewModel = ViewModelProviders.of(this).get(MViewModel.class);
    mViewModel.getData().observe(this, new Observer<String>() {
    
    
        @Override
        public void onChanged(String msg) {
    
    
            binding.setData(msg);
        }
    });
}

3. Use setValue o postValue de LiveData para actualizar los datos y luego obtenga los datos actualizados en el observador, es decir, Actividad o Fragmento, de la siguiente manera:

public void setData(String data) {
    
    
    mData.setValue(data);
}

Entonces, ¿cómo crear observadores sin LifecycleOwner? Puede usar el método observeForever del objeto LiveData para agregar una clase sin LifecycleOwner a la lista de observadores, de la siguiente manera:

public class NoLifecycleOwner {
    
    
    public void print(NViewModel viewModel, final TextView tvData){
    
    
        //使用observeForever对象创建没有LifecycleOwner的观察者
        viewModel.getData().observeForever(new Observer<String>() {
    
    
            @Override
            public void onChanged(String s) {
    
    
                tvData.setText("我是没有LifecycleOwner的观察者:"+s);
            }
        });
    }
}

Sin embargo, el uso de observeForever para obtener el objeto observador siempre estará activo. En este momento, debemos llamar manualmente a removeObserver (Observer) para eliminar el observador.

Livedata personalizado

Puede utilizar el objeto LiveData con conocimiento del ciclo de vida para proporcionar servicios al mundo exterior, y puede controlar cómodamente la apertura y el cierre del servicio, de la siguiente manera:

/**
 * 自定义LiveData
 * Powered by jzman.
 * Created on 2018/12/17 0017.
 */
public class CustomLiveData extends LiveData<String> {
    
    

    @Override
    protected void onActive() {
    
    
        //有活跃观察者调用该方法
        //开启服务...
    }

    @Override
    protected void onInactive() {
    
    
        //没有任何活跃观察者调用该方法
        //结束服务...
    }
}

Conversión de LiveData

Lifecycle proporciona la clase de herramienta Transformaciones para convertir los tipos de datos de LiveData. Puede modificar los tipos específicos de datos en LiveData antes de que LiveData devuelva los datos al observador. Por ejemplo, los números de tipo int 1, 2, etc. se convierten en mayúsculas en chino uno, dos, etc., Entonces, cómo usarlo, cree MapViewModel de la siguiente manera:

/**
 * LiveData转换
 * Powered by jzman.
 * Created on 2018/12/17 0017.
 */
public class MapViewModel extends ViewModel {
    
    
    private MutableLiveData<Integer> mPrice = new MutableLiveData<>();

    //Map
    private LiveData<String> mMapPrice = Transformations.map(mPrice, new Function<Integer, String>() {
    
    
        @Override
        public String apply(Integer input) {
    
    
            //返回String
            return Util.getNumberCapital(input);
        }
    });

    //SwitchMap
    private LiveData<String> mSwitchMapPrice = Transformations.switchMap(mPrice, new Function<Integer, LiveData<String>>() {
    
    
        @Override
        public LiveData<String> apply(Integer input) {
    
    
            //返回LiveData
            MutableLiveData<String> data = new MutableLiveData<>();
            data.postValue(Util.getNumberCapital(input));
            return data;
        }
    });

    public void setPrice(int price) {
    
    
        mPrice.setValue(price);
    }

    public LiveData<String> getPrice() {
    
    
        //Map
        return mMapPrice;
        //SwitchMap
//        return mSwitchMapPrice;
    }
}

Luego, observe los cambios en los datos en Actividad, de la siguiente manera:

public class MapActivity extends AppCompatActivity {
    
    
    private MapViewModel mapViewModel;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
    
    
        super.onCreate(savedInstanceState);
        final ActivityMapBinding binding = DataBindingUtil.setContentView(this,R.layout.activity_map);
        mapViewModel = new MapViewModel();
        mapViewModel.getPrice().observe(this, new Observer<String>() {
    
    
            @Override
            public void onChanged(String s) {
    
    
                //数字转换为中文大写
                binding.tvData.setText(s);
            }
        });
    }

    public void btnSetPrice1(View view) {
    
    
        mapViewModel.setPrice(1);
    }

    public void btnSetPrice2(View view) {
    
    
        mapViewModel.setPrice(2);
    }
}

La única diferencia entre los métodos map y switchMap en la clase de herramienta Transformations es que map convierte datos LiveData a un tipo específico, como String en el código anterior, mientras que switchMap es LiveData. El método getNumberCapital en el código anterior es solo un método de conversión de caso., Los resultados de la prueba son los siguientes:

Tanto el método map como el método switchMap son convertidos internamente por MediatorLiveData. Puede usar MediatorLiveData para implementar más conversiones de tipos de datos como map y switch.