Jetpack Compose ফেজ

অন্যান্য বেশিরভাগ UI টুলকিটের মতো, Compose বেশ কয়েকটি আলাদা ফেজের মাধ্যমে ফ্রেম রেন্ডার করে। যেমন, Android ভিউ সিস্টেমে তিনটি প্রধান পর্যায় আছে: পরিমাপ, লে-আউট ও ড্রয়িং। Compose-এর ক্ষেত্রেও একই পদ্ধতি অনুসরণ করা হয়, তবে শুরুতে কম্পোজিশন নামে একটি গুরুত্বপূর্ণ অতিরিক্ত ধাপ থাকে।

Compose ডকুমেন্টেশনে Thinking in Compose এবং State and Jetpack Compose-এ কম্পোজিশন সম্পর্কে বর্ণনা করা হয়েছে।

ফ্রেমের তিনটি পর্যায়

Compose-এর তিনটি প্রধান ফেজ আছে:

  1. কম্পোজিশন: কোন UI দেখাতে হবে। Compose কম্পোজেবল ফাংশন রান করে এবং আপনার UI-এর বিবরণ তৈরি করে।
  2. লেআউট: UI কোথায় প্লেস করতে হবে। এই পর্যায়ে দুটি ধাপ আছে: পরিমাপ ও প্লেসমেন্ট। লেআউট এলিমেন্ট, লেআউট ট্রির প্রতিটি নোডের জন্য, 2D কোঅর্ডিনেটে নিজেদের এবং যেকোনও চাইল্ড এলিমেন্টকে পরিমাপ করে এবং প্লেস করে।
  3. ড্রয়িং: এটি কীভাবে রেন্ডার করে। UI এলিমেন্ট ক্যানভাসে আঁকা হয়, সাধারণত এটি ডিভাইসের স্ক্রিন।
Compose যে তিনটি ফেজে ডেটাকে UI-তে রূপান্তরিত করে (ক্রম অনুসারে, ডেটা, কম্পোজিশন, লেআউট, ড্রয়িং, UI)।
ছবি ১. Compose তিনটি ধাপে ডেটাকে UI-তে রূপান্তরিত করে।

এইসব ফেজের ক্রম সাধারণত একই থাকে, যার ফলে ডেটা কম্পোজিশন থেকে লেআউট হয়ে ড্রয়িং পর্যন্ত একটিই দিকে প্রবাহিত হয় এবং ফ্রেম তৈরি করে (এটি একমুখী ডেটা ফ্লো নামেও পরিচিত)। BoxWithConstraints, LazyColumn, এবং LazyRow হল উল্লেখযোগ্য ব্যতিক্রম, যেখানে এর চাইল্ডের কম্পোজিশন পেরেন্টের লেআউট ফেজের উপর নির্ভর করে।

ধারণাগতভাবে, এই প্রতিটি ফেজ প্রতিটি ফ্রেমের জন্য ঘটে; তবে পারফর্ম্যান্স অপ্টিমাইজ করতে, Compose এমন কাজ পুনরাবৃত্তি করা এড়িয়ে যায় যা এই সমস্ত ফেজে একই ইনপুট থেকে একই ফলাফল গণনা করবে। Compose কোনও কম্পোজেবল ফাংশন রান করা এড়িয়ে যায় যদি এটি আগের ফলাফল আবার ব্যবহার করতে পারে এবং Compose UI পুরো ট্রিকে আবার লে-আউট বা ড্র করে না যদি না এটি করতে হয়। UI আপডেট করার জন্য প্রয়োজনীয় ন্যূনতম কাজই Compose করে। এই অপ্টিমাইজেশন সম্ভব কারণ Compose বিভিন্ন ফেজের মধ্যে স্টেট রিড ট্র্যাক করে।

পর্যায়গুলি সম্পর্কে জানুন

এই বিভাগে কম্পোজেবলের জন্য তিনটি Compose ফেজ কীভাবে আরও বিস্তারিতভাবে সম্পন্ন করা হয় তা বর্ণনা করা হয়েছে।

রচনা

কম্পোজিশন ফেজে, Compose রানটাইম কম্পোজেবল ফাংশন এক্সিকিউট করে এবং একটি ট্রি স্ট্রাকচার আউটপুট করে যা আপনার UI-কে দেখায়। এই UI ট্রি-তে লেআউট নোড থাকে, যাতে পরবর্তী পর্যায়ের জন্য প্রয়োজনীয় সব তথ্য থাকে, যেমনটি নিম্নলিখিত ভিডিওতে দেখানো হয়েছে:

