ViewModel + LiveData, Retrofit + Coroutines के एक समूह के साथ एक Android अनुप्रयोग में सरल वास्तुकला का संगठन

लंबे परिचय के बिना, मैं आपको बताता हूं कि आपके आवेदन की सुविधाजनक वास्तुकला को जल्दी और आसानी से कैसे व्यवस्थित किया जाए। सामग्री उन लोगों के लिए उपयोगी होगी जो mvvm पैटर्न और कोटलिन कोराउटीन से बहुत परिचित नहीं हैं।

इसलिए, हमारे पास एक सरल कार्य है: नेटवर्क अनुरोध प्राप्त करने और संसाधित करने के लिए, एक दृश्य में परिणाम प्रदर्शित करने के लिए।

हमारे कार्य: गतिविधि (खंड) से, हम वांछित विधि को कहते हैं ViewModel -> ViewModel रेट्रोफिट हैंडल तक पहुंचता है, कोरआउट के माध्यम से अनुरोध को निष्पादित करता है -> प्रतिक्रिया एक घटना के रूप में लाइव डेटा को भेजी जाती है -> उस गतिविधि में> जो हम दृश्य को डेटा स्थानांतरित करते हैं।

प्रोजेक्ट सेटअप

पर निर्भर करता है

//Retrofit implementation 'com.squareup.retrofit2:retrofit:2.6.2' implementation 'com.squareup.retrofit2:converter-gson:2.6.2' implementation 'com.squareup.okhttp3:logging-interceptor:4.2.1' //Coroutines implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0' implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0' //ViewModel lifecycle implementation 'androidx.lifecycle:lifecycle-extensions:2.1.0' implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0-rc01" 

घोषणापत्र

 <manifest ...> <uses-permission android:name="android.permission.INTERNET" /> </manifest> 

रेट्रोफिट सेटअप

