remember — کلیدی تصورات، دوبارہ ترتیب کے درمیان اقدار کا تحفظ

Jetpack Compose میں remember کیا ہے

remember androidx.compose.runtime پیکج سے ایک بلٹ ان Jetpack Compose فنکشن ہے جو ایک ایسی شے بناتا ہے جو Composable فنکشن کی متواتر کالوں کے درمیان اپنی قدر محفوظ رکھتی ہے۔ تکنیکی طور پر، remember سلاٹس کے ساتھ کام کرتا ہے — UI درخت میں ہر فنکشن کال کی پوزیشن کے لیے مختص خصوصی میموری خلیات۔ جب تک فنکشن ترکیب میں رہتا ہے (if شرط کے ذریعے نہیں ہٹایا جاتا)، remember ہر دوبارہ ترتیب پر محفوظ کردہ قدر لوٹائے گا۔

remember کا نحو سادہ ہے: گھنگریالے بریکٹ کے اندر ابتدائی قدر کے حساب کا بلاک متعین کیا جاتا ہے۔ بلاک صرف ایک بار عمل میں آتا ہے — فنکشن کی پہلی ترکیب کے دوران۔ بعد میں ہونے والی تمام دوبارہ ترتیبیں بلاک کو دوبارہ عمل میں لائے بغیر پہلے سے محفوظ کردہ قدر لوٹاتی ہیں۔ تاہم، اگر ایک کلیدی پیرامیٹر متعین کیا گیا ہے، تو کلید بدلنے پر بلاک دوبارہ عمل میں آتا ہے، جو ان پٹ ڈیٹا کی بنیاد پر قدر کو دوبارہ شمار کرنے کی اجازت دیتا ہے۔

remember کوٹلن کا جادو نہیں ہے — یہ ایک کلیدی پیرامیٹر اور حساب لیمبڈا کے ساتھ ایک سادہ فنکشن ہے۔ اس کا اندرونی نفاذ سلاٹس کو پڑھنے اور لکھنے کے لیے Composer استعمال کرتا ہے۔ کوٹلن کمپائلر، remember کال دیکھ کر، کوڈ تیار کرتا ہے جو موجودہ CompositionContext تک رسائی حاصل کرتا ہے اور سلاٹس کا انتظام کرتا ہے۔ اس کا مطلب ہے کہ remember صرف Composable فنکشن کے اندر یا ترکیب کے سیاق و سباق میں کسی دوسرے فنکشن میں کال کیا جا سکتا ہے۔

remember کی اقسام: remember، rememberSaveable، derivedStateOf

Jetpack Compose میں، remember کی تین اہم اقسام ہیں، ہر ایک کا اپنا مقصد ہے۔ بنیادی remember صرف موجودہ عمل کی میموری میں قدر محفوظ رکھتا ہے — اسکرین گھومنے (کنفیگریشن تبدیلی) پر، Compose ترکیب کو دوبارہ بناتا ہے اور تمام remember قدریں ری سیٹ ہو جاتی ہیں۔ کنفیگریشن تبدیلیوں اور عمل کے رکنے کے دوران ڈیٹا محفوظ رکھنے کے لیے rememberSaveable استعمال کیا جاتا ہے۔

rememberSaveable SavedStateHandle یا Parcelable میکانزم کے ذریعے قدر کو Bundle میں سیریلائز کرتا ہے۔ یہ اسکرین گھومنے، "سرگرمیاں نہ رکھیں" کی ترتیب اور عارضی ایپ چھوٹے کرنے سے بچنے کی اجازت دیتا ہے۔ تاہم، rememberSaveable ذخیرہ کیے جا سکنے والے ڈیٹا کی قسم پر پابندیاں لگاتا ہے: وہ ابتدائی، Parcelable، Serializable ہونا چاہئیں یا Saver کنورٹر کو سپورٹ کرنا چاہیے۔

