লেজি লিস্ট ও লেজি গ্রিড

অনেক অ্যাপকে আইটেমের কালেকশন দেখাতে হয়। এই ডকুমেন্ট ব্যাখ্যা করে যে কীভাবে আপনি Jetpack Compose-এ দক্ষতার সাথে এটি করতে পারেন।

আপনি যদি জানেন যে আপনার ব্যবহারের ক্ষেত্রে কোনও স্ক্রোলিংয়ের প্রয়োজন নেই, তাহলে আপনি একটি সাধারণ Column বা Row (দিকনির্দেশের উপর নির্ভর করে) ব্যবহার করতে চাইতে পারেন এবং নিম্নলিখিত উপায়ে একটি তালিকার উপর ইটারেট করে প্রতিটি আইটেমের কন্টেন্ট এমিট করতে পারেন:

@Composable
fun MessageList(messages: List<Message>) {
    Column {
        messages.forEach { message ->
            MessageRow(message)
        }
    }
}

verticalScroll() মডিফায়ার ব্যবহার করে আমরা Column স্ক্রল করার সুবিধা দিতে পারি।

লেজি তালিকা

আপনাকে যদি অনেক আইটেম (বা অজানা দৈর্ঘ্যের তালিকা) দেখাতে হয়, তাহলে Column-এর মতো লেআউট ব্যবহার করলে পারফর্ম্যান্স সংক্রান্ত সমস্যা হতে পারে, কারণ সব আইটেম কম্পোজ ও লেআউট করা হবে, সেগুলি দেখা যাক বা না যাক।

Compose এমন এক সেট কম্পোনেন্ট প্রদান করে যা শুধুমাত্র কম্পোনেন্টের ভিউপোর্টে দৃশ্যমান আইটেমগুলি কম্পোজ এবং লেআউট করে। এইসব কম্পোনেন্টের মধ্যে LazyColumn এবং LazyRow অন্তর্ভুক্ত।

নাম থেকেই বোঝা যায় যে LazyColumn এবং LazyRow -এর মধ্যে পার্থক্য হল, আইটেমগুলি কীভাবে সাজানো এবং স্ক্রল করা হয়। LazyColumn উল্লম্বভাবে স্ক্রল করা যায় এমন তালিকা তৈরি করে এবং LazyRow অনুভূমিকভাবে স্ক্রল করা যায় এমন তালিকা তৈরি করে।

Compose-এ বেশিরভাগ লেআউটের থেকে Lazy কম্পোনেন্ট আলাদা। @Composable কন্টেন্ট ব্লক প্যারামিটার গ্রহণ করার পরিবর্তে, অ্যাপকে সরাসরি কম্পোজেবল নির্গত করার অনুমতি দিয়ে, Lazy কম্পোনেন্ট একটি LazyListScope.() ব্লক প্রদান করে। এই LazyListScope ব্লক একটি DSL অফার করে যা অ্যাপগুলিকে আইটেমের কন্টেন্ট বর্ণনা করার অনুমতি দেয়। লেআউট ও স্ক্রল পজিশন অনুযায়ী প্রতিটি আইটেমের কন্টেন্ট যোগ করার দায়িত্ব Lazy কম্পোনেন্টের উপর বর্তায়।

LazyListScope DSL

LazyListScope-এর DSL লেআউটে আইটেম বর্ণনা করার জন্য অনেকগুলি ফাংশন প্রদান করে। সবচেয়ে সহজভাবে, item() একটি আইটেম যোগ করে এবং items(Int) একাধিক আইটেম যোগ করে:

LazyColumn {
    // Add a single item
    item {
        Text(text = "First item")
    }

    // Add 5 items
    items(5) { index ->
        Text(text = "Item: $index")
    }

    // Add another single item
    item {
        Text(text = "Last item")
    }
}

এছাড়াও, বেশ কিছু এক্সটেনশন ফাংশন আছে যা আপনাকে আইটেমের সংগ্রহ যোগ করার অনুমতি দেয়, যেমন List। এইসব এক্সটেনশন আমাদের সহজেই উপরের Column উদাহরণ মাইগ্রেট করতে দেয়:

/**
 * import androidx.compose.foundation.lazy.items
 */
LazyColumn {
    items(messages) { message ->
        MessageRow(message)
    }
}

এছাড়াও, items() এক্সটেনশন ফাংশনের একটি ভ্যারিয়েন্ট আছে, যাকে itemsIndexed() বলা হয়, যা ইন্ডেক্স প্রদান করে। আরও বিবরণের জন্য LazyListScope রেফারেন্স দেখুন।

লেজি গ্রিড

LazyVerticalGrid এবং LazyHorizontalGrid কম্পোজেবল গ্রিডে আইটেম দেখানোর জন্য সহায়তা প্রদান করে। একটি লেজি ভার্টিক্যাল গ্রিড এটির আইটেমগুলি একটি উল্লম্বভাবে স্ক্রোলযোগ্য কন্টেনারে প্রদর্শন করবে, যা একাধিক কলাম জুড়ে বিস্তৃত, যখন লেজি হরাইজন্টাল গ্রিডগুলির অনুভূমিক অক্ষে একই আচরণ থাকবে।

গ্রিডে তালিকার মতোই শক্তিশালী API ক্ষমতা রয়েছে এবং তারা কন্টেন্ট বর্ণনা করার জন্য খুব একই রকম DSL - LazyGridScope.() ব্যবহার করে।

ফোনের স্ক্রিনশট যেখানে ফটোর গ্রিড দেখানো হচ্ছে

LazyVerticalGrid-এ columns প্যারামিটার এবং LazyHorizontalGrid-এ rows প্যারামিটার কলাম বা সারিতে কীভাবে সেল তৈরি করা হয় তা নিয়ন্ত্রণ করে। নিম্নলিখিত উদাহরণে গ্রিডে আইটেম দেখানো হয়েছে, যেখানে GridCells.Adaptive ব্যবহার করে প্রতিটি কলামের প্রস্থ অন্তত 128.dp সেট করা হয়েছে:

LazyVerticalGrid(
    columns = GridCells.Adaptive(minSize = 128.dp)
) {
    items(photos) { photo ->
        PhotoItem(photo)
    }
}

LazyVerticalGrid আপনাকে আইটেমের প্রস্থ নির্দিষ্ট করতে দেয় এবং তারপর গ্রিড যতগুলি সম্ভব কলাম ফিট করবে। কলামের সংখ্যা গণনা করার পরে, অবশিষ্ট প্রস্থ কলামগুলির মধ্যে সমানভাবে বিতরণ করা হয়। বিভিন্ন স্ক্রিন সাইজ জুড়ে আইটেমের সেট দেখানোর জন্য এই অ্যাডাপ্টিভ সাইজিং পদ্ধতিটি বিশেষভাবে উপযোগী।

আপনি যদি ঠিক কতগুলি কলাম ব্যবহার করতে হবে তা জানেন, তাহলে আপনি এর পরিবর্তে GridCells.Fixed -এর একটি ইনস্ট্যান্স প্রদান করতে পারেন যাতে প্রয়োজনীয় সংখ্যক কলাম রয়েছে।

