آموزش flow در اندروید: راهنمای جامع flow در کاتلین

flow در اندروید یک کتابخانه برنامه‌نویسی است که در کتابخانه Kotlin Coroutines موجود است و برای برنامه‌نویسی آسینکرون (async) در اندروید استفاده می‌شود. از طریق Flow، شما می‌توانید داده‌ها را به صورت پیوسته و آسینکرون پردازش کنید و بازخورد بین اجزا مختلف برنامه را بهبود بخشید.

 

 

“ما را در اینستاگرام دنبال کنید”

در این مقاله از سری مقالات کاتلین می خواهیم شما را با flow در اندروید آشنا کنیم. پس با سایت ترولرن همراه باش.

“قبل از شروع مقاله، بگم که بعد از مطالعه این مطلب، از آموزش پروژه محور برنامه نویسی اندروید سایتمون یعنی دوره ژنرال اندروید غافل نشید.”

توی دوره ژنرال صفر تا صد flow در اندروید رو در یک فصل کامل توضیح دادیم و همچنین توی پروژه های دیجی کالا و اسنپ فود به صورت عملی و پروژه محور از flow استفاده کردیم و بطور کامل اون رو آموزش دادیم.

flow در اندروید چیست؟

flow در اندروید به عنوان یک الگوی برنامه‌نویسی رویداد-مبتنی بر-جریان (Event-Driven Stream) استفاده می‌شود. این الگو به شما امکان می‌دهد داده‌ها را در قالب جریانی پردازش کنید و بر اساس رویدادهایی که در طول زمان رخ می‌دهند، با آنها تعامل کنید.

در Flow، شما با استفاده از توابعی مانند flowOf، asFlow، یا تابع flow، یک جریان ایجاد می‌کنید.

این جریان می‌تواند داده‌هایی از هر نوعی که شما نیاز دارید را حمل کند، مانند اعداد، رشته‌ها، شیء‌ها و غیره. سپس با استفاده از توابعی مانند map، filter، transform و reduce، داده‌های Flow را پردازش می‌کنید.

یکی از مزایای flow در اندروید این است که به صورت پیش‌فرض توسط کوروتین‌ها همروند است. این بدان معنی است که می‌توانید برنامه‌های همروند را با استفاده از Flow بسازید و عملیات‌های آسینکرون را به صورت ساده در کد خود دستکاری کنید.

می‌توانید از توابعی مانند launch, async و withContext برای ایجاد همروندی در کوروتین‌ها استفاده کنید و برنامه‌های پاسخ‌دهی به رویدادها را بهبود بخشید.

از جمله استفاده‌های متداول Flow در اندروید می‌توان به موارد زیر اشاره کرد:

۱. پیاده سازی رویدادهای زمانی

می‌توانید از Flow برای پیاده سازی رویدادهای زمانی مانند تغییرات در حسگرها (مانند شتاب‌سنج) یا تغییرات در داده‌های شبکه استفاده کنید. با استفاده از Flow، می‌توانید داده‌های را به صورت پیوسته دریافت کرده و در واکنش به آنها عمل کنید.

۲. جمع‌آوری داده‌های پشته

اگر نیاز دارید داده‌های گسترده‌ای را از منابع مختلف جمع‌آوری کنیدو آنها را به صورت پیوسته در یک جریان پردازش کنید، Flow به شما این امکان را می‌دهد. می‌توانید از توابع مانند zip, combine و flattenMerge برای ترکیب و تجمیع داده‌های مختلف استفاده کنید.

۳. پردازش داده‌های بلادرنگ

با استفاده از Flow، می‌توانید عملیات‌های پردازش داده‌ها را به صورت بلادرنگ (asynchronous) انجام دهید. می‌توانید توابعی مانند map, filter, flatMap, distinct و … را بر روی داده‌های Flow اعمال کنید و نتایج را به صورت آسینکرون دریافت کنید.

۴. مدیریت خطا و لغو

با استفاده از Flow و کوروتین‌ها، می‌توانید خطاها را مدیریت کنید و عملیات‌های لغو را پیاده سازی کنید. با استفاده از توابعی مانند catch, retry, onCompletion و … می‌توانید خطاها را تشخیص داده و بر اساس شرایط مورد نظر عمل کنید.

Flow یکی از قابلیت‌های قدرتمندی است که به برنامه‌نویسان اندروید امکان پردازش داده‌ها به صورت آسینکرون، همروند و پیوسته را می‌دهد. با استفاده از Flow، می‌توانید برنامه‌هایی با عملکرد بهتر، پاسخ‌دهی سریع‌تر و کد قابل فهمتر بنویسید.

می‌توانید از Observable در RxJava، در یا استریم‌های دیگر مانند LiveData در زمینه برنامه‌نویسی اندروید استفاده کنید. هر یک از این راهکارها مفهومی مشابه با Flow دارند که برای پردازش آسینکرون داده‌ها و رفتاری راکتیو طراحی شده‌اند.

به طور خلاصه، Flow در کاتلین و Kotlin Coroutines یک راهکار برای پردازش آسینکرون داده‌هاست و در زمینه برنامه‌نویسی reactive ، برخی از راهکارهای دیگر مانند Observable و Flux معادل‌هایی مشابه برای Flow هستند. انتخاب راهکار مناسب بستگی به زبان برنامه‌نویسی، فریمورک مورد استفاده و نیازهای خاص پروژه دارد. اما flow راهکاری جدیدتر، قدرتمندتر و سازگار تر است.

 

 

یک مثال کامل از استفاده از flow در معماری MVVM با استفاده از جت پک کامپوز و هیلت:

بهترین راه برای نشان دادن یک مثال کامل از استفاده از Flow در Kotlin MVVM Jetpack Compose Hilt، این است که یک برنامه ساده‌ای را برای مدیریت لیستی از کاربران پیاده‌سازی کنیم. در این مثال، از شبکه برای دریافت لیست کاربران استفاده می‌کنیم و از Flow برای پردازش آسینکرون داده‌ها استفاده می‌کنیم. همچنین از MVVM برای طراحی الگوی معماری استفاده می‌کنیم و از Jetpack Compose برای رابط کاربری بصری استفاده می‌کنیم. همچنین از Hilt برای مدیریت وابستگی‌ها و تزریق وابستگی استفاده می‌کنیم.

در ابتدا، به فایل build.gradle پروژه خود رفته و اطمینان حاصل کنید که شما از کتابخانه‌های Jetpack Compose و Hilt استفاده می‌کنید. فایل build.gradle باید مشابه کد زیر باشد:

// برای Jetpack Compose
dependencies {
    implementation 'androidx.core:core-ktx:1.7.0'
    implementation 'androidx.compose.ui:ui:1.1.0-beta01'
    implementation 'androidx.compose.material:material:1.1.0-beta01'
    implementation 'androidx.compose.runtime:runtime-livedata:1.1.0-beta01'
}

// برای Hilt
dependencies {
    implementation 'com.google.dagger:hilt-android:2.39.1'
    kapt 'com.google.dagger:hilt-android-compiler:2.39.1'
    implementation 'androidx.hilt:hilt-lifecycle-viewmodel:1.0.0-alpha03'
    kapt 'androidx.hilt:hilt-compiler:1.0.0'
}

حالا، باید یک ViewModel برای مدیریت لیست کاربران ایجاد کنیم. در این ViewModel، از Flow برای دریافت داده‌ها استفاده خواهیم کرد. برای شروع، یک ریپازیتوری (Repository) برای ارتباط با شبکه را پیاده‌سازی می‌کنیم و سپس از آن در ViewModel استفاده می‌کنیم. کد زیر را به فایل ViewModel اضافه کنید:

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch
import javax.inject.Inject

@HiltViewModel
class UserViewModel @Inject constructor(
    private val userRepository: UserRepository
) : ViewModel() {

    private val _userList = MutableStateFlow<List<User>>(emptyList())
    val userList: StateFlow<List<User>> get() = _userList

    init {
        fetchUsers()
    }

    private fun fetchUsers() {
        viewModelScope.launch {
            userRepository.getUsers().collect { userList ->
                _userList.value = userList
            }
        }
    }
}

در این ViewModel، از MutableStateFlow برای نگهداری لیست کاربران استفاده می‌کنیم. به عنوان یک StateFlow عمومی، می‌توانیم به لیست کاربران در UI دسترسی داشته باشیم. در init بلاک، لیست کاربران را از ریپازیتوری دریافت می‌کنیم و با استفاده از collect از Flow، تغییرات را در userList به روز می‌کنیم.

حالا باید ریپازیتوری را پیاده‌سازی کنیم. ریپازیتوری مسئول دریافت داده‌ها از شبکه است. کد زیر را به فایل UserRepository اضافه کنید:

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.withContext
import javax.inject.Inject

class UserRepository @Inject constructor() {

    suspend fun getUsers(): Flow<List<User>> = withContext(Dispatchers.IO) {
        // شبیه‌سازی دریافت داده‌ها از شبکه با تاخیر
        delay(2000)
        
        // اینجا می‌توانید کد واقعی برای دریافت داده‌ها از شبکه را پیاده‌سازی کنید
        val users = listOf(
            User("1", "John"),
            User("2", "Alice"),
            User("3", "Bob")
        )
        
        // تبدیل لیست کاربران به یک Flow
        flow {
            emit(users)
        }
    }
}

در این ریپازیتوری، در تابع getUsers از Flow برای بازگرداندن لیست کاربران استفاده می‌کنیم. توجه کنید که اینجا یک شبیه‌سازی است و شما باید کد واقعی برای دریافت داده‌ها از شبکه را پیاده‌سازی کنید.

حالا باید رابط کاربری را پیاده‌سازی کنیم. برای این منظور، از Jetpack Compose استفاده می‌کنیم. کد زیر را به فایل Composable اضافه کنید:

import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Surface
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.ui.tooling.preview.Preview
import androidx.lifecycle.viewmodel.compose.viewModel
import dagger.hilt.android.AndroidEntryPoint

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            UsersList()
        }
    }
}

@Composable
fun UsersList(userViewModel: UserViewModel = viewModel()) {
    val userList = userViewModel.userList.collectAsState(emptyList()).value

    Surface(color = MaterialTheme.colors.background) {
        LazyColumn {
            items(userList) { user ->
                UserItem(user)
            }
        }
    }
}

@Composable
fun UserItem(user: User) {
    // نمایش جزئیات کاربر
}

در این کد، از collectAsState برای دریافت لیست کاربران از ViewModel استفاده می‌کنیم. سپس با استفاده از LazyColumn و items، لیست کاربران را نمایش می‌دهیم.

این مثال یک نمونه ساده از استفاده از Flow در Kotlin MVVM ،Jetpack Compose ،Hilt است. شما می‌توانید آن را برای پروژه‌های بزرگتر و پیچیده‌تر گسترش دهید.

حرف آخر

به طور خلاصه، flow در اندروید یک روش قدرتمند برای مدیریت داده‌های آسینکرون در اندروید است. با استفاده از Flow و کوروتین‌ها، می‌توانید کدهای پاسخ‌دهی به رویدادها،در اندروید را بهبود بخشید و عملیات‌های آسینکرون را به صورت ساده‌تر و قابل فهمتری انجام دهید. با مطالعه و آشنایی بیشتر با مفاهیم و متدهای موجود در کتابخانه Flow، می‌توانید برنامه‌های Android خود را با کدی قابل خواندن، قابل توسعه و قابل اطمینان بنویسید.

و همچنین ممنون میشم از طریق ستاره‌های این پایین به این مقاله امتیاز بدی و اگه هر سوالی داشتی توی قسمت دیدگاه بپرس و قطعا بهت پاسخ میدیم.