derivedStateOf تحفظ کا طریقہ کار نہیں بلکہ ایک بهتری ہے۔ یہ ایک State بناتا ہے جس کی قدر دوسری State اشیاء سے شمار کی جاتی ہے۔ derivedStateOf ماخذ حالتوں میں تبدیلیوں پر ردعمل ظاہر کرتا ہے لیکن قدر صرف اس وقت دوبارہ شمار کرتا ہے جب سبسکرائبرز ہوں۔ اگر موجودہ دوبارہ ترتیب derivedStateOf نہیں پڑھتی ہے، تو حساب نہیں کیا جاتا، جو بار بار لیکن غیر ضروری اپ ڈیٹس پر وسائل بچاتا ہے۔

@Composable
fun RememberVariants() {
    // 1. بنیادی remember: ترکیب چھوڑنے تک برقرار رہتا ہے
    val createdAt = remember { System.currentTimeMillis() }

    // 2. rememberSaveable: اسکرین گھومنے سے بچ جاتا ہے
    var username by rememberSaveable { mutableStateOf("") }

    // 3. derivedStateOf: صرف ضرورت پڑنے پر شمار ہوتا ہے
    val isButtonVisible = remember {
        derivedStateOf { username.length() > 3 }
    }

    Text("بنایا گیا: $createdAt")
    TextField(value = username, onValueChange = { username = it })

    if (isButtonVisible.value) {
        Text("بٹن دکھایا جائے گا")
    }
}

remember بمقابلہ rememberSaveable: کب کیا استعمال کریں

remember اور rememberSaveable کے درمیان انتخاب اس بات پر منحصر ہے کہ کنفیگریشن تبدیلیوں کے دوران ڈیٹا کا تحفظ کتنا اہم ہے۔ عارضی حالتوں کے لیے جو گھومنے پر کھونے میں اہم نہیں ہیں (حرکت پذیری، موجودہ اسکرول پوزیشن، فوکس حالت) — عام remember کافی ہے۔ اہم ڈیٹا کے لیے (فارم میں متن، منتخب اشیاء، چیک باکسز) — rememberSaveable استعمال کریں۔

کارکردگی: rememberSaveable عام remember سے سست ہے کیونکہ اسے Bundle میں سیریلائزیشن کی ضرورت ہوتی ہے۔ rememberSaveable صرف اس ڈیٹا کے لیے استعمال کریں جسے واقعی Activity کی دوبارہ تخلیق سے بچنے کی ضرورت ہے۔ باقی سب کے لیے — سادہ remember۔ rememberSaveable کا ضرورت سے زیادہ استعمال اسکرین گھومنے اور ایپس کے درمیان سوئچ کرنے پر سستی کا باعث بنتا ہے۔

اگر آپ ان کلاسز کے ساتھ کام کرتے ہیں جو Parcelable یا Serializable کو سپورٹ نہیں کرتی ہیں، تو Saver استعمال کریں — ایک کنورٹر جو متعین کرتا ہے کہ شے کو کیسے محفوظ اور بحال کرنا ہے۔ Saver کا بیان لیمبڈا کے ایک جوڑے سے کیا جاتا ہے: save (شے کو قابل ذخیرہ قسم میں تبدیل کرتا ہے) اور restore (محفوظ کردہ ڈیٹا سے شے کو بحال کرتا ہے)। mutableStateListOf اور mutableStateMapOf کے لیے ایک معیاری Saver پہلے سے نافذ ہے۔

حقیقی منصوبوں میں remember کے استعمال کی مثالیں

ایک عام منظر نامے پر غور کریں — ایک پروفائل ترمیم اسکرین جہاں remember کئی مقاصد کے لیے استعمال ہوتا ہے: فارم فیلڈز کی حالت ذخیرہ کرنا، مشتق اقدار کا حساب لگانا اور حسابی طور پر مہنگی کارروائیوں کو کیش کرنا۔

data class ProfileUiState(
    val name: String = "",
    val bio: String = "",
    val isSaving: Boolean = false
)