আপনার ডিজাইনে যদি শুধুমাত্র নির্দিষ্ট কিছু আইটেমের জন্য নন-স্ট্যান্ডার্ড ডাইমেনশনের প্রয়োজন হয়, তাহলে আপনি আইটেমের জন্য কাস্টম কলাম স্প্যান প্রদান করতে গ্রিড সাপোর্ট ব্যবহার করতে পারেন। item এবং items পদ্ধতির LazyGridScope DSL span প্যারামিটার দিয়ে কলাম স্প্যান নির্দিষ্ট করুন। maxLineSpan, স্প্যান স্কোপের একটি মান, বিশেষ করে যখন আপনি অ্যাডাপ্টিভ সাইজিং ব্যবহার করছেন তখন এটি উপযোগী, কারণ কলামের সংখ্যা নির্দিষ্ট নয়। এই উদাহরণে দেখানো হয়েছে কীভাবে সম্পূর্ণ সারি স্প্যান প্রদান করতে হয়:

LazyVerticalGrid(
    columns = GridCells.Adaptive(minSize = 30.dp)
) {
    item(span = {
        // LazyGridItemSpanScope:
        // maxLineSpan
        GridItemSpan(maxLineSpan)
    }) {
        CategoryCard("Fruits")
    }
    // ...
}

লেজি স্ট্যাগার্ড গ্রিড

LazyVerticalStaggeredGrid এবং LazyHorizontalStaggeredGrid হল কম্পোজেবল যা আপনাকে আইটেমের ধীরে ধীরে লোড করা, স্ট্যাগার্ড গ্রিড তৈরি করতে দেয়। একটি লেজি ভার্টিক্যাল স্ট্যাগার্ড গ্রিড তার আইটেমগুলিকে একটি উল্লম্বভাবে স্ক্রোলযোগ্য কন্টেনারে প্রদর্শন করে যা একাধিক কলাম জুড়ে বিস্তৃত এবং পৃথক আইটেমগুলিকে বিভিন্ন উচ্চতার হতে দেয়। লেজি হরাইজন্টাল গ্রিডের আচরণ হরাইজন্টাল অক্ষে একই রকম হয়, তবে আইটেমের প্রস্থ আলাদা হয়।

নিম্নলিখিত স্নিপেটটি হল আইটেম প্রতি 200.dp প্রস্থ সহ LazyVerticalStaggeredGrid ব্যবহার করার একটি প্রাথমিক উদাহরণ:

LazyVerticalStaggeredGrid(
    columns = StaggeredGridCells.Adaptive(200.dp),
    verticalItemSpacing = 4.dp,
    horizontalArrangement = Arrangement.spacedBy(4.dp),
    content = {
        items(randomSizedPhotos) { photo ->
            AsyncImage(
                model = photo,
                contentScale = ContentScale.Crop,
                contentDescription = null,
                modifier = Modifier
                    .fillMaxWidth()
                    .wrapContentHeight()
            )
        }
    },
    modifier = Modifier.fillMaxSize()
)

ছবি ১. লেজি স্ট্যাগার্ড ভার্টিক্যাল গ্রিডের উদাহরণ

কলামের একটি নির্দিষ্ট সংখ্যা সেট করতে, আপনি StaggeredGridCells.Adaptive-এর পরিবর্তে StaggeredGridCells.Fixed(columns) ব্যবহার করতে পারেন। এটি উপলভ্য প্রস্থকে কলামের সংখ্যা (বা অনুভূমিক গ্রিডের জন্য সারি) দ্বারা ভাগ করে এবং প্রতিটি আইটেম সেই প্রস্থ (বা অনুভূমিক গ্রিডের জন্য উচ্চতা) গ্রহণ করে:

LazyVerticalStaggeredGrid(
    columns = StaggeredGridCells.Fixed(3),
    verticalItemSpacing = 4.dp,
    horizontalArrangement = Arrangement.spacedBy(4.dp),
    content = {
        items(randomSizedPhotos) { photo ->
            AsyncImage(
                model = photo,
                contentScale = ContentScale.Crop,
                contentDescription = null,
                modifier = Modifier
                    .fillMaxWidth()
                    .wrapContentHeight()
            )
        }
    },
    modifier = Modifier.fillMaxSize()
)
Compose-এ ছবির লেজি স্ট্যাগার্ড গ্রিড
ছবি ২. নির্দিষ্ট কলাম সহ লেজি স্ট্যাগার্ড উল্লম্ব গ্রিডের উদাহরণ

LazyLayoutCacheWindow-এর মাধ্যমে স্ক্রল পারফর্ম্যান্স উন্নত করুন

LazyLayoutCacheWindow হল এমন একটি API যা তালিকা, গ্রিড ও স্ট্যাগার্ড গ্রিডে স্ক্রল পারফর্ম্যান্স উন্নত করতে সাহায্য করার জন্য ডিজাইন করা হয়েছে। CacheWindow-এ, আপনি এমন একটি ভার্চুয়াল স্পেস নির্ধারণ করতে পারবেন যেখানে স্ক্রল ইভেন্টের সময় আইটেম প্রিফেচ (আগের উইন্ডো) বা অ্যাক্টিভ (পরের উইন্ডো) রাখা যাবে। এর অর্থ হল আইটেম কম্পোজিশন ও পরিমাপ ইন্টার্নাল ক্যাশে প্রাইম করে — যখন এইসব আইটেম আসলে প্রয়োজন হয় (যখন সেগুলি দৃশ্যমান হয়), তখন সেগুলি স্ক্র্যাচ থেকে তৈরি করার তুলনায় দেখাতে অনেক কম সময় লাগে।

সব লেজি কালেকশন ডিফল্ট প্রিফেচ স্ট্র্যাটেজি হিসেবে CacheWindow ব্যবহার করে। ডিফল্ট উইন্ডো ভিউপোর্টের ১০% থেকে ৫০% এর মধ্যে প্রিফেচ দূরত্বকে ক্ল্যাম্প করে। এটি পিছনের উইন্ডোকে ০ পিক্সেলে সেট করে এবং স্ক্রল করা যায় না এমন ক্যাশিং বন্ধ করে দেয়।

উইন্ডো কনফিগারেশন

আপনি Dp-এ ভিউপোর্ট ফ্র্যাকশন বা নির্দিষ্ট দূরত্ব ব্যবহার করে ক্যাশে উইন্ডো কনফিগার করতে পারবেন:

// Fraction-based cache window: prefetch 50% of viewport ahead, keep 20% behind
LazyColumn(
    cacheWindow = LazyLayoutCacheWindow(aheadFraction = 0.5f, behindFraction = 0.2f)
) {
    items(itemsList) { item -> Text("Item $item") }
}

// Dp-based cache window: prefetch 150.dp ahead, keep 50.dp behind
LazyVerticalGrid(
    columns = GridCells.Fixed(3),
    cacheWindow = LazyLayoutCacheWindow(
        ahead = 150.dp,
        behind = 50.dp,
        isNonScrollCachingEnabled = true
    )
) {
    items(itemsList) { item -> Text("Item $item") }
}