ছবি ২. কম্পোজিশন ফেজে তৈরি করা ট্রি যা আপনার UI-কে প্রতিনিধিত্ব করে।

কোড ও UI ট্রির সাবসেকশন নিচে দেখানো উদাহরণের মতো দেখতে হয়:

পাঁচটি কম্পোজেবল সহ একটি কোড স্নিপেট এবং এর ফলে তৈরি হওয়া UI ট্রি, যেখানে চাইল্ড নোডগুলি তাদের পেরেন্ট নোড থেকে ব্রাঞ্চ হিসেবে বের হচ্ছে।
ছবি ৩. সংশ্লিষ্ট কোড সহ UI ট্রির একটি সাবসেকশন।

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

লেআউট

লেআউট ফেজে, কম্পোজিশন ফেজে তৈরি হওয়া UI ট্রিকে কম্পোজ ইনপুট হিসেবে ব্যবহার করে। লেআউট নোডের সংগ্রহে 2D স্পেসে প্রতিটি নোডের আকার এবং অবস্থান নির্ধারণ করার জন্য প্রয়োজনীয় সমস্ত তথ্য থাকে।

ছবি ৪. লেআউট ফেজ চলাকালীন UI ট্রিতে প্রতিটি লেআউট নোডের পরিমাপ ও প্লেসমেন্ট।

লেআউট ফেজে, নিম্নলিখিত তিন-ধাপের অ্যালগরিদম ব্যবহার করে ট্রি ট্রাভার্স করা হয়:

  1. চিলড্রেন পরিমাপ করা: কোনও নোড তার চিলড্রেন থাকলে তা পরিমাপ করে।
  2. নিজস্ব সাইজ নির্ধারণ করা: এই পরিমাপের উপর ভিত্তি করে, একটি নোড তার নিজস্ব সাইজ নির্ধারণ করে।
  3. চাইল্ড নোড প্লেস করা: প্রতিটি চাইল্ড নোডকে নোডের নিজস্ব অবস্থানের সাপেক্ষে প্লেস করা হয়।

এই ফেজের শেষে, প্রতিটি লেআউট নোডে এগুলি থাকে:

  • অ্যাসাইন করা প্রস্থ ও উচ্চতা
  • একটি x, y কোঅর্ডিনেট যেখানে এটি আঁকা উচিত

আগের বিভাগ থেকে UI ট্রি রিকল করুন:

পাঁচটি কম্পোজেবল সহ একটি কোড স্নিপেট এবং এর ফলে তৈরি হওয়া UI ট্রি, যেখানে চাইল্ড নোডগুলি তাদের পেরেন্ট নোড থেকে ব্রাঞ্চ হিসেবে বের হচ্ছে

এই ট্রির জন্য, অ্যালগরিদম এইভাবে কাজ করে:

  1. Row তার চাইল্ড, Image ও Column পরিমাপ করে।
  2. Image পরিমাপ করা হয়। এটির কোনও চাইল্ড নেই, তাই এটি নিজেই নিজের সাইজ নির্ধারণ করে এবং Row-কে সাইজ সম্পর্কে জানায়।
  3. এরপর Column পরিমাপ করা হয়। এটি প্রথমে নিজের চিলড্রেন (দুটি Text কম্পোজেবল) পরিমাপ করে।
  4. প্রথম Text পরিমাপ করা হয়েছে। এটির কোনও চাইল্ড নেই, তাই এটি নিজের সাইজ নিজেই নির্ধারণ করে এবং Column-কে নিজের সাইজ সম্পর্কে জানায়।
    1. দ্বিতীয় Text পরিমাপ করা হয়। এটির কোনও চাইল্ড নেই, তাই এটি নিজের সাইজ নির্ধারণ করে এবং Column-কে রিপোর্ট করে।
  5. Column নিজের সাইজ নির্ধারণ করতে চাইল্ডের পরিমাপ ব্যবহার করে। এটি চাইল্ডের সর্বাধিক প্রস্থ এবং এর চাইল্ডের উচ্চতার যোগফল ব্যবহার করে।
  6. Column তার চাইল্ড এলিমেন্টকে নিজের সাপেক্ষে প্লেস করে, একটির নিচে আরেকটি উল্লম্বভাবে রাখে।
  7. Row নিজের সাইজ নির্ধারণ করতে চাইল্ডের পরিমাপ ব্যবহার করে। এটি চাইল্ডের সর্বাধিক উচ্চতা এবং এর চাইল্ডের প্রস্থের যোগফল ব্যবহার করে। তারপর এটি তার চাইল্ড এলিমেন্টকে প্লেস করে।