एक Kotlinovsky NetworkService ऑब्जेक्ट बनाएँ। यह हमारा नेटवर्क क्लाइंट - सिंगलटन होगा
यूपीडी सिंगलटन को समझने में आसानी के लिए उपयोग किया जाता है। टिप्पणियों ने संकेत दिया कि नियंत्रण व्युत्क्रम का उपयोग करना अधिक उपयुक्त है, लेकिन यह एक अलग विषय है।

 object NetworkService { private const val BASE_URL = " http://www.mocky.io/v2/" // HttpLoggingInterceptor       private val loggingInterceptor = run { val httpLoggingInterceptor = HttpLoggingInterceptor() httpLoggingInterceptor.apply { httpLoggingInterceptor.level = HttpLoggingInterceptor.Level.BODY } } private val baseInterceptor: Interceptor = invoke { chain -> val newUrl = chain .request() .url .newBuilder() .build() val request = chain .request() .newBuilder() .url(newUrl) .build() return@invoke chain.proceed(request) } private val client: OkHttpClient = OkHttpClient .Builder() .addInterceptor(loggingInterceptor) .addInterceptor(baseInterceptor) .build() fun retrofitService(): Api { return Retrofit.Builder() .baseUrl(BASE_URL) .addConverterFactory(GsonConverterFactory.create()) .client(client) .build() .create(Api::class.java) } } 

आपी इंटरफ़ेस

हम नकली सेवा के लिए बंद अनुरोधों का उपयोग करते हैं।

मज़े को रोकिए, यहाँ से शुरू होता है कोरटीन का जादू।

हम कीवर्ड सस्पेंड फ़न के साथ अपने कार्यों को चिह्नित करते हैं ...।

रेट्रॉलिट ने 2.6.0 संस्करण से कोटलिन निलंबित कार्यों के साथ काम करना सीखा, अब यह सीधे नेटवर्क अनुरोध को निष्पादित करता है और डेटा के साथ एक वस्तु लौटाता है:

 interface Api { @GET("5dcc12d554000064009c20fc") suspend fun getUsers( @Query("page") page: Int ): ResponseWrapper<Users> @GET("5dcc147154000059009c2104") suspend fun getUsersError( @Query("page") page: Int ): ResponseWrapper<Users> } 

ResponseWrapper हमारे नेटवर्क अनुरोधों के लिए एक सरल आवरण वर्ग है:

 class ResponseWrapper<T> : Serializable { @SerializedName("response") val data: T? = null @SerializedName("error") val error: Error? = null } 

दिनांक वर्ग उपयोगकर्ता

 data class Users( @SerializedName("count") var count: Int?, @SerializedName("items") var items: List<Item?>? ) { data class Item( @SerializedName("first_name") var firstName: String?, @SerializedName("last_name") var lastName: String? ) } 

ViewModel

हम एक सार BaseViewModel क्लास बनाते हैं, जहाँ से हमारे सभी ViewModel को विरासत में मिलेगा। यहाँ हम और अधिक विस्तार से रहते हैं:

 abstract class BaseViewModel : ViewModel() { var api: Api = NetworkService.retrofitService() //       requestWithLiveData  // requestWithCallback,       //           // .       suspend , //             //    .      fun <T> requestWithLiveData( liveData: MutableLiveData<Event<T>>, request: suspend () -> ResponseWrapper<T>) { //        liveData.postValue(Event.loading()) //     ViewModel,  viewModelScope. //        //    . //   IO     this.viewModelScope.launch(Dispatchers.IO) { try { val response = request.invoke() if (response.data != null) { //     postValue  IO  liveData.postValue(Event.success(response.data)) } else if (response.error != null) { liveData.postValue(Event.error(response.error)) } } catch (e: Exception) { e.printStackTrace() liveData.postValue(Event.error(null)) } } } fun <T> requestWithCallback( request: suspend () -> ResponseWrapper<T>, response: (Event<T>) -> Unit) { response(Event.loading()) this.viewModelScope.launch(Dispatchers.IO) { try { val res = request.invoke() //   ,    //       ,  //    //    //  context  launch(Dispatchers.Main) { if (res.data != null) { response(Event.success(res.data)) } else if (res.error != null) { response(Event.error(res.error)) } } } catch (e: Exception) { e.printStackTrace() // UPD (  )   catch     Main  launch(Dispatchers.Main) { response(Event.error(null)) } } } } } 

घटना

Google का एक शांत समाधान एक इवेंट रैपर क्लास में डेट क्लासेस को लपेटना है जिसमें हमारे पास कई राज्य हो सकते हैं, आमतौर पर LOADING, SUCCESS और ERROR।

 data class Event<out T>(val status: Status, val data: T?, val error: Error?) { companion object { fun <T> loading(): Event<T> { return Event(Status.LOADING, null, null) } fun <T> success(data: T?): Event<T> { return Event(Status.SUCCESS, data, null) } fun <T> error(error: Error?): Event<T> { return Event(Status.ERROR, null, error) } } } enum class Status { SUCCESS, ERROR, LOADING } 

यहाँ यह कैसे काम करता है। एक नेटवर्क अनुरोध के दौरान, हम स्थिति के साथ एक घटना बनाते हैं। हम सर्वर से प्रतिक्रिया की प्रतीक्षा कर रहे हैं और फिर घटना के साथ डेटा को लपेटते हैं और इसे निर्दिष्ट स्थिति के साथ आगे भेजते हैं। दृश्य में, हम घटना के प्रकार की जांच करते हैं और, राज्य के आधार पर, दृश्य के लिए अलग-अलग राज्य निर्धारित करते हैं। एमवीआई का आर्किटेक्चर पैटर्न उसी दर्शन पर आधारित है।

ActivityViewModel

 class ActivityViewModel : BaseViewModel() { //       val simpleLiveData = MutableLiveData<Event<Users>>() //  .    requestWithLiveData //  BaseViewModel     , //          //     api.getUsers //         //    fun getUsers(page: Int) { requestWithLiveData(simpleLiveData) { api.getUsers( page = page ) } } //  ,       // UPD           fun getUsersError(page: Int, callback: (data: Event<Users>) -> Unit) { requestWithCallback({ api.getUsersError( page = page ) }) { callback(it) } } } 

और अंत में

MainActivity

 class MainActivity : AppCompatActivity() { private lateinit var activityViewModel: ActivityViewModel override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) activityViewModel = ViewModelProviders.of(this).get(ActivityViewModel::class.java) observeGetPosts() buttonOneClickListener() buttonTwoClickListener() } //     //         private fun observeGetPosts() { activityViewModel.simpleLiveData.observe(this, Observer { when (it.status) { Status.LOADING -> viewOneLoading() Status.SUCCESS -> viewOneSuccess(it.data) Status.ERROR -> viewOneError(it.error) } }) } private fun buttonOneClickListener() { btn_test_one.setOnClickListener { activityViewModel.getUsers(page = 1) } } //      ,   private fun buttonTwoClickListener() { btn_test_two.setOnClickListener { activityViewModel.getUsersError(page = 2) { when (it.status) { Status.LOADING -> viewTwoLoading() Status.SUCCESS -> viewTwoSuccess(it.data) Status.ERROR -> viewTwoError(it.error) } } } } private fun viewOneLoading() { //  ,    } private fun viewOneSuccess(data: Users?) { val usersList: MutableList<Users.Item>? = data?.items as MutableList<Users.Item>? usersList?.shuffle() usersList?.let { Toast.makeText(applicationContext, "${it}", Toast.LENGTH_SHORT).show() } } private fun viewOneError(error: Error?) { //   } private fun viewTwoLoading() {} private fun viewTwoSuccess(data: Users?) {} private fun viewTwoError(error: Error?) { error?.let { Toast.makeText(applicationContext, error.errorMsg, Toast.LENGTH_SHORT).show() } } } 

स्रोत कोड