@Composable
fun ProfileEditor() {
    var state by rememberSaveable { mutableStateOf(ProfileUiState()) }
    val isValid = remember {
        derivedStateOf { state.name.isNotBlank() && state.bio.length() <= 500 }
    }

    val bioWarning = remember(state.bio) {
        if (state.bio.length() > 400) {
            "${500 - state.bio.length} chars left"
        } else null
    }

    Column(modifier = Modifier.padding(16.dp)) {
        OutlinedTextField(
            value = state.name,
            onValueChange = { state = state.copy(name = it) },
            label = { Text("نام") }
        )

        OutlinedTextField(
            value = state.bio,
            onValueChange = { state = state.copy(bio = it) },
            label = { Text("کے بارے میں") }
        )

        bioWarning?.let { Text(it, color = MaterialTheme.colorScheme.error) }

        Button(onClick = { /* save */ },
            enabled = isValid.value) {
            Text("محفوظ کریں")
        }
    }
}

مثال میں، حالت rememberSaveable کے ذریعے محفوظ کی جاتی ہے — اسکرین گھومنے پر متن ضائع نہیں ہوگا۔ isValid کا حساب derivedStateOf کے ذریعے کیا جاتا ہے، جو دوبارہ ترتیب کے دوران غیر ضروری حسابات کو روکتا ہے۔ bioWarning bio کلید کے ساتھ remember استعمال کرتا ہے — یہ ایک مہنگا حساب ہے (اختیاری، مظاہرے کے لیے) جو صرف bio بدلنے پر دوبارہ شمار ہوتا ہے، ہر دوبارہ ترتیب پر نہیں۔

مشتق حالتیں اور کنجیوں کے ساتھ remember

مشتق حالتیں وہ اقدار ہیں جو دوسری State اشیاء سے شمار کی جاتی ہیں۔ ہر دوبارہ ترتیب پر ان کا حساب لگانے اور ایک جیسے نتائج پر CPU ضائع کرنے کے بجائے، remember derivedStateOf کے ساتھ قدر صرف اس وقت شمار کرتا ہے جب ذرائع بدلتے ہیں۔ یہ خاص طور پر فلٹرنگ، ترتیب اور ڈیٹا جمع کرنے کے لیے مفید ہے۔

کنجیوں کے ساتھ remember (remember(key) { calculation }) ایک اور بهتری کا طریقہ کار ہے۔ اگر پچھلی دوبارہ ترتیب کے بعد سے کلید نہیں بدلی ہے، تو حساب کا بلاک عمل میں نہیں آتا اور کیش کی گئی قدر لوٹائی جاتی ہے۔ یہ ان اشیاء کو کیش کرنے کے لیے آسان ہے جن کی تخلیق مہنگی ہے: تاریخ کی فارمیٹنگ، JSON تجزیہ، بڑے ناقابل تبدیل مجموعے بنانا۔

@Composable
fun SearchResults(allItems: List<Item>, query: String) {
    // derivedStateOf: فلٹر صرف ان پٹ بدلنے پر دوبارہ شمار ہوتا ہے
    val filtered = remember {
        derivedStateOf {
            allItems.filter { it.title.contains(query, true) }
        }
    }

    // کلید کے ساتھ remember: فارمیٹ شدہ اعدادوشمار صرف سوال بدلنے پر دوبارہ شمار ہوتے ہیں
    val statsText = remember(query) {
        "Results for query \"$query\": ${filtered.value.size}"
    }

    Text(statsText)
    LazyColumn {
        items(filtered.value, key = { it.id }) { item ->
            Text(item.title)
        }
    }
}

filtered ایک derivedStateOf ہے جو allItems یا query بدلنے پر خود بخود دوبارہ شمار ہوتا ہے۔ statsText remember(query) استعمال کرتا ہے — مہنگی سٹرنگ فارمیٹنگ صرف اس وقت کی جاتی ہے جب تلاش کا سوال بدلتا ہے۔ derivedStateOf اور کنجیوں کے ساتھ remember کا امتزاج زیادہ سے زیادہ کارکردگی دیتا ہے: مشتق حالت صرف ضرورت پڑنے پر شمار کی جاتی ہے اور پیچیدہ اشیاء کلید بدلنے تک کیش رہتی ہیں۔