মনে রাখবেন যে প্রতিটি নোড শুধুমাত্র একবারই ভিজিট করা হয়েছে। Compose রানটাইমের জন্য UI ট্রি-এর মাধ্যমে শুধুমাত্র একবার পাস করলেই হয়, যাতে সব নোড পরিমাপ ও প্লেস করা যায়, যা পারফর্ম্যান্স উন্নত করে। ট্রি-তে নোডের সংখ্যা বাড়লে, সেটি ট্রাভার্স করতে যে সময় লাগে তা লিনিয়ার ফ্যাশনে বাড়ে। অন্যদিকে, প্রতিটি নোড একাধিকবার ভিজিট করা হলে, ট্রাভার্সাল টাইম এক্সপোনেনশিয়ালি বৃদ্ধি পায়।

ড্রয়িং

ড্রয়িং ফেজে, ট্রি আবার উপর থেকে নিচে ট্রাভার্স করা হয় এবং প্রতিটি নোড স্ক্রিনে নিজের মতো করে ড্র করে।

ছবি ৫. ড্রয়িং ফেজ স্ক্রিনে পিক্সেল আঁকে।

আগের উদাহরণ ব্যবহার করে, ট্রি কন্টেন্ট নিম্নলিখিত উপায়ে আঁকা হয়:

  1. Row-এ ব্যাকগ্রাউন্ড কালারের মতো কোনও কন্টেন্ট থাকলে তা ড্র করে।
  2. Image নিজে থেকেই ড্র করে।
  3. Column নিজে থেকেই ড্র করে।
  4. প্রথম ও দ্বিতীয় Text যথাক্রমে নিজেদের ড্র করে।

ছবি ৬. UI ট্রি এবং তার আঁকা উপস্থাপনা।

স্টেট রিড

আগে তালিকাভুক্ত করা কোনও একটি ফেজ চলাকালীন আপনি snapshot state-এর value পড়ার সময়, value পড়ার সময় Compose অটোমেটিক ট্র্যাক করে যে এটি কী করছিল। এই ট্র্যাকিংয়ের মাধ্যমে Compose, রিডারকে আবার এক্সিকিউট করতে পারে যখন স্টেটের value পরিবর্তন হয় এবং এটি Compose-এ স্টেট অবজার্ভেবিলিটির ভিত্তি।

আপনি সাধারণত mutableStateOf() ব্যবহার করে স্টেট তৈরি করেন এবং তারপরে দুটি উপায়ের মধ্যে একটির মাধ্যমে এটি অ্যাক্সেস করেন: সরাসরি value প্রপার্টি অ্যাক্সেস করে অথবা Kotlin প্রপার্টি ডেলিগেট ব্যবহার করে। আপনি কম্পোজেবলে স্টেট থেকে এই বিষয়ে আরও জানতে পারবেন। এই গাইডের উদ্দেশ্যে, "স্টেট রিড" বলতে এই দুটি সমতুল্য অ্যাক্সেস পদ্ধতির যেকোনও একটিকে বোঝায়।

// State read without property delegate.
val paddingState: MutableState<Dp> = remember { mutableStateOf(8.dp) }
Text(
    text = "Hello",
    modifier = Modifier.padding(paddingState.value)
)

// State read with property delegate.
var padding: Dp by remember { mutableStateOf(8.dp) }
Text(
    text = "Hello",
    modifier = Modifier.padding(padding)
)

প্রপার্টি ডেলিগেট-এর আড়ালে, "getter" এবং "setter" ফাংশন ব্যবহার করে State-এর value অ্যাক্সেস ও আপডেট করা হয়। এই গেটার ও সেটার ফাংশন তখনই কল করা হয় যখন আপনি প্রপার্টিকে ভ্যালু হিসেবে রেফার করেন, এটি তৈরি করার সময় নয়, সেই কারণে আগে বর্ণিত দুটি পদ্ধতি একই রকম।

রিড স্টেট পরিবর্তন হলে কোডের প্রতিটি ব্লক যা আবার এক্সিকিউট করা যায়, তাকে রিস্টার্ট স্কোপ বলা হয়। Compose, স্টেট value-এর পরিবর্তন ট্র্যাক করে এবং বিভিন্ন ফেজে স্কোপ রিস্টার্ট করে।

ফেজড স্টেট রিড

আগে যেমন উল্লেখ করা হয়েছে, Compose-এ তিনটি প্রধান ফেজ আছে এবং Compose প্রতিটি ফেজে কোন স্টেট রিড করা হচ্ছে তা ট্র্যাক করে। এর ফলে, Compose আপনার UI-এর প্রতিটি প্রভাবিত এলিমেন্টের জন্য শুধুমাত্র সেই নির্দিষ্ট ফেজকেই বিজ্ঞপ্তি পাঠাতে পারে, যেখানে কাজ করা প্রয়োজন।

নিম্নলিখিত বিভাগগুলি প্রতিটি পর্যায় বর্ণনা করে এবং এর মধ্যে একটি স্টেট ভ্যালু রিড করা হলে কী ঘটে তা বর্ণনা করে।

ফেজ ১: কম্পোজিশন

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

কম্পোজিশনের ফলাফলের উপর নির্ভর করে, Compose UI লেআউট ও ড্রয়িং ফেজ রান করে। কন্টেন্ট একই থাকলে এবং সাইজ ও লেআউট পরিবর্তন না হলে, এটি এইসব ফেজ এড়িয়ে যেতে পারে।

var padding by remember { mutableStateOf(8.dp) }
Text(
    text = "Hello",
    // The `padding` state is read in the composition phase
    // when the modifier is constructed.
    // Changes in `padding` will invoke recomposition.
    modifier = Modifier.padding(padding)
)

পর্যায় ২: লেআউট

লেআউট ফেজে দুটি ধাপ আছে: পরিমাপ ও প্লেসমেন্ট। পরিমাপের ধাপটি Layout কম্পোজেবলে পাস করা পরিমাপ ল্যাম্বডা, LayoutModifier ইন্টারফেসের MeasureScope.measure পদ্ধতি, অন্যান্যদের মধ্যে রান করে। প্লেসমেন্ট স্টেপ layout ফাংশনের প্লেসমেন্ট ব্লক, Modifier.offset { … }-এর ল্যাম্বডা ব্লক এবং একই ধরনের ফাংশন রান করে।

এইসব ধাপের প্রতিটির সময় স্টেট রিড লেআউট এবং সম্ভাব্য ড্রয়িং ফেজকে প্রভাবিত করে। স্টেটের value পরিবর্তন হলে, Compose UI লেআউট ফেজ শিডিউল করে। সাইজ বা পজিশন পরিবর্তন হলে এটি ড্রয়িং ফেজও রান করে।

var offsetX by remember { mutableStateOf(8.dp) }
Text(
    text = "Hello",
    modifier = Modifier.offset {
        // The `offsetX` state is read in the placement step
        // of the layout phase when the offset is calculated.
        // Changes in `offsetX` restart the layout.
        IntOffset(offsetX.roundToPx(), 0)
    }
)

পর্যায় ৩: ড্রয়িং

ড্রয়িং কোড চলাকালীন স্টেট রিড ড্রয়িং ফেজকে প্রভাবিত করে। সাধারণ উদাহরণের মধ্যে Canvas(), Modifier.drawBehind এবং Modifier.drawWithContent অন্তর্ভুক্ত। যখন স্টেটের value পরিবর্তন হয়, Compose UI শুধুমাত্র ড্র ফেজ রান করে।

var color by remember { mutableStateOf(Color.Red) }
Canvas(modifier = modifier) {
    // The `color` state is read in the drawing phase
    // when the canvas is rendered.
    // Changes in `color` restart the drawing.
    drawRect(color)
}

ডায়াগ্রাম দেখাচ্ছে যে ড্র ফেজ চলাকালীন একটি স্টেট রিড শুধুমাত্র ড্র ফেজকে আবার চালানোর জন্য ট্রিগার করে।

স্টেট রিড অপ্টিমাইজ করুন

Compose যেহেতু লোকালাইজড স্টেট রিড ট্র্যাকিং পারফর্ম করে, তাই আপনি প্রতিটি স্টেট উপযুক্ত ফেজে রিড করার মাধ্যমে পারফর্ম করা কাজের পরিমাণ কমাতে পারেন।

নিচের উদাহরণটি দেখুন। এই উদাহরণে একটি Image() আছে যা অফসেট মডিফায়ার ব্যবহার করে এর ফাইনাল লেআউট পজিশন অফসেট করে, যার ফলে ব্যবহারকারী স্ক্রল করলে প্যারালাক্স এফেক্ট দেখা যায়।

Box {
    val listState = rememberLazyListState()

    Image(
        // ...
        // Non-optimal implementation!
        Modifier.offset(
            with(LocalDensity.current) {
                // State read of firstVisibleItemScrollOffset in composition
                (listState.firstVisibleItemScrollOffset / 2).toDp()
            }
        )
    )

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

এই কোড কাজ করে, তবে এর ফলে পারফর্ম্যান্স সাবঅপ্টিমাল হয়। কোডটি যেভাবে লেখা হয়েছে, সেই অনুযায়ী এটি firstVisibleItemScrollOffset স্টেট থেকে value পড়ে এবং Modifier.offset(offset: Dp) ফাংশনে পাস করে। ব্যবহারকারী স্ক্রল করলে, firstVisibleItemScrollOffset-এর value পরিবর্তিত হবে। আপনি যেমন জেনেছেন, Compose যেকোনও স্টেট রিড ট্র্যাক করে যাতে এটি রিডিং কোড রিস্টার্ট (আবার-ইনভোক) করতে পারে, যা এই উদাহরণে Box-এর কন্টেন্ট।

এটি কম্পোজিশন ফেজে স্টেট রিড করার একটি উদাহরণ। এটি খারাপ কিছু নয়, আসলে এটিই হল রিকম্পোজিশনের ভিত্তি, যার ফলে ডেটা পরিবর্তন হলে নতুন UI দেখা যায়।

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

ল্যাম্বডা সহ অফসেট

অফসেট মডিফায়ারের আরেকটি ভার্সন উপলভ্য: Modifier.offset(offset: Density.() -> IntOffset).

এই ভার্সনটি একটি ল্যাম্বডা প্যারামিটার নেয়, যেখানে ল্যাম্বডা ব্লক দ্বারা ফলাফল অফসেট ফেরত দেওয়া হয়। এটি ব্যবহার করতে কোড আপডেট করুন:

Box {
    val listState = rememberLazyListState()

    Image(
        // ...
        Modifier.offset {
            // State read of firstVisibleItemScrollOffset in Layout
            IntOffset(x = 0, y = listState.firstVisibleItemScrollOffset / 2)
        }
    )

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

তাহলে এটি কেন আরও বেশি পারফর্ম্যান্স দেয়? আপনি মডিফায়ারকে যে ল্যাম্বডা ব্লক প্রদান করেন তা লেআউট ফেজের সময় (বিশেষ করে, লেআউট ফেজের প্লেসমেন্ট স্টেপের সময়) ইনভোক করা হয়, যার অর্থ হল কম্পোজিশনের সময় firstVisibleItemScrollOffset স্টেট আর পড়া হয় না। Compose টুলকিট, State কখন রিড করা হয় তা ট্র্যাক করে, তাই এই পরিবর্তনের অর্থ হল, firstVisibleItemScrollOffset-এর value পরিবর্তিত হলে, Compose টুলকিটকে শুধু লেআউট ও ড্রয়িং ফেজ রিস্টার্ট করতে হয়।

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

রিকম্পোজিশন লুপ (সাইক্লিক ফেজ ডিপেন্ডেন্সি)

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

Box {
    var imageHeightPx by remember { mutableIntStateOf(0) }

    Image(
        painter = painterResource(R.drawable.rectangle),
        contentDescription = "I'm above the text",
        modifier = Modifier
            .fillMaxWidth()
            .onSizeChanged { size ->
                // Don't do this
                imageHeightPx = size.height
            }
    )

    Text(
        text = "I'm below the image",
        modifier = Modifier.padding(
            top = with(LocalDensity.current) { imageHeightPx.toDp() }
        )
    )
}

এই উদাহরণে একটি উল্লম্ব কলাম প্রয়োগ করা হয়েছে, যেখানে উপরে ছবি এবং তার নিচে টেক্সট রয়েছে। এটি ছবির সমাধান করা সাইজ পেতে Modifier.onSizeChanged() ব্যবহার করে এবং তারপরে টেক্সটকে নিচে নামাতে Modifier.padding() ব্যবহার করে। Px থেকে Dp-এ অস্বাভাবিক কনভার্সন থেকে বোঝা যায় যে কোডে কিছু সমস্যা আছে।

এই উদাহরণের সমস্যা হল যে কোডটি একটি ফ্রেমের মধ্যে "চূড়ান্ত" লেআউটে পৌঁছায় না। কোডটি একাধিক ফ্রেমের উপর নির্ভর করে, যা অপ্রয়োজনীয় কাজ করে এবং এর ফলে ব্যবহারকারীর জন্য স্ক্রিনে UI জাম্প করে।

প্রথম ফ্রেম কম্পোজিশন

প্রথম ফ্রেমের কম্পোজিশন ফেজ চলাকালীন, imageHeightPx প্রাথমিকভাবে 0। এর ফলে, কোডটি Modifier.padding(top = 0) সহ টেক্সট প্রদান করে। পরবর্তী লেআউট ফেজ onSizeChanged মডিফায়ারের কলব্যাককে ইনভোক করে, যা imageHeightPx-কে ছবির প্রকৃত উচ্চতায় আপডেট করে। Compose তারপর পরবর্তী ফ্রেমের জন্য একটি রিকম্পোজিশন শিডিউল করে। তবে, বর্তমান ড্রয়িং ফেজে, টেক্সট 0 প্যাডিং সহ রেন্ডার হয়, কারণ আপডেট করা imageHeightPx ভ্যালু এখনও প্রতিফলিত হয়নি।

দ্বিতীয় ফ্রেম কম্পোজিশন

Compose দ্বিতীয় ফ্রেম শুরু করে, যা imageHeightPx-এর ভ্যালুতে পরিবর্তনের মাধ্যমে ট্রিগার হয়। এই ফ্রেমের কম্পোজিশন ফেজে, Box কন্টেন্ট ব্লকের মধ্যে স্টেট রিড করা হয়। টেক্সটটি এখন প্যাডিং সহ প্রদান করা হয়েছে যা ছবির উচ্চতার সাথে সঠিকভাবে মেলে। লেআউট ফেজ চলাকালীন, imageHeightPx আবার সেট করা হয়; তবে, ভ্যালু একই থাকার কারণে আর কোনও রিকম্পোজিশন শিডিউল করা হয় না।

ডায়াগ্রামে একটি রিকম্পোজিশন লুপ দেখানো হয়েছে যেখানে লেআউট ফেজে সাইজ পরিবর্তন হলে রিকম্পোজিশন ট্রিগার হয়, যার ফলে লেআউট আবার তৈরি হয়।

এই উদাহরণটি কৃত্রিম বলে মনে হতে পারে, তবে এই সাধারণ প্যাটার্ন সম্পর্কে সতর্ক থাকুন:

  • Modifier.onSizeChanged(), onGloballyPositioned() বা অন্য কোনও লেআউট অপারেশন
  • কিছু স্ট্যাটাস আপডেট করুন
  • লেআউট মডিফায়ারের (padding(), height(), বা একই ধরনের) ইনপুট হিসেবে সেই স্টেট ব্যবহার করুন
  • সম্ভাব্য পুনরাবৃত্তি

আগের স্যাম্পেলের সমস্যা সমাধান করতে, সঠিক লেআউট প্রিমিটিভ ব্যবহার করতে হবে। আগের উদাহরণটি Column()-এর মাধ্যমে প্রয়োগ করা যেতে পারে, তবে আপনার কাছে আরও জটিল উদাহরণ থাকতে পারে যার জন্য কাস্টম কিছু প্রয়োজন, যার জন্য একটি কাস্টম লেআউট লিখতে হবে। আরও তথ্যের জন্য কাস্টম লেআউট সংক্রান্ত নির্দেশিকা দেখুন।

এখানে সাধারণ নীতি হল একাধিক UI এলিমেন্টের জন্য single source of truth থাকা যা একে অপরের সাপেক্ষে পরিমাপ করা এবং স্থাপন করা উচিত। সঠিক লেআউট প্রিমিটিভ ব্যবহার করা বা কাস্টম লেআউট তৈরি করার অর্থ হল, ন্যূনতম শেয়ার করা পেরেন্ট সোর্স অফ ট্রুথ হিসেবে কাজ করে যা একাধিক এলিমেন্টের মধ্যে সম্পর্ককে সমন্বয় করতে পারে। ডায়নামিক স্টেট চালু করলে এই নীতি লঙ্ঘন করা হয়।

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