ক্যাশে উইন্ডো স্ক্রল করার দিকের সাথে সম্পর্কিত দুটি স্বতন্ত্র অঞ্চল ম্যানেজ করে:

  • আগে থেকে উইন্ডো: ফ্রেমওয়ার্ক আসন্ন আইটেমগুলি দৃশ্যমান ভিউপোর্টে প্রবেশ করার আগেই সেগুলি আগে থেকে কম্পোজ ও পরিমাপ করে। এটি ডিফল্ট হিসেবে 0dp বা 0f-এ সেট করা থাকে।
  • উইন্ডোর পিছনে: ফ্রেমওয়ার্ক সম্প্রতি স্ক্রল-অফ করা আইটেমগুলি বাতিল না করে রেখে দেয়। ব্যবহারকারী স্ক্রল করার দিক পরিবর্তন করলে, রিটেন করা আইটেম পুনরায় কম্পোজ বা পরিমাপ না করেই সাথে সাথে দেখানো হয়। এটি ডিফল্ট হিসেবে 0dp বা 0f-এ সেট করা থাকে।

এছাড়াও, আপনি isNonScrollCachingEnabled = true (ডিফল্ট ভ্যালু) সেট করলে, ব্যবহারকারী স্ক্রল না করার সময় লেআউটটি পরবর্তী উইন্ডোটি দেখায়। এইসব ট্রিগারের মধ্যে প্রাথমিক লেআউট পাস, ডেটাসেট আপডেট ও আইটেম আবার সাজানো অন্তর্ভুক্ত। false-এ সেট করা হলে, শুধুমাত্র স্ক্রল ইভেন্ট চলাকালীন ক্যাশিং হয়।

কাস্টম CacheWindow

নির্দিষ্ট দূরত্ব বা ভিউপোর্ট ফ্র্যাকশন আপনার লেআউট প্যাটার্নের সাথে ম্যাচ না করলে, আপনি সরাসরি LazyLayoutCacheWindow ইন্টারফেস প্রয়োগ করতে পারবেন:

interface LazyLayoutCacheWindow {
    fun Density.calculateAheadWindow(viewport: Int): Int = 0
    fun Density.calculateBehindWindow(viewport: Int): Int = 0
    val isNonScrollCachingEnabled: Boolean get() = false
}

প্রদত্ত ভিউপোর্ট সাইজের জন্য পিক্সেলে পছন্দের উইন্ডো সাইজ ফিরিয়ে আনতে ক্যালকুলেশন পদ্ধতি প্রয়োগ করুন:

class ScaledCacheWindow(
    val someLayoutState: LayoutState
) : LazyLayoutCacheWindow {
    override fun Density.calculateAheadWindow(viewport: Int): Int {
        return someLayoutState.specialDynamicCalculation().coerceAtMost(viewport * 5)
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is ScaledCacheWindow) return false
        return someLayoutState == other.someLayoutState
    }

    override fun hashCode(): Int {
        return someLayoutState.hashCode()
    }
}

@Composable
fun ScaledCacheWindowSample() {
    val state = rememberLazyListState()
    val newCacheWindow = remember { ScaledCacheWindow(state) }
    LazyColumn(
        state = state,
        cacheWindow = newCacheWindow,
    ) {
        items(100) { index ->
            Text(
                text = "Item #$index",
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(16.dp),
            )
        }
    }
}

মাইগ্রেশন গাইড

প্রাথমিক প্রিফেচিং কনফিগারেশন API (PrefetchStrategy) এবং LazyLayoutCacheWindow-এর প্রথম ভার্সন, স্টেটগুলিতে কনফিগারেশন করার অনুমতি দেয়, তবে এই কার্যকারিতা এখন বন্ধ করে দেওয়া হয়েছে। এই বিভাগে বর্ণনা করা হয়েছে যে কীভাবে নিম্নলিখিত বন্ধ হয়ে যাওয়া API ও প্যারামিটার থেকে মাইগ্রেট করবেন:

  • rememberLazyListState এবং rememberLazyGridState-এ রাজ্য-ভিত্তিক cacheWindow প্যারামিটার।
  • LazyListPrefetchStrategy এবং LazyGridPrefetchStrategy-এর সাথে LazyLayoutCacheWindow।

বিকল্প ১: cacheWindowটি আর্গুমেন্ট সরান

সাজেস্ট করা API-তে মাইগ্রেট করতে, cacheWindow আর্গুমেন্ট rememberLazyListState এবং rememberLazyGridState থেকে সরিয়ে cacheWindow আর্গুমেন্ট LazyColumn, LazyRow, LazyVerticalGrid এবং LazyHorizontalGrid-এ ব্যবহার করুন। LazyVerticalStaggeredGrid এবং LazyHorizontalStaggeredGrid লেআউট কম্পোজেবলে নতুন প্যারাডাইম আগে থেকেই প্রয়োগ করে।

// Before (Experimental in Compose 1.9 to 1.12, now Deprecated)
val state = rememberLazyListState(
    cacheWindow = LazyLayoutCacheWindow(aheadFraction = 0.5f, behindFraction = 0.2f)
)
LazyColumn(state = state) {
    items(itemsList) { item -> Text("Item $item") }
}

// Now in Compose 1.13 (Stable)
val state = rememberLazyListState()
LazyColumn(
    state = state,
    cacheWindow = LazyLayoutCacheWindow(aheadFraction = 0.5f, behindFraction = 0.2f)
) {
    items(itemsList) { item -> Text("Item $item") }
}

বিকল্প ২: LazyListPrefetchStrategy এবং LazyGridPrefetchStrategy পরিবর্তন করুন

LazyListPrefetchStrategy এবং LazyGridPrefetchStrategy API-এর ব্যবহার বন্ধ করা হয়েছে, এর পরিবর্তে LazyLayoutCacheWindow ব্যবহার করুন। অভ্যন্তরীণভাবে, সব প্রিফেচিং আচরণ এখন cacheWindow-এর উপর নির্ভর করে। এই পরিবর্তন নিম্নলিখিত পরিস্থিতিতে প্রিফেচিংয়ের আচরণ পরিবর্তন করে:

  • ছোট আইটেম: আইটেম ভিউপোর্টের ১০%-এর কম জায়গা নিলে, Compose আগে থেকে একাধিক আইটেম প্রিফেচ করে। এটি দ্রুত ফ্লিং করার সময় স্ক্রল জ্যাঙ্ক কমায়।
  • বড় আইটেম: কোনও আইটেম ভিউপোর্টের ৫০%-এর বেশি জায়গা নিলে, ক্ল্যাম্প করা উইন্ডো সম্পূর্ণ আসন্ন আইটেম কভার করতে পারে না। আপনার কাছে মিডিয়া ফিড বা মেসেজিং থ্রেডের মতো লম্বা আইটেম থাকলে, আপনি দেরিতে প্রিফেচ ট্রিগার লক্ষ্য করতে পারেন এবং আপনার উচিত আগে থেকে উইন্ডো টিউন করা।
  • আপনার কাস্টম স্ট্র্যাটেজি যদি আইটেম-বাই-আইটেম শিডিউলিংয়ের উপর নির্ভর করে, তাহলে লজিকটি LazyLayoutCacheWindow.calculateAheadWindow-এ পোর্ট করুন। স্ক্রল করার দিকে একটি আইটেম আগে কম্পোজ ও পরিমাপ করার মতো একই ধরনের প্রিফেচ আচরণ রেপ্লিকেট করতে, দৃশ্যমান আইটেম মেট্রিকের উপর ভিত্তি করে একটি কাস্টম উইন্ডো প্রয়োগ করুন। মনে রাখবেন যে, এটি ঠিক একই আচরণ না হলেও, উইন্ডো-ভিত্তিক প্রিফেচিং ব্যবহার করার সময় আপনি এর সবচেয়ে কাছাকাছি পেতে পারেন:

val state = rememberLazyListState()
val legacyCacheWindow = remember(state) {
    object : LazyLayoutCacheWindow {
        override fun Density.calculateAheadWindow(viewport: Int): Int {
            val visibleItems = state.layoutInfo.visibleItemsInfo
            if (visibleItems.isEmpty()) return 0
            val averageItemHeight = visibleItems.sumOf { it.size } / visibleItems.size
            return averageItemHeight
        }
    }
}
LazyColumn(
    state = state,
    cacheWindow = legacyCacheWindow
) {
    items(itemsList) { item -> Text("Item $item") }
}

কন্টেন্ট প্যাডিং

কখনও কখনও আপনাকে কন্টেন্টের কিনারার চারপাশে প্যাডিং যোগ করতে হবে। লেজি কম্পোনেন্ট আপনাকে contentPadding প্যারামিটারে কিছু PaddingValues পাস করার অনুমতি দেয় যাতে এটি কাজ করে:

LazyColumn(
    contentPadding = PaddingValues(horizontal = 16.dp, vertical = 8.dp),
) {
    // ...
}

এই উদাহরণে, আমরা অনুভূমিক প্রান্তে (বাঁদিকে ও ডানদিকে) 16.dp প্যাডিং যোগ করি এবং তারপরে কন্টেন্টের উপরে ও নিচে 8.dp প্যাডিং যোগ করি।

মনে রাখবেন যে এই প্যাডিং কন্টেন্টে প্রয়োগ করা হয়, LazyColumn-এ নয়। উপরের উদাহরণে, প্রথম আইটেমটি তার উপরে 8.dp প্যাডিং যোগ করবে, শেষ আইটেমটি তার নিচে 8.dp যোগ করবে এবং সব আইটেমের বাঁদিকে ও ডানদিকে 16.dp প্যাডিং থাকবে।

অন্য একটি উদাহরণ হিসেবে, আপনি Scaffold-এর PaddingValues, LazyColumn-এর contentPadding-এ পাস করতে পারেন। এজ-টু-এজ গাইড দেখুন।

কন্টেন্ট স্পেসিং

আইটেমের মধ্যে স্পেসিং যোগ করতে, আপনি Arrangement.spacedBy() ব্যবহার করতে পারবেন। নিচের উদাহরণে প্রতিটি আইটেমের মধ্যে 4.dp স্পেস যোগ করা হয়েছে:

LazyColumn(
    verticalArrangement = Arrangement.spacedBy(4.dp),
) {
    // ...
}

একইভাবে LazyRow-এর জন্য:

LazyRow(
    horizontalArrangement = Arrangement.spacedBy(4.dp),
) {
    // ...
}

তবে, গ্রিড উল্লম্ব এবং অনুভূমিক উভয় বিন্যাস গ্রহণ করে:

LazyVerticalGrid(
    columns = GridCells.Fixed(2),
    verticalArrangement = Arrangement.spacedBy(16.dp),
    horizontalArrangement = Arrangement.spacedBy(16.dp)
) {
    items(photos) { item ->
        PhotoItem(item)
    }
}

আইটেম 'কী'

ডিফল্ট হিসেবে, প্রতিটি আইটেমের অবস্থা তালিকা বা গ্রিডে আইটেমের অবস্থানের বিপরীতে কী করা হয়। তবে, ডেটাসেট পরিবর্তন হলে এটি সমস্যা সৃষ্টি করতে পারে, কারণ যেসব আইটেম পজিশন পরিবর্তন করে সেগুলি কার্যকরভাবে যেকোনও মনে রাখা স্ট্যাটাস হারিয়ে ফেলে। আপনি যদি LazyColumn-এর মধ্যে LazyRow-এর দৃশ্য কল্পনা করেন, তাহলে সারি যদি আইটেমের পজিশন পরিবর্তন করে, তাহলে ব্যবহারকারী সারির মধ্যে তার স্ক্রল পজিশন হারাবেন।

এটি এড়াতে, আপনি প্রতিটি আইটেমের জন্য একটি স্থিতিশীল এবং অনন্য কী প্রদান করতে পারেন, যা key প্যারামিটারে একটি ব্লক প্রদান করে। একটি স্থিতিশীল কী প্রদান করলে আইটেমের অবস্থা ডেটাসেট পরিবর্তন জুড়ে সামঞ্জস্যপূর্ণ হতে পারে:

LazyColumn {
    items(
        items = messages,
        key = { message ->
            // Return a stable + unique key for the item
            message.id
        }
    ) { message ->
        MessageRow(message)
    }
}

কী প্রদান করার মাধ্যমে, আপনি Compose-কে সঠিকভাবে রিঅর্ডার ম্যানেজ করতে সাহায্য করেন। যেমন, আপনার আইটেমে যদি মনে রাখা স্টেট থাকে, তাহলে কী সেট করলে কম্পোজকে আইটেমের সাথে এই স্টেটটি সরানোর অনুমতি দেবে, যখন এর পজিশন পরিবর্তন হবে।

LazyColumn {
    items(books, key = { it.id }) {
        val rememberedValue = remember {
            Random.nextInt()
        }
    }
}

তবে, আইটেম কী হিসেবে আপনি কোন ধরনের ডেটা ব্যবহার করতে পারবেন সেই ব্যাপারে একটি সীমাবদ্ধতা আছে। 'কী'-এর ধরন অবশ্যই Bundle-এর সাথে কাজ করতে হবে, অ্যাক্টিভিটি আবার তৈরি করার সময় স্টেট রাখার জন্য Android-এর মেকানিজম। Bundle প্রিমিটিভ, enum বা Parcelable-এর মতো টাইপ সাপোর্ট করে।

LazyColumn {
    items(books, key = {
        // primitives, enums, Parcelable, etc.
    }) {
        // ...
    }
}

Bundle-এর সাথে কীটি কাজ করতে হবে যাতে অ্যাক্টিভিটি আবার তৈরি করার সময় বা আপনি এই আইটেম থেকে দূরে স্ক্রল করে আবার ফিরে আসার সময়ও আইটেম কম্পোজেবলের মধ্যে rememberSaveable রিস্টোর করা যায়।

LazyColumn {
    items(books, key = { it.id }) {
        val rememberedValue = rememberSaveable {
            Random.nextInt()
        }
    }
}

আইটেম অ্যানিমেশন

আপনি RecyclerView উইজেট ব্যবহার করে থাকলে, আপনি জানবেন যে এটি অটোমেটিক আইটেম পরিবর্তন অ্যানিমেট করে। আইটেম রিঅর্ডার করার জন্য লেজি লেআউট একই কার্যকারিতা প্রদান করে। API-টি সহজ - আপনাকে শুধু আইটেম কন্টেন্টে animateItem মডিফায়ার সেট করতে হবে:

LazyColumn {
    // It is important to provide a key to each item to ensure animateItem() works as expected.
    items(books, key = { it.id }) {
        Row(Modifier.animateItem()) {
            // ...
        }
    }
}

এমনকি, প্রয়োজন হলে আপনি কাস্টম অ্যানিমেশন স্পেসিফিকেশনও দিতে পারেন:

LazyColumn {
    items(books, key = { it.id }) {
        Row(
            Modifier.animateItem(
                fadeInSpec = tween(durationMillis = 250),
                fadeOutSpec = tween(durationMillis = 100),
                placementSpec = spring(stiffness = Spring.StiffnessLow, dampingRatio = Spring.DampingRatioMediumBouncy)
            )
        ) {
            // ...
        }
    }
}

আপনার আইটেমের জন্য 'কী' প্রদান করেছেন কিনা তা ভাল করে দেখে নিন, যাতে সরানো এলিমেন্টের নতুন অবস্থান খুঁজে পাওয়া সম্ভব হয়।

উদাহরণ: লেজি লিস্টে আইটেম অ্যানিমেট করা

Compose-এর মাধ্যমে, আপনি লেজি লিস্টে আইটেমে পরিবর্তন অ্যানিমেট করতে পারবেন। একসাথে ব্যবহার করা হলে, নিম্নলিখিত স্নিপেটগুলি লেজি লিস্ট আইটেম যোগ, সরানো এবং পুনরায় সাজানোর সময় অ্যানিমেশন প্রয়োগ করে।

এই স্নিপেট অ্যানিমেটেড ট্রানজিশন সহ স্ট্রিংয়ের তালিকা দেখায় যখন আইটেম যোগ করা, সরানো বা আবার সাজানো হয়:

@Composable
fun ListAnimatedItems(
    items: List<String>,
    modifier: Modifier = Modifier
) {
    LazyColumn(modifier) {
        // Use a unique key per item, so that animations work as expected.
        items(items, key = { it }) {
            ListItem(
                headlineContent = { Text(it) },
                modifier = Modifier
                    .animateItem(
                        // Optionally add custom animation specs
                    )
                    .fillParentMaxWidth()
                    .padding(horizontal = 8.dp, vertical = 0.dp),
            )
        }
    }
}

কোড সম্পর্কে গুরুত্বপূর্ণ পয়েন্ট

  • আইটেম পরিবর্তন করা হলে, ListAnimatedItems, অ্যানিমেটেড ট্রানজিশন সহ LazyColumn-এ স্ট্রিংয়ের তালিকা দেখায়।
  • items ফাংশন তালিকার প্রতিটি আইটেমে একটি অনন্য কী অ্যাসাইন করে। Compose আইটেম ট্র্যাক করতে এবং তাদের পজিশনে পরিবর্তন শনাক্ত করতে 'কী' ব্যবহার করে।
  • ListItem প্রতিটি তালিকা আইটেমের লেআউট নির্ধারণ করে। এতে headlineContent প্যারামিটার থাকে, যা আইটেমের মূল কন্টেন্টকে সংজ্ঞায়িত করে।
  • animateItem মডিফায়ার আইটেম যোগ করা, সরানো ও স্থানান্তরের ক্ষেত্রে ডিফল্ট অ্যানিমেশন প্রয়োগ করে।

নিচে দেওয়া স্নিপেটে এমন একটি স্ক্রিন দেখানো হয়েছে যেখানে আইটেম যোগ করা ও সরানোর কন্ট্রোল রয়েছে এবং আগে থেকে নির্ধারিত তালিকা সাজানোর সুবিধাও রয়েছে:

@Composable
private fun ListAnimatedItemsExample(
    data: List<String>,
    modifier: Modifier = Modifier,
    onAddItem: () -> Unit = {},
    onRemoveItem: () -> Unit = {},
    resetOrder: () -> Unit = {},
    onSortAlphabetically: () -> Unit = {},
    onSortByLength: () -> Unit = {},
) {
    val canAddItem = data.size < 10
    val canRemoveItem = data.isNotEmpty()

    Scaffold(modifier) { paddingValues ->
        Column(
            modifier = Modifier
                .padding(paddingValues)
                .fillMaxSize()
        ) {
            // Buttons that change the value of displayedItems.
            AddRemoveButtons(canAddItem, canRemoveItem, onAddItem, onRemoveItem)
            OrderButtons(resetOrder, onSortAlphabetically, onSortByLength)

            // List that displays the values of displayedItems.
            ListAnimatedItems(data)
        }
    }
}

কোড সম্পর্কে গুরুত্বপূর্ণ পয়েন্ট

  • ListAnimatedItemsExample এমন একটি স্ক্রিন দেখায় যেখানে আইটেম যোগ করা, সরানো ও সাজানোর জন্য কন্ট্রোল থাকে।
    • onAddItem এবং onRemoveItem হল ল্যাম্বডা এক্সপ্রেশন যা তালিকা থেকে আইটেম যোগ করতে এবং সরাতে AddRemoveButtons-এ পাস করা হয়।
    • resetOrder, onSortAlphabetically এবং onSortByLength হল ল্যাম্বডা এক্সপ্রেশন যা তালিকায় আইটেমের ক্রম পরিবর্তন করার জন্য OrderButtons-এ পাস করা হয়।
  • AddRemoveButtons-এ "যোগ করুন" ও "সরান" বোতাম দেখা যায়। এটি বোতাম চালু/বন্ধ করে এবং বোতামে ক্লিক ম্যানেজ করে।
  • OrderButtons তালিকা আবার সাজানোর বোতাম দেখায়। এটি ক্রম রিসেট করা এবং দৈর্ঘ্য বা বর্ণানুক্রমিকভাবে তালিকা সাজানোর জন্য ল্যাম্বডা ফাংশন গ্রহণ করে।
  • ListAnimatedItems, ListAnimatedItems কম্পোজ করার উপযুক্ত আইটেমকে কল করে, data তালিকা পাস করে যাতে স্ট্রিংয়ের অ্যানিমেটেড তালিকা দেখানো যায়। data অন্য কোথাও নির্দিষ্ট করা হয়েছে।

এই স্নিপেট আইটেম যোগ করুন এবং আইটেম মুছুন বোতাম সহ একটি UI তৈরি করে:

@Composable
private fun AddRemoveButtons(
    canAddItem: Boolean,
    canRemoveItem: Boolean,
    onAddItem: () -> Unit,
    onRemoveItem: () -> Unit
) {
    Row(
        modifier = Modifier.fillMaxWidth(),
        horizontalArrangement = Arrangement.Center
    ) {
        Button(enabled = canAddItem, onClick = onAddItem) {
            Text("Add Item")
        }
        Spacer(modifier = Modifier.padding(25.dp))
        Button(enabled = canRemoveItem, onClick = onRemoveItem) {
            Text("Delete Item")
        }
    }
}

কোড সম্পর্কে গুরুত্বপূর্ণ পয়েন্ট

  • AddRemoveButtons তালিকায় যোগ করা ও সরিয়ে দেওয়ার অপারেশন পারফর্ম করার জন্য বোতামের একটি সারি ডিসপ্লে করে।
  • canAddItem এবং canRemoveItem প্যারামিটার বোতামের চালু থাকা স্ট্যাটাস নিয়ন্ত্রণ করে। canAddItem বা canRemoveItem ভুল হলে, সংশ্লিষ্ট বোতাম বন্ধ করা থাকে।
  • onAddItem এবং onRemoveItem প্যারামিটার হল ল্যাম্বডা যা ব্যবহারকারী সংশ্লিষ্ট বোতামে ক্লিক করলে রান করে।

সবশেষে, এই স্নিপেট তালিকা সাজানোর জন্য তিনটি বোতাম দেখায় (রিসেট, বর্ণানুক্রমিক এবং দৈর্ঘ্য):

@Composable
private fun OrderButtons(
    resetOrder: () -> Unit,
    orderAlphabetically: () -> Unit,
    orderByLength: () -> Unit
) {
    Row(
        modifier = Modifier.fillMaxWidth(),
        horizontalArrangement = Arrangement.Center
    ) {
        var selectedIndex by remember { mutableIntStateOf(0) }
        val options = listOf("Reset", "Alphabetical", "Length")

        SingleChoiceSegmentedButtonRow {
            options.forEachIndexed { index, label ->
                SegmentedButton(
                    shape = SegmentedButtonDefaults.itemShape(
                        index = index,
                        count = options.size
                    ),
                    onClick = {
                        Log.d("AnimatedOrderedList", "selectedIndex: $selectedIndex")
                        selectedIndex = index
                        when (options[selectedIndex]) {
                            "Reset" -> resetOrder()
                            "Alphabetical" -> orderAlphabetically()
                            "Length" -> orderByLength()
                        }
                    },
                    selected = index == selectedIndex
                ) {
                    Text(label)
                }
            }
        }
    }
}

কোড সম্পর্কে গুরুত্বপূর্ণ পয়েন্ট

  • OrderButtons-এ SingleChoiceSegmentedButtonRow দেখানো হয় যাতে ব্যবহারকারীরা তালিকার জন্য বাছাই করার পদ্ধতি বেছে নিতে বা তালিকার ক্রম রিসেট করতে পারেন। SegmentedButton কম্পোনেন্ট আপনাকে বিকল্পের তালিকা থেকে একটি বিকল্প বেছে নিতে দেয়।
  • resetOrder, orderAlphabetically ও orderByLength হল ল্যাম্বডা ফাংশন যা সংশ্লিষ্ট বোতাম বেছে নেওয়া হলে এক্সিকিউট করা হয়।
  • selectedIndex স্টেট ভেরিয়েবেল বেছে নেওয়া বিকল্প ট্র্যাক করে।

ফলাফল

আইটেমগুলি পুনরায় সাজানো হলে এই ভিডিওটি পূর্ববর্তী স্নিপেটের ফলাফল দেখায়:

ছবি ১. একটি তালিকা যা আইটেম যোগ, সরানো বা সাজানো হলে আইটেম ট্রানজিশন অ্যানিমেট করে।

স্টিকি হেডার

গ্রুপ করা ডেটার তালিকা দেখানোর সময় ‘স্টিকি হেডার’ প্যাটার্ন সহায়ক হয়। নিচে আপনি 'পরিচিতি তালিকা'-র একটি উদাহরণ দেখতে পাবেন, যা প্রতিটি পরিচিতির নামের আদ্যক্ষর অনুযায়ী গ্রুপ করা হয়েছে:

ফোনের ভিডিও, যাতে পরিচিতি তালিকা উপর ও নিচে স্ক্রল করা হচ্ছে

LazyColumn-এর সাথে স্টিকি হেডার পেতে, আপনি stickyHeader() ব্যবহার করতে পারেন

ফাংশন, হেডার কন্টেন্ট প্রদান করছে:

@Composable
fun ListWithHeader(items: List<Item>) {
    LazyColumn {
        stickyHeader {
            Header()
        }

        items(items) { item ->
            ItemRow(item)
        }
    }
}

উপরে দেওয়া ‘পরিচিতি তালিকা’ উদাহরণের মতো একাধিক হেডার সহ তালিকা তৈরি করতে, আপনি এটি করতে পারেন:

// This ideally would be done in the ViewModel
val grouped = contacts.groupBy { it.firstName[0] }

@Composable
fun ContactsList(grouped: Map<Char, List<Contact>>) {
    LazyColumn {
        grouped.forEach { (initial, contactsForInitial) ->
            stickyHeader {
                CharacterHeader(initial)
            }

            items(contactsForInitial) { contact ->
                ContactListItem(contact)
            }
        }
    }
}

স্ক্রল পজিশনে প্রতিক্রিয়া জানানো হচ্ছে

অনেক অ্যাপকে স্ক্রল পজিশন ও আইটেম লেআউট পরিবর্তনের সাথে মানিয়ে নিতে হয়। লেজি কম্পোনেন্ট এই ব্যবহারের ক্ষেত্রে LazyListState হোস্টিং করে সাহায্য করে:

@Composable
fun MessageList(messages: List<Message>) {
    // Remember our own LazyListState
    val listState = rememberLazyListState()

    // Provide it to LazyColumn
    LazyColumn(state = listState) {
        // ...
    }
}

সহজ ব্যবহারের ক্ষেত্রে, অ্যাপকে সাধারণত শুধু প্রথম দৃশ্যমান আইটেম সম্পর্কে তথ্য জানতে হয়। এর জন্য LazyListState firstVisibleItemIndex এবং firstVisibleItemScrollOffset প্রপার্টি প্রদান করে।

ব্যবহারকারী প্রথম আইটেম স্ক্রল করে পেরিয়ে গেছেন কিনা তার উপর ভিত্তি করে বোতাম দেখানো এবং লুকানোর উদাহরণ ব্যবহার করলে:

@Composable
fun MessageList(messages: List<Message>) {
    Box {
        val listState = rememberLazyListState()

        LazyColumn(state = listState) {
            // ...
        }

        // Show the button if the first visible item is past
        // the first item. We use a remembered derived state to
        // minimize unnecessary compositions
        val showButton by remember {
            derivedStateOf {
                listState.firstVisibleItemIndex > 0
            }
        }

        AnimatedVisibility(visible = showButton) {
            ScrollToTopButton()
        }
    }
}

অন্য UI কম্পোজেবল আপডেট করার প্রয়োজন হলে, কম্পোজিশনে সরাসরি স্টেট রিড করা উপযোগী হয়, তবে এমন পরিস্থিতিও থাকে যেখানে একই কম্পোজিশনে ইভেন্ট ম্যানেজ করার প্রয়োজন হয় না। এর একটি সাধারণ উদাহরণ হল, ব্যবহারকারী কোনও নির্দিষ্ট পয়েন্টের পরে স্ক্রল করলে অ্যানালিটিক্স ইভেন্ট পাঠানো। এটি দক্ষতার সাথে ম্যানেজ করতে, আমরা snapshotFlow() ব্যবহার করতে পারি:

val listState = rememberLazyListState()

LazyColumn(state = listState) {
    // ...
}

LaunchedEffect(listState) {
    snapshotFlow { listState.firstVisibleItemIndex }
        .map { index -> index > 0 }
        .distinctUntilChanged()
        .filter { it }
        .collect {
            MyAnalyticsService.sendScrolledPastFirstItemEvent()
        }
}

LazyListState বর্তমানে দেখানো হচ্ছে এমন সব আইটেম এবং স্ক্রিনে সেগুলির বাউন্ড সম্পর্কেও তথ্য প্রদান করে, layoutInfo প্রপার্টির মাধ্যমে। আরও তথ্যের জন্য LazyListLayoutInfo ক্লাস দেখুন।

স্ক্রল পজিশন কন্ট্রোল করা

স্ক্রল পজিশনে প্রতিক্রিয়া জানানোর পাশাপাশি, অ্যাপের জন্য স্ক্রল পজিশন নিয়ন্ত্রণ করতে পারাটাও উপযোগী। LazyListState scrollToItem() ফাংশনের মাধ্যমে এটি সাপোর্ট করে, যা স্ক্রল পজিশন ‘অবিলম্বে’ স্ন্যাপ করে এবং animateScrollToItem() যা অ্যানিমেশন ব্যবহার করে স্ক্রল করে (স্মুথ স্ক্রল নামেও পরিচিত):

@Composable
fun MessageList(messages: List<Message>) {
    val listState = rememberLazyListState()
    // Remember a CoroutineScope to be able to launch
    val coroutineScope = rememberCoroutineScope()

    LazyColumn(state = listState) {
        // ...
    }

    ScrollToTopButton(
        onClick = {
            coroutineScope.launch {
                // Animate scroll to the first item
                listState.animateScrollToItem(index = 0)
            }
        }
    )
}

বড় ডেটা-সেট (পেজিং)

পেজিং লাইব্রেরি অ্যাপকে আইটেমের বড় তালিকা সাপোর্ট করতে সাহায্য করে, প্রয়োজন অনুযায়ী তালিকার ছোট ছোট অংশ লোড করে ও দেখায়। Paging 3.0 এবং পরবর্তী ভার্সন androidx.paging:paging-compose লাইব্রেরির মাধ্যমে Compose-এর জন্য সহায়তা প্রদান করে।

পৃষ্ঠাভিত্তিক কন্টেন্টের তালিকা দেখাতে, আমরা collectAsLazyPagingItems() এক্সটেনশন ফাংশন ব্যবহার করতে পারি এবং তারপর আমাদের LazyColumn-এ items()-এ ফেরত আসা LazyPagingItems পাস করতে পারি। ভিউতে পেজিং সাপোর্টের মতো, item-এর মান null কিনা তা চেক করে ডেটা লোড হওয়ার সময় আপনি প্লেসহোল্ডার দেখাতে পারবেন:

@Composable
fun MessageList(pager: Pager<Int, Message>) {
    val lazyPagingItems = pager.flow.collectAsLazyPagingItems()

    LazyColumn {
        items(
            lazyPagingItems.itemCount,
            key = lazyPagingItems.itemKey { it.id }
        ) { index ->
            val message = lazyPagingItems[index]
            if (message != null) {
                MessageRow(message)
            } else {
                MessagePlaceholder()
            }
        }
    }
}

লেজি লেআউট ব্যবহার করার ব্যাপারে পরামর্শ

আপনার লেজি লেআউট যাতে প্রত্যাশা অনুযায়ী কাজ করে তা নিশ্চিত করতে আপনি কিছু পরামর্শ বিবেচনা করতে পারেন।

০-পিক্সেল সাইজের আইটেম ব্যবহার করা এড়িয়ে চলুন

এটি এমন পরিস্থিতিতে ঘটতে পারে যেখানে, উদাহরণস্বরূপ, আপনি পরে আপনার তালিকার আইটেমগুলি পূরণ করার জন্য অ্যাসিঙ্ক্রোনাসভাবে কিছু ডেটা যেমন ছবি, আশা করেন। এর ফলে Lazy লেআউট প্রথম পরিমাপে তার সব আইটেম কম্পোজ করবে, কারণ সেগুলির উচ্চতা ০ পিক্সেল এবং এটি ভিউপোর্টে সব আইটেম ফিট করতে পারবে। আইটেমগুলি লোড হয়ে গেলে এবং তাদের উচ্চতা প্রসারিত হলে, Lazy লেআউট তখন অন্য সমস্ত আইটেম বাতিল করে দেবে যা প্রথমবার অপ্রয়োজনীয়ভাবে কম্পোজ করা হয়েছে কারণ সেগুলি আসলে ভিউপোর্টে ফিট করতে পারে না। এটি এড়াতে, আপনার আইটেমের ডিফল্ট সাইজ সেট করা উচিত, যাতে লেজি লেআউট ভিউ পোর্টে আসলে কতগুলি আইটেম ফিট করতে পারে তার সঠিক গণনা করতে পারে:

@Composable
fun Item(imageUrl: String) {
    AsyncImage(
        model = rememberAsyncImagePainter(model = imageUrl),
        modifier = Modifier.size(30.dp),
        contentDescription = null
        // ...
    )
}

ডেটা অ্যাসিঙ্ক্রোনাসভাবে লোড হওয়ার পরে আপনার আইটেমের আনুমানিক সাইজ সম্পর্কে আপনি যখন জানতে পারবেন, তখন লোড হওয়ার আগে ও পরে আপনার আইটেমের সাইজ একই রাখার জন্য কিছু প্লেসহোল্ডার যোগ করা একটি ভালো অভ্যাস। এটি সঠিক স্ক্রল পজিশন বজায় রাখতে সাহায্য করবে।

একই দিকে স্ক্রল করা যায় এমন নেস্টিং কম্পোনেন্ট এড়িয়ে চলুন

এটি শুধুমাত্র সেইসব ক্ষেত্রে প্রযোজ্য হয় যখন আগে থেকে নির্দিষ্ট করা সাইজ ছাড়া নেস্টিং স্ক্রলযোগ্য চাইল্ড একই দিকে স্ক্রলযোগ্য অন্য পেরেন্টের মধ্যে থাকে। যেমন, উল্লম্বভাবে স্ক্রল করা যায় এমন Column পেরেন্ট এলিমেন্টের মধ্যে নির্দিষ্ট উচ্চতা ছাড়া চাইল্ড এলিমেন্ট LazyColumn নেস্ট করার চেষ্টা করা:

// throws IllegalStateException
Column(
    modifier = Modifier.verticalScroll(state)
) {
    LazyColumn {
        // ...
    }
}

পরিবর্তে, আপনার সব কম্পোজেবল একটি পেরেন্ট LazyColumn-এর মধ্যে র‍্যাপ করে এবং বিভিন্ন ধরনের কন্টেন্ট পাস করার জন্য এর DSL ব্যবহার করে একই ফলাফল অর্জন করা যেতে পারে। এটি একটি আইটেম, পাশাপাশি একাধিক তালিকা আইটেম, সব এক জায়গায় নির্গত করতে সক্ষম করে:

LazyColumn {
    item {
        Header()
    }
    items(data) { item ->
        PhotoItem(item)
    }
    item {
        Footer()
    }
}

মনে রাখবেন, আপনি বিভিন্ন ডিরেকশন লেআউট নেস্ট করলে, যেমন, স্ক্রল করা যায় এমন পেরেন্ট Row এবং চাইল্ড LazyColumn, অনুমোদিত:

Row(
    modifier = Modifier.horizontalScroll(scrollState)
) {
    LazyColumn {
        // ...
    }
}

এছাড়াও, আপনি একই ডিরেকশন লেআউট ব্যবহার করেন, কিন্তু নেস্টেড চিলড্রেনের জন্য নির্দিষ্ট সাইজ সেট করেন:

Column(
    modifier = Modifier.verticalScroll(scrollState)
) {
    LazyColumn(
        modifier = Modifier.height(200.dp)
    ) {
        // ...
    }
}

একটি আইটেমে একাধিক এলিমেন্ট যোগ করার সময় সতর্ক থাকুন

এই উদাহরণে, দ্বিতীয় আইটেম ল্যাম্বডা একটি ব্লকে ২টি আইটেম এমিট করে:

LazyVerticalGrid(
    columns = GridCells.Adaptive(100.dp)
) {
    item { Item(0) }
    item {
        Item(1)
        Item(2)
    }
    item { Item(3) }
    // ...
}

লেজি লেআউট এটি প্রত্যাশিতভাবে ম্যানেজ করবে - এটি এলিমেন্টগুলিকে একের পর এক লেআউট করবে যেন সেগুলি আলাদা আইটেম। তবে, এটি করার ক্ষেত্রে কিছু সমস্যা আছে।

একটি আইটেমের অংশ হিসেবে একাধিক এলিমেন্ট এমিট করা হলে, সেগুলিকে একটি এন্টিটি হিসেবে ম্যানেজ করা হয়, অর্থাৎ সেগুলিকে আর আলাদাভাবে কম্পোজ করা যায় না। স্ক্রিনে একটি এলিমেন্ট দৃশ্যমান হলে, আইটেমের সাথে সম্পর্কিত সব এলিমেন্ট কম্পোজ ও পরিমাপ করতে হবে। এটি অতিরিক্ত ব্যবহার করলে পারফর্ম্যান্সের উপর প্রভাব পড়তে পারে। সব এলিমেন্ট একটি আইটেমে রাখার চরম ক্ষেত্রে, এটি লেজি লেআউট ব্যবহার করার উদ্দেশ্যকে সম্পূর্ণরূপে ব্যর্থ করে। পারফর্ম্যান্স সংক্রান্ত সম্ভাব্য সমস্যা ছাড়াও, একটি আইটেমে আরও এলিমেন্ট যোগ করলে তা scrollToItem() ও animateScrollToItem()-এর সাথেও ইন্টারফেয়ার করবে।

তবে, একটি আইটেমে একাধিক এলিমেন্ট রাখার বৈধ ব্যবহারের কেস আছে, যেমন তালিকার মধ্যে ডিভাইডার থাকা। আপনি চান না যে ডিভাইডারগুলি স্ক্রোলিং ইনডেক্স পরিবর্তন করুক, কারণ সেগুলিকে স্বাধীন উপাদান হিসাবে বিবেচনা করা উচিত নয়। এছাড়াও, ডিভাইডার ছোট হওয়ার কারণে পারফর্ম্যান্স প্রভাবিত হয় না। ডিভাইডারটি সম্ভবত তার আগের আইটেমটি দৃশ্যমান হলে দৃশ্যমান হতে হবে, যাতে এটি পূর্ববর্তী আইটেমের অংশ হতে পারে:

LazyVerticalGrid(
    columns = GridCells.Adaptive(100.dp)
) {
    item { Item(0) }
    item {
        Item(1)
        Divider()
    }
    item { Item(2) }
    // ...
}

কাস্টম ব্যবস্থা ব্যবহার করার কথা বিবেচনা করুন

সাধারণত Lazy লিস্টে অনেক আইটেম থাকে এবং সেগুলি স্ক্রলিং কন্টেনারের সাইজের চেয়ে বেশি জায়গা দখল করে। তবে, আপনার তালিকায় অল্প আইটেম থাকলে, ভিউপোর্টে সেগুলি কীভাবে পজিশন করা হবে সেই ব্যাপারে আপনার ডিজাইনে আরও নির্দিষ্ট প্রয়োজনীয়তা থাকতে পারে।

এটি করতে, আপনি কাস্টম ভার্টিক্যাল Arrangement ব্যবহার করতে এবং LazyColumn-এ পাস করতে পারবেন। নিম্নলিখিত উদাহরণে, TopWithFooter অবজেক্টকে শুধুমাত্র arrange পদ্ধতি প্রয়োগ করতে হবে। প্রথমত, এটি আইটেমগুলিকে একটির পর একটি সাজাবে। দ্বিতীয়ত, মোট ব্যবহৃত উচ্চতা ভিউপোর্ট উচ্চতার চেয়ে কম হলে, এটি ফুটারকে নিচে পজিশন করবে:

object TopWithFooter : Arrangement.Vertical {
    override fun Density.arrange(
        totalSize: Int,
        sizes: IntArray,
        outPositions: IntArray
    ) {
        var y = 0
        sizes.forEachIndexed { index, size ->
            outPositions[index] = y
            y += size
        }
        if (y < totalSize) {
            val lastIndex = outPositions.lastIndex
            outPositions[lastIndex] = totalSize - sizes.last()
        }
    }
}

contentType যোগ করার কথা বিবেচনা করুন

Compose 1.2 থেকে শুরু করে, আপনার Lazy লেআউটের পারফর্ম্যান্স সর্বাধিক করতে, আপনার তালিকা বা গ্রিডে contentType যোগ করার কথা বিবেচনা করুন। এর ফলে আপনি লেআউটের প্রতিটি আইটেমের জন্য কন্টেন্টের ধরন নির্দিষ্ট করতে পারবেন, যেসব ক্ষেত্রে আপনি একাধিক বিভিন্ন ধরনের আইটেম নিয়ে গঠিত কোনও তালিকা বা গ্রিড কম্পোজ করছেন:

LazyColumn {
    items(elements, contentType = { it.type }) {
        // ...
    }
}

আপনি contentType প্রদান করলে, Compose শুধুমাত্র একই ধরনের আইটেমের মধ্যে কম্পোজিশন আবার ব্যবহার করতে পারে। একই ধরনের স্ট্রাকচারের আইটেম কম্পোজ করার সময় পুনর্ব্যবহার করা আরও বেশি কার্যকর হয়, কন্টেন্টের ধরন প্রদান করলে তা নিশ্চিত করে যে Compose, B ধরনের সম্পূর্ণ আলাদা আইটেমের উপরে A ধরনের আইটেম কম্পোজ করার চেষ্টা করে না। এটি কম্পোজিশন আবার ব্যবহার করার সুবিধা এবং আপনার লেজি লেআউট পারফর্ম্যান্স সর্বাধিক করতে সাহায্য করে।

পারফর্ম্যান্স পরিমাপ করা

আপনি শুধুমাত্র রিলিজ মোডে এবং R8 অপ্টিমাইজেশন চালু থাকা অবস্থায় চালানোর সময় Lazy লেআউটের পারফর্ম্যান্স নির্ভরযোগ্যভাবে পরিমাপ করতে পারেন। ডিবাগ বিল্ডে, লেজি লেআউট স্ক্রলিং ধীরগতির মনে হতে পারে। এই বিষয়ে আরও জানতে, Compose পারফর্ম্যান্স পড়ুন।

অতিরিক্ত রিসোর্স