Android LiveData: ¿cómo reutilizar el mismo ViewModel en diferentes actividades?

Ejemplo de modelo de vista:

public class NameViewModel extends ViewModel {
    // Create a LiveData with a String
    private MutableLiveData<String> mCurrentName;

    public MutableLiveData<String> getCurrentName() {
        if (mCurrentName == null) {
            mCurrentName = new MutableLiveData<>();
        }
        return mCurrentName;
    }

}

Actividad principal:

mModel = ViewModelProviders.of(this).get(NameViewModel.class);

// Create the observer which updates the UI.
final Observer<String> nameObserver = textView::setText;

// Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
mModel.getCurrentName().observe(this, nameObserver);

quiero llamar mModel.getCurrentName().setValue(anotherName); en la segunda actividad y hacer que MainActivity reciba cambios. ¿Es eso posible?

Cuando usted llama ViewModelProviders.of(this)en realidad creas/retienes un ViewModelStore que está obligado a thispor lo que diferentes actividades tienen diferentes ViewModelStore y cada ViewModelStore crea una instancia diferente de un ViewModel utilizando una fábrica determinada, por lo que no puede tener la misma instancia de un ViewModel en diferentes ViewModelStores.

Pero puede lograr esto pasando una única instancia de una fábrica ViewModel personalizada que actúa como una fábrica única, por lo que siempre pasará la misma instancia de su ViewModel entre diferentes actividades.

Por ejemplo:

public class SingletonNameViewModelFactory extends ViewModelProvider.NewInstanceFactory {


    NameViewModel t;

    public SingletonNameViewModelFactory() {
      //  t = provideNameViewModelSomeHowUsingDependencyInjection
    }

    @Override
    public NameViewModel create(Class<NameViewModel> modelClass) {
        return t;
    }
}

Entonces lo que necesitas es hacer SingletonNameViewModelFactory singleton (por ejemplo, usando Dagger) y úsalo así:

mModel = ViewModelProviders.of(this,myFactory).get(NameViewModel.class);

Nota:

Conservación ViewModels entre diferentes ámbitos es un anti-patrón. Se recomienda encarecidamente conservar los objetos de la capa de datos (p. ej., hacer que su Fuente de datos o Repositorio sea único) y conservar sus datos entre diferentes ámbitos (Actividades).

Leer este artículo para más detalles.

Al obtener el modelo de vista usando los ViewModelProviders que está pasando como propietario del ciclo de vida MainActivity, esto le dará el modelo de vista para esa actividad. En la segunda actividad, obtendrá una instancia diferente de ese ViewModel, esta vez para su segunda actividad. El segundo modelo tendrá un segundo datos en vivo.

Lo que puede hacer es mantener los datos en una capa diferente, como un repositorio, que puede ser un singleton y de esa manera puede usar el mismo modelo de vista.

public class NameViewModel extends ViewModel {
    // Create a LiveData with a String
    private MutableLiveData<String> mCurrentName;

    public MutableLiveData<String> getCurrentName() {
        if (mCurrentName == null) {
            mCurrentName = DataRepository.getInstance().getCurrentName();
        }
        return mCurrentName;
    }
}

//SingleTon
public class DataRepository     

    private MutableLiveData<String> mCurrentName;

    public MutableLiveData<String> getCurrentName() {
        if (mCurrentName == null) {
            mCurrentName = new MutableLiveData<>();
        }
        return mCurrentName;
    }
//Singleton code
...
}

Simplemente cree la instancia de su Ver modeloen este caso NombreVerModelo

Tu ViewModel Factory será como

class ViewModelFactory : ViewModelProvider.NewInstanceFactory() {

    override fun <T : ViewModel?> create(modelClass: Class<T>) =
        with(modelClass){
            when {
                isAssignableFrom(NameViewModel::class.java) -> NameViewModel.getInstance()
                else -> throw IllegalArgumentException("Unknown viewModel class $modelClass")
            }
        } as T


    companion object {
        private var instance : ViewModelFactory? = null
        fun getInstance() =
            instance ?: synchronized(ViewModelFactory::class.java){
                instance ?: ViewModelFactory().also { instance = it }
            }
    }
}

Y tu modelo de vista

class NameViewModel : ViewModel() {

    //your liveData objects and many more...

    companion object {
        private var instance : NameViewModel? = null
        fun getInstance() =
            instance ?: synchronized(NameViewModel::class.java){
                instance ?: NameViewModel().also { instance = it }
            }
    }
}

Ahora puedes usar ViewModelProviders para obtener la misma instancia de su ViewModel para usar en cualquier actividad

ViewModelProviders.of(this, ViewModelFactory.getInstance()).get(NameViewModel::class.java)

O

crear una función de extensión para facilitar el acceso

fun <T : ViewModel> AppCompatActivity.getViewModel(viewModelClass: Class<T>) =
    ViewModelProviders.of(this, ViewModelFactory.getInstance()).get(viewModelClass)

El alcance/ciclo de vida de ViewModel está vinculado a una actividad simplemente porque el ViewModelStoreOwner que pasa al constructor de ViewModelProvider resulta ser la actividad.

Dado que puede proporcionar ViewModelStoreOwner, puede proporcionar fácilmente uno que tenga un ciclo de vida más largo, como la aplicación.

Puedes

1. Proporcione su propia subclase de aplicación y haga que implemente ViewModelStoreOwner (y tenga un ViewModelStore)
2. En las llamadas al constructor de ViewModelProvider, pase actividad.aplicación en lugar de actividad.

Esto hará que ViewModelProvider interactúe con ViewModelStore a nivel de la aplicación, lo que le permitirá crear instancias de ViewModel que tendrán el alcance de la aplicación.