जेटपैक कंपोज़ एंड्रॉइड के लिए आधुनिक यूआई टूलकिट है। एक घोषणात्मक यूआई है जो अनिवार्य एक (एक्सएमएल) को प्रतिस्थापित करता है।

क्लासिक तरीके से आप कई गतिविधियों या खंड जीवनचक्र को संभालने के लिए उपयोग करते हैं। ( onStart , onCreate , onResume ...etc)

आधिकारिक डॉक्स के अनुसार :

एक कंपोज़ेबल का जीवनचक्र निम्नलिखित घटनाओं द्वारा परिभाषित किया गया है: कंपोज़िशन में प्रवेश करना, 0 या अधिक बार रीकंपोज़ करना, और कंपोज़िशन को छोड़ना।

तो हमारे पास तीन घटनाएँ हैं:

I. संरचना दर्ज करें

द्वितीय। एन बार के लिए पुनः रचना प्राप्त करना

तृतीय। रचना छोड़ना

एक रचना केवल एक प्रारंभिक रचना द्वारा निर्मित की जा सकती है और पुनर्रचना द्वारा अद्यतन की जा सकती है । रचना को संशोधित करने का एकमात्र तरीका पुनर्रचना के माध्यम से है ।

उदाहरण के लिए:

@Composable
fun MoviesScreen(movies: List<Movie>) {
    Column {
        for (movie in movies) {
            key(movie.id) { // Unique ID for this movie
                MovieOverview(movie)
            }
        }
    }
}

अन्यथा, हमें फ़ंक्शन को वापस बुलाने की आवश्यकता के बिना पुनरावृत्ति को संभालना होगा।

यदि कोई कंपोज़ेबल पहले से ही संरचना में है, तो यह पुनर्रचना को छोड़ सकता है यदि सभी इनपुट स्थिर हैं और बदले नहीं गए हैं।

तो पुनर्रचना कैसे करें?

recompositon रचना योग्य फ़ंक्शन चर प्रकार पर निर्भर करता है

यदि चर स्थिर प्रकार (( Boolean,,,,, Intआदि ) Longसे हैं Floatतो Charकोई पुनर्संयोजन नहीं होगा।

तो फिर इन स्थिर प्रकारों को ऐसे प्रकार में कैसे परिवर्तित किया जाए जिससे पुनर्रचना हो सके?

ठीक है, आधिकारिक डॉक्स के अनुसार :

rememberकिसी वस्तु को मेमोरी में स्टोर करने के लिए कंपोज़ेबल फ़ंक्शंस एपीआई का उपयोग कर सकते हैं । rememberप्रारंभिक संरचना के दौरान संरचना द्वारा गणना की गई मान को संग्रहीत किया जाता है, और संग्रहीत मूल्य को पुनर्रचना के दौरान वापस कर दिया जाता है। rememberपरिवर्तनीय और अपरिवर्तनीय दोनों वस्तुओं को संग्रहीत करने के लिए उपयोग किया जा सकता है।

इसलिए हमें MutableState<T> इंटरफ़ेस को अपने कंपोज़ फ़ंक्शन में परिवर्तनशीलता जोड़ने के लिए करना होगा, इसलिए इस प्रकार के परिवर्तन के मूल्य में हर बार पुनर्संयोजन होगा।

MutableState<T> क्लास अगर आप State<T> टाइप करते हैं

interface MutableState<T> : State<T> {
    override var value: T
}

mutableStateOf

var list by remeber{mutableStateOf(initialValue)}
or 
val list = remember { mutableStateOf(initialValue) } // val variable will not change

import androidx.compose.runtime.getValue
import androidx.compose.runtime.setValue

list.value = ….

State<T> या MutableState<T> के अलावा अन्य प्रकार के State हैं, रचना भी निम्नलिखित का समर्थन करती है:

• सजीव आंकड़ा
• प्रवाह
• RxJava2

पढ़ने के लिए धन्यवाद :)

संदर्भ :