web-dev-qa-db-fra.com

Android - MVVM avec composant LiveData et appel de modification dans le référentiel

J'aimerais utiliser les composants suivants pour une vue d'authentification (connexion):

  • MVVM
  • Données en direct
  • Retrofit
  • Dépôt

Je ne sais pas comment puis-je recevoir un appel de modification asynchrone dans la classe Repository vers le ViewModel actuel.

Voir -> ViewModel -> Référentiel avec LiveData.

Quelqu'un aurait une idée ou un exemple pour résoudre ce problème?

androidretrofitrepository-patternandroid-livedata
4
rmarbaix

Vous pouvez faire comme ci-dessous:

YourActivity.kt 

class YourActivity : AppCompatActivity() {

private val myViewModel by lazy {
    return@lazy ViewModelProviders.of(this).get(MyViewModel::class.Java) }
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onViewReady(savedInstanceState)
    myViewModel.callApi() // You can do it anywhere, on button click etc..
    observeResponseData() // observe it once in onCreate(), it'll respect your activity lifecycle
}

private fun observeResponseData() {
    myViewModel.liveData.observe(this, Observer { data ->
        // here will be your response
    })
}
}

MyViewModel.kt 

class MyViewModel : ViewModel() {

val liveData = MutableLiveData<Your response type here>()
val myRepository = MyRepository()

fun callApi() {
    myRepository.callMyRetrofitApi(liveData)
}
}

MyRepository.kt 

class MyRepository {
//Make your retrofit setup here

//This is the method that calls API using Retrofit
fun callMyRetrofitApi(liveData: MutableLiveData<Your response type here>) {
    // Your Api Call with response callback
    myRetrofitInstance.apiMethod.enqueue(object : Callback<Your response type here> {
        override fun onFailure(call: Call<Your response type here>, t: Throwable) {

        }

        override fun onResponse(call: Call<Your response type here>, response: Response<Your response type here>) {
            liveData.value = response.body()
        }

    })
}
}

Essayez de faire la configuration comme ça.

J'espère que ça aide !

4
Jeel Vankhede

Le moyen le plus simple de concevoir votre projet dans MVVM à l'aide de LiveData et de Retrofit consiste à utiliser LiveData dans votre classe ViewModel et à Retrofit dans votre référentiel. 

En termes simples, vous obtenez des données de votre référentiel dans votre classe ViewModel et dans votre classe ViewModel, vous transmettez ces données au MutableLiveData , puis ce MutableLiveData peut être observé dans votre vue en le convertissant en LiveData. 

MainActivity.Java

public class MainActivity extends AppCompatActivity {
        private MainViewModel mainViewModel;

      @Override
      protected void onCreate(@Nullable Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_instruction);
                mainViewModel = ViewModelProviders.of(this).get(MainViewModel.class);
                mainViewModel.init();
                mainViewModel.getModelLiveData().observe(this, new Observer<MainResponse>() {
                @Override
                public void onChanged(@Nullable MainResponse mainResponse) {
                // Here you write logic which implements if the ViewModel data changes. 
             }}
         });
      }
    }

MainViewModel (votre ViewModel)

public class MainViewModel extends ViewModel {
private MainRepo mainRepo;
private MutableLiveData<MainResponse> modelMutableLiveData = new MutableLiveData<>();
Disposable disposable;

public MainViewModel() {
}

public MainViewModel(MainRepo mainRepo) {
    this.mainRepo = mainRepo;
}

public void init() {
                    modelMutableLiveData.setValue(mainRepo.callRetrofit().body());
                }

public LiveData<MainResponse> getModelLiveData() {
    return modelMutableLiveData;
   }
}

MainRepository (votre classe de référentiel)

    public class MainRepository{

            public void callRetrofit() {
                    apiInterface = 
        ApiClient.getClient(ApiClient.POST_STATUS_URL).create(ApiInterface.class);
        Call<ModelForPostRequest> call = apiInterface.likeItem(modelForPostRequest);
        call.enqueue(new Callback<ModelForPostRequest>() {
        @Override
        public void onResponse(Call<ModelForPostRequest> call, 
                Response<ModelForPostRequest> response) {
            return response;
        }

        @Override
        public void onFailure(Call<ModelForPostRequest> call, Throwable t) {
        }
    });
}}
1
Abhishek Kumar