SharedFlow کیا ہے؟ Android میں SharedFlow بمقابلہ StateFlow

Kotlin میں SharedFlow کیا ہے؟

SharedFlow kotlinx.coroutines.flow لائبریری کا ایک گرم بہاؤ (hot flow) ہے، جو StateFlow کے برعکس کسی ایک حالت سے منسلک نہیں ہوتا اور من مانی تعداد میں واقعات من مانی سبسکرائبرز کو بھیج سکتا ہے۔ SharedFlow StateFlow کے لیے بنیادی قسم ہے — StateFlow دراصل replay = 1 کے ساتھ SharedFlow کے ذریعے لاگو کیا گیا ہے۔

SharedFlow کی کلیدی خصوصیت یہ ہے کہ اسے آخری قدر محفوظ کرنے کی ضرورت نہیں ہے۔ پہلے سے طے شدہ طور پر (replay = 0)، نیا سبسکرائبر کچھ حاصل نہیں کرتا جب تک کوئی نیا واقعہ نہ بھیجا جائے۔ یہ SharedFlow کو ان منظرناموں کے لیے مثالی بناتا ہے جہاں واقعہ کو صرف ایک بار پروسیس کیا جانا چاہیے: نیویگیشن، Snackbar، سسٹم نوٹیفیکیشن، QR کوڈ اسکیننگ کے نتائج۔

SharedFlow کو kotlinx.coroutines 1.4.0 (نومبر 2020) میں StateFlow کے ساتھ مستحکم کیا گیا تھا۔ Kotlin Coroutines دستاویزات (2025) کے مطابق، SharedFlow سبسکرائبرز کو ہم آہنگ کرنے کے لیے باریک دانے دار لاک کا استعمال کرتا ہے اور JetBrains ٹیسٹوں سے تصدیق شدہ کارکردگی میں تنزلی کے بغیر 1000+ بیک وقت سبسکرائبرز تک لکیری اسکیل ایبلٹی فراہم کرتا ہے۔

SharedFlow vs StateFlow: کب کیا استعمال کریں

SharedFlow اور StateFlow کے درمیان انتخاب منتقل کردہ ڈیٹا کے معنویات پر منحصر ہے: حالت (StateFlow) یا واقعہ (SharedFlow)۔ ذیل میں — مثالوں کے ساتھ واضح معیار۔

سادہ اصول: اگر ڈیٹا اسکرین گھمانے پر دکھایا جانا چاہیے — یہ حالت ہے (StateFlow)۔ اگر اسکرین گھمانے پر واقعہ دہرایا نہیں جانا چاہیے — یہ ایک بار استعمال ہونے والا واقعہ ہے (SharedFlow)۔ مثال کے طور پر، «خرابی کے پیغام کا ٹوسٹ» — SharedFlow: اسکرین گھمانے پر ٹوسٹ دوبارہ نہیں دکھایا جانا چاہیے۔ «مصنوعات کی فہرست» — StateFlow: اسکرین گھمانے پر فہرست اسکرین پر رہنی چاہیے۔

IT Sectr میں ہم SharedFlow استعمال کرتے ہیں: نیویگیشن کمانڈز (اسکرین پر جانا، ڈیپ لنک کھولنا)، UI واقعات (Snackbar, AlertDialog)، سسٹم نوٹیفیکیشن (پس منظر میں ڈیٹا اپ ڈیٹ، ادائیگی کا نتیجہ)، تجزیاتی واقعات (لاگنگ، ٹریکنگ)۔

MutableSharedFlow: emit، tryEmit اور بفرنگ

MutableSharedFlow واقعات بھیجنے کے لیے emit() (suspend) اور tryEmit()(non-suspend) طریقوں کے ساتھ SharedFlow کا قابل تبدیل ورژن ہے۔ اگر بفر بھرا ہوا ہو اور onBufferOverflow = SUSPEND ہو تو emit() معطل ہو جاتا ہے۔ tryEmit() Boolean لوٹاتا ہے — واقعہ بفر میں کامیابی سے شامل ہوا یا نہیں۔

class EventBus {
    private val _events = MutableSharedFlow<UiEvent>(
        replay = 0,
        extraBufferCapacity = 10,
        onBufferOverflow = BufferOverflow.DROP_OLDEST
    )
    val events: SharedFlow<UiEvent> get() = _events

    suspend fun sendEvent(event: UiEvent) {
        _events.emit(event)
    }

    fun trySendEvent(event: UiEvent): Boolean {
        return _events.tryEmit(event)
    }
}

sealed interface UiEvent {
    data class ShowSnackbar(val message: String) : UiEvent
    data class NavigateTo(val route: String) : UiEvent
    data class ShowDialog(val title: String, val message: String) : UiEvent
}

تعمیری پیرامیٹرز اہم ہیں: replay = 0 اس بات کی ضمانت دیتا ہے کہ واقعہ نئے سبسکرائبر کے لیے دہرایا نہیں جائے گا؛ extraBufferCapacity = 10 — UI کے سبسکرائب ہونے سے پہلے تیز واقعہ بھیجنے کی صورت میں بفر؛ DROP_OLDEST — بھرنے پر حکمت عملی: پرانے واقعات ضائع ہو جاتے ہیں، نئے محفوظ رہتے ہیں۔ Kotlin Coroutines Performance (JetBrains, 2024) کے مطابق، extraBufferCapacity = 64 کے ساتھ SharedFlow بغیر نقصان کے فی سیکنڈ 100,000 سے زیادہ واقعات پر کارروائی کرتا ہے۔

SharedFlow کے ساتھ ایک بار استعمال ہونے والے واقعات: Event پیٹرن

Event پیٹرن (یا UiEvent) — ViewModel سے View میں ایک بار استعمال ہونے والے واقعات کی منتقلی کے لیے Google کا تجویز کردہ طریقہ۔ حالت (StateFlow) کے برعکس، واقعہ کو صرف ایک بار پروسیس کیا جانا چاہیے، اور اسکرین گھمانے پر اسے دہرایا نہیں جانا چاہیے۔ replay = 0 کے ساتھ SharedFlow اس کام کے لیے مثالی ہے۔

class CheckoutViewModel : ViewModel() {
    private val _uiState = MutableStateFlow<CheckoutState>(CheckoutState.Idle)
    val uiState: StateFlow<CheckoutState> get() = _uiState

    private val _event = MutableSharedFlow<CheckoutEvent>()
    val event: SharedFlow<CheckoutEvent> get() = _event

    fun placeOrder() {
        viewModelScope.launch {
            _uiState.value = CheckoutState.Loading
            try {
                val orderId = orderRepository.createOrder(cart)
                _uiState.value = CheckoutState.Success(orderId)
                _event.emit(CheckoutEvent.NavigateToOrderTracking(orderId))
            } catch (e: Exception) {
                _uiState.value = CheckoutState.Error(e.message)
                _event.emit(CheckoutEvent.ShowErrorSnackbar(e.message ?: "آرڈر کی خرابی"))
            }
        }
    }
}

sealed interface CheckoutEvent {
    data class NavigateToOrderTracking(val orderId: String) : CheckoutEvent
    data class ShowErrorSnackbar(val message: String) : CheckoutEvent
}

View میں (Activity/Fragment): واقعہ کی سبسکرپشن lifecycleScope میں repeatOnLifecycle(STATE.STARTED) کے ساتھ کی جانی چاہیے۔ STARTED میں ہر داخلے پر سبسکرپشن دوبارہ بنتی ہے، لیکن واقعہ دہرایا نہیں جاتا کیونکہ replay=0 والا SharedFlow اسے پہلے ہی جاری کر چکا ہے۔ یہ اس بات کی ضمانت دیتا ہے کہ آرڈر ٹریکنگ اسکرین پر نیویگیشن ہر اسکرین گھمانے پر نہیں بلکہ صرف ایک بار ہوگی۔

SharedFlow پیرامیٹرز: replay، extraBufferCapacity، onBufferOverflow

MutableSharedFlow تعمیر کنندہ تین پیرامیٹرز لیتا ہے جو بفر کے رویے کا تعین کرتے ہیں۔ غلط ترتیب واقعات کے نقصان یا emit() کی مسدودی کا سبب بن سکتی ہے۔

// مختلف منظرناموں کے لیے ترتیبات:

// 1. ایک بار استعمال ہونے والے UI واقعات (نیویگیشن، ٹوسٹ)
val uiEvents = MutableSharedFlow<UiEvent>(
    replay = 0,
    extraBufferCapacity = 5,
    onBufferOverflow = BufferOverflow.DROP_OLDEST
)

// 2. حالت کی مطابقت پذیری کے لیے Replay بہاؤ (StateFlow کی طرح)
val stateLike = MutableSharedFlow<AppState>(
    replay = 1,
    extraBufferCapacity = 0
)

// 3. زیادہ فریکوئنسی والے واقعات کی ترسیل (تجزیہ، لاگز)
val analytics = MutableSharedFlow<AnalyticsEvent>(
    replay = 0,
    extraBufferCapacity = 100,
    onBufferOverflow = BufferOverflow.DROP_OLDEST
)

اہم: extraBufferCapacity + replay = کل بفر سائز۔ اگر emit() سبسکرائبر کے واقعہ پر کارروائی کرنے سے زیادہ تیزی سے بلایا جائے تو بفر بھر جاتا ہے اور onBufferOverflow عمل میں آتا ہے۔ UI واقعات کے لیے DROP_OLDEST ایک محفوظ حکمت عملی ہے: پرانے واقعات (جو اب متعلقہ نہیں ہیں) نئے کے حق میں ضائع کر دیے جاتے ہیں۔ مالی لین دین کے لیے SUSPEND استعمال کریں — یہ بھیجنے والے کو مسدود کرنے کی قیمت پر کسی واقعہ کے ضائع نہ ہونے کی ضمانت دیتا ہے۔

Kotlin میں SharedFlow کوڈ کی مثالیں

مثال 1: Jetpack Navigation کے ساتھ SharedFlow

نیویگیشن کمانڈز SharedFlow کے لیے کلاسک استعمال کا معاملہ ہیں۔ Fragment واقعات کو سبسکرائب کرکے نیویگیشن انجام دیتا ہے۔ اسکرین گھمانے پر کمانڈ دہرائی نہیں جاتی۔

// ViewModel
class AuthViewModel : ViewModel() {
    private val _navEvent = MutableSharedFlow<NavEvent>()
    val navEvent: SharedFlow<NavEvent> get() = _navEvent

    fun onLoginSuccess() {
        viewModelScope.launch {
            _navEvent.emit(NavEvent.NavigateTo(NavRoutes.HOME))
        }
    }

    fun onLogout() {
        viewModelScope.launch {
            _navEvent.emit(NavEvent.NavigateTo(NavRoutes.LOGIN))
        }
    }
}

sealed interface NavEvent {
    data class NavigateTo(val route: String) : NavEvent
    data class NavigateBack(val popUpTo: String? = null) : NavEvent
}

// Fragment میں:
viewLifecycleOwner.lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.navEvent.collect { navEvent ->
            when (navEvent) {
                is NavEvent.NavigateTo -> findNavController().navigate(navEvent.route)
                is NavEvent.NavigateBack -> findNavController().popBackStack()
            }
        }
    }
}

مثال 2: Room اور Flow آپریٹرز کے ساتھ SharedFlow

پیچیدہ منظرنامہ: UI کے لیے StateFlow کے ساتھ ملا کر پس منظر کے واقعات کی اطلاع کے لیے SharedFlow۔

class NotificationViewModel : ViewModel() {
    private val _toastMessage = MutableSharedFlow<String>()
    val toastMessage: SharedFlow<String> get() = _toastMessage

    private val _notifications = MutableStateFlow<List<Notification>>(emptyList())
    val notifications: StateFlow<List<Notification>> get() = _notifications

    init {
        viewModelScope.launch {
            notificationChannel
                .consumeAsFlow()
                .collect { notification ->
                    _notifications.value = _notifications.value + notification
                    _toastMessage.emit("نئی اطلاع: ${notification.title}")
                }
        }
    }

    fun dismissNotification(id: String) {
        _notifications.value = _notifications.value.filter { it.id != id }
    }

    fun markAllRead() {
        viewModelScope.launch {
            _notifications.value = _notifications.value.map { it.copy(isRead = true) }
            _toastMessage.emit("تمام اطلاعات پڑھی ہوئی نشان زد")
        }
    }
}

اس مثال میں: StateFlow اطلاعوں کی فہرست محفوظ کرتا ہے (حالت — اسکرین گھمانے پر محفوظ رہتی ہے)، SharedFlow ٹوسٹ پیغامات بھیجتا ہے (ایک بار استعمال ہونے والے واقعات — اسکرین گھمانے پر دہرائے نہیں جاتے)۔ دو Flow اقسام کا مجموعہ 2022 سے Google کا ViewModel کے لیے تجویز کردہ پیٹرن ہے۔