टाइल का इस्तेमाल शुरू करना


अपने ऐप्लिकेशन से टाइल उपलब्ध कराने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये डिपेंडेंसी शामिल करें.

Groovy

dependencies {
    // Use to implement support for wear tiles
    implementation "androidx.wear.tiles:tiles:1.6.2"

    // Use to utilize standard components and layouts in your tiles
    implementation "androidx.wear.protolayout:protolayout:1.4.2"

    // Use to utilize components and layouts with Material Design in your tiles
    implementation "androidx.wear.protolayout:protolayout-material:1.4.2"

    // Use to include dynamic expressions in your tiles
    implementation "androidx.wear.protolayout:protolayout-expression:1.4.2"

    // Use to preview wear tiles in your own app
    debugImplementation "androidx.wear.tiles:tiles-renderer:1.6.2"

    // Use to fetch tiles from a tile provider in your tests
    testImplementation "androidx.wear.tiles:tiles-testing:1.6.2"
}

Kotlin

dependencies {
    // Use to implement support for wear tiles
    implementation("androidx.wear.tiles:tiles:1.6.2")

    // Use to utilize standard components and layouts in your tiles
    implementation("androidx.wear.protolayout:protolayout:1.4.2")

    // Use to utilize components and layouts with Material Design in your tiles
    implementation("androidx.wear.protolayout:protolayout-material:1.4.2")

    // Use to include dynamic expressions in your tiles
    implementation("androidx.wear.protolayout:protolayout-expression:1.4.2")

    // Use to preview wear tiles in your own app
    debugImplementation("androidx.wear.tiles:tiles-renderer:1.6.2")

    // Use to fetch tiles from a tile provider in your tests
    testImplementation("androidx.wear.tiles:tiles-testing:1.6.2")
}

मुख्य सिद्धांत

टाइल, Android ऐप्लिकेशन की तरह नहीं बनाई जाती हैं. इन्हें बनाने के लिए, अलग-अलग कॉन्सेप्ट का इस्तेमाल किया जाता है:

  • लेआउट टेंप्लेट: डिसप्ले पर विज़ुअल एलिमेंट की पूरी व्यवस्था तय करें. ऐसा करने के लिए, primaryLayout() फ़ंक्शन का इस्तेमाल किया जाता है.
  • लेआउट एलिमेंट: ये किसी अलग ग्राफ़िकल एलिमेंट को दिखाते हैं. जैसे, बटन या कार्ड. इसके अलावा, ये कॉलम, buttonGroup या मिलते-जुलते एलिमेंट का इस्तेमाल करके, एक साथ ग्रुप किए गए कई एलिमेंट को भी दिखाते हैं. ये लेआउट टेंप्लेट में एम्बेड किए जाते हैं.
  • संसाधन: ResourceBuilders.Resources ऑब्जेक्ट में, Android के संसाधनों (इमेज) के की-वैल्यू पेयर का मैप और वर्शन शामिल होता है. लेआउट रेंडर करने के लिए, इन संसाधनों की ज़रूरत होती है.
  • टाइमलाइन: TimelineBuilders.Timeline ऑब्जेक्ट, लेआउट ऑब्जेक्ट के एक या उससे ज़्यादा इंस्टेंस की सूची होती है. रेंडरर को एक लेआउट ऑब्जेक्ट से दूसरे लेआउट ऑब्जेक्ट पर कब स्विच करना चाहिए, यह बताने के लिए कई तरह के तरीके और एक्सप्रेशन उपलब्ध कराए जा सकते हैं. जैसे, किसी खास समय पर लेआउट दिखाना बंद करना.
  • स्टेट: StateBuilders.State टाइप का डेटा स्ट्रक्चर, जिसे टाइल और ऐप्लिकेशन के बीच पास किया जाता है. इससे दोनों कॉम्पोनेंट एक-दूसरे के साथ कम्यूनिकेट कर पाते हैं. उदाहरण के लिए, अगर टाइल पर मौजूद किसी बटन पर टैप किया जाता है, तो स्टेट में उस बटन का आईडी सेव हो जाता है. मैप का इस्तेमाल करके, डेटा टाइप भी बदले जा सकते हैं.
  • टाइल: टाइल को दिखाने वाला TileBuilders.Tile ऑब्जेक्ट. इसमें टाइमलाइन, संसाधन के वर्शन का आईडी, डेटा अपडेट होने की फ़्रीक्वेंसी, और स्थिति शामिल होती है.
  • Protolayout: यह शब्द, टाइल से जुड़ी अलग-अलग क्लास के नाम में दिखता है. यह Wear OS Protolayout लाइब्रेरी के बारे में बताता है. यह एक ग्राफ़िक्स लाइब्रेरी है, जिसका इस्तेमाल Wear OS के अलग-अलग प्लैटफ़ॉर्म पर किया जाता है.

टाइल बनाना

Material3TileService का इस्तेमाल करें (सुझाया गया)

Material 3 टाइल (androidx.wear.tiles:tiles:1.6.0 और इसके बाद के वर्शन) बनाते समय, हमेशा निचले लेवल की TileService क्लास के बजाय, Material3TileService को एक्सटेंड करें. Material3TileService, Kotlin-फ़र्स्ट आर्किटेक्चर उपलब्ध कराता है. इससे टाइल डेवलपमेंट आसान हो जाता है:

  • पहले से मौजूद Kotlin कोरूटीन: ListenableFuture का इस्तेमाल करने और onTileRequest() को बदलने के बजाय, एक सस्पेंडिंग MaterialScope.tileResponse(requestParams: TileRequest): Tile फ़ंक्शन लागू करें.
  • पहले से कॉन्फ़िगर किया गया MaterialScope: tileResponse(), MaterialScope के साथ रिसीवर के तौर पर काम करता है. इसे कंस्ट्रक्टर पैरामीटर, जैसे कि allowDynamicTheme और defaultColorScheme की मदद से कॉन्फ़िगर किया जाता है. इसलिए, आपको अपने लेआउट को ग़ैर-ज़रूरी materialScope() कॉल में रैप करने की ज़रूरत नहीं है.
  • एक कॉल में संसाधन रजिस्टर करना: इसमें ProtoLayoutScope शामिल है, ताकि इनलाइन इमेज के संसाधनों को अपने-आप रजिस्टर किया जा सके. साथ ही, एक ही सिस्टम बाइंडर कॉल में टाइल लेआउट और संसाधन, दोनों को वापस लाया जा सके. Material3TileService, संसाधनों को अपने-आप मैनेज करता है (final onTileResourcesRequest()). इसलिए, onTileResourcesRequest() को ओवरराइड न करें.
class MyTileService : Material3TileService() {

    override suspend fun MaterialScope.tileResponse(requestParams: TileRequest): Tile =
        tile(
            timeline =
            Timeline.fromLayoutElement(
                primaryLayout(
                    mainSlot = {
                        text("Hello, World!".layoutString, typography = BODY_LARGE)
                    }
                )
            )
        )
}

अंडरलाइंग TileService आर्किटेक्चर

Material3TileService, बेस TileService क्लास पर आधारित है. इस गाइड में दिए गए बाकी उदाहरणों में, इस क्लास का इस्तेमाल करके बुनियादी कॉन्सेप्ट को समझाया गया है.

अपने ऐप्लिकेशन से टाइल उपलब्ध कराने के लिए, TileService टाइप की सेवा लागू करें और उसे अपने मेनिफ़ेस्ट में रजिस्टर करें. इससे, सिस्टम onTileRequest() को कॉल करने के दौरान ज़रूरी टाइल और onTileResourcesRequest() को कॉल करने के दौरान ज़रूरी संसाधनों का अनुरोध करता है.

class MyTileService : TileService() {

    override fun onTileRequest(requestParams: RequestBuilders.TileRequest) =
        Futures.immediateFuture(
            Tile.Builder()
                .setResourcesVersion(RESOURCES_VERSION)
                .setTileTimeline(
                    Timeline.fromLayoutElement(
                        materialScope(this, requestParams.deviceConfiguration) {
                            primaryLayout(
                                mainSlot = {
                                    text("Hello, World!".layoutString, typography = BODY_LARGE)
                                }
                            )
                        }
                    )
                )
                .build()
        )

    override fun onTileResourcesRequest(requestParams: ResourcesRequest) =
        Futures.immediateFuture(Resources.Builder().setVersion(RESOURCES_VERSION).build())
}

इसके बाद, अपनी AndroidManifest.xml फ़ाइल के <application> टैग में कोई सेवा जोड़ें.

<service
    android:name=".snippets.m3.tile.MyTileService"
    android:label="@string/tile_label"
    android:description="@string/tile_description"
    android:icon="@mipmap/ic_launcher"
    android:exported="true"
    android:permission="com.google.android.wearable.permission.BIND_TILE_PROVIDER">
    <intent-filter>
        <action android:name="androidx.wear.tiles.action.BIND_TILE_PROVIDER" />
    </intent-filter>

    <meta-data android:name="androidx.wear.tiles.PREVIEW"
        android:resource="@drawable/tile_preview" />
</service>

अनुमति और इंटेंट फ़िल्टर, इस सेवा को टाइल उपलब्ध कराने वाली सेवा के तौर पर रजिस्टर करते हैं.

जब उपयोगकर्ता अपने फ़ोन या स्मार्टवॉच पर टाइल कॉन्फ़िगर करता है, तो उसे आइकॉन, लेबल, ब्यौरा, और झलक वाला संसाधन दिखता है. ध्यान दें कि झलक वाला रिसॉर्स, Android के सभी स्टैंडर्ड रिसॉर्स क्वालिफ़ायर के साथ काम करता है. इसलिए, स्क्रीन के साइज़ और डिवाइस की भाषा जैसे फ़ैक्टर के हिसाब से, झलक में बदलाव किया जा सकता है. अन्य सुझावों के लिए, झलक की चेकलिस्ट देखें.

अपना ऐप्लिकेशन डिप्लॉय करें और टाइल को टाइल कैरसेल में जोड़ें. टाइल की झलक देखने का एक और तरीका भी है जो डेवलपर के लिए ज़्यादा आसान है. हालांकि, फ़िलहाल इसे मैन्युअल तरीके से ही करें.

मटीरियल 3 की मदद से बनाई गई Wear OS टाइल, जिसमें 'नमस्ते' टेक्स्ट दिख रहा है.
पहली इमेज. "नमस्ते" टाइल.

पूरा उदाहरण देखने के लिए, GitHub पर मौजूद कोड सैंपल या कोड लैब देखें.

टाइल के लिए यूज़र इंटरफ़ेस (यूआई) बनाना

Material 3 Expressive के यूज़र इंटरफ़ेस (यूआई) एलिमेंट, Kotlin के टाइप-सेफ़ बिल्डर पैटर्न की मदद से, स्ट्रक्चर्ड तरीके से बनाए जाते हैं.

लेआउट

असरदार और रिस्पॉन्सिव टाइल लेआउट बनाने के लिए, डिज़ाइन से जुड़े सिद्धांतों के बारे में दिशा-निर्देश पाने के लिए, टाइल के लिए सामान्य लेआउट देखें.

अपना लेआउट बनाने के लिए, यह तरीका अपनाएं:

  1. मटीरियल डिज़ाइन स्कोप शुरू करना: materialScope() फ़ंक्शन को कॉल करें. साथ ही, ज़रूरी context और deviceConfiguration उपलब्ध कराएं. आपके पास allowDynamicTheme और defaultColorScheme जैसे वैकल्पिक पैरामीटर शामिल करने का विकल्प होता है. allowDynamicTheme डिफ़ॉल्ट रूप से true होता है और defaultColorScheme, ColorScheme को दिखाता है. इसका इस्तेमाल तब किया जाता है, जब डाइनैमिक कलर उपलब्ध न हों. जैसे, जब उपयोगकर्ता ने इस सुविधा को बंद कर दिया हो या डिवाइस पर यह सुविधा काम न करती हो या allowDynamicTheme, false हो. कस्टम TileService में backgroundImage() जैसे ImageResource एपीआई का इस्तेमाल करते समय, इसके बजाय materialScopeWithResources() को कॉल करें.

  2. स्कोप के अंदर अपना यूज़र इंटरफ़ेस (यूआई) बनाएं: किसी टाइल लेआउट के लिए, सभी यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट को एक टॉप-लेवल materialScope() कॉल के लैम्डा के अंदर तय किया जाना चाहिए. primaryLayout() और textEdgeButton() जैसे कॉम्पोनेंट फ़ंक्शन, MaterialScope पर एक्सटेंशन फ़ंक्शन होते हैं. ये सिर्फ़ तब उपलब्ध होते हैं, जब इन्हें इस रिसीवर स्कोप पर कॉल किया जाता है.

    materialScope(
        context = context,
        deviceConfiguration =
        requestParams.deviceConfiguration, // requestParams is passed to onTileRequest
        defaultColorScheme = myFallbackColorScheme
    ) {
        // inside the MaterialScope, you can call functions like primaryLayout()
        primaryLayout(
            titleSlot = { text(text = "Title".layoutString) },
            mainSlot = { text(text = "Main Content".layoutString) },
            bottomSlot = {
                textEdgeButton(
                    labelContent = { text("Action".layoutString) },
                    onClick = clickable()
                )
            }
        )
    }

कसीनो स्लॉट मशीन की नकल वाले गेम

M3 में, टाइल लेआउट के लिए Compose से प्रेरित तरीका इस्तेमाल किया जाता है. इसमें तीन अलग-अलग स्लॉट इस्तेमाल किए जाते हैं. ऊपर से नीचे की ओर, ये हैं:

  1. titleSlot, आम तौर पर मुख्य टाइटल या हेडर के लिए.
  2. मुख्य कॉन्टेंट के लिए mainSlot.
  3. bottomSlot, जिसका इस्तेमाल अक्सर कार्रवाइयों या अतिरिक्त जानकारी के लिए किया जाता है. यहीं पर एज बटन भी दिखता है.
titleSlot, mainSlot, और bottomSlot दिखाने वाला टाइल लेआउट
दूसरी इमेज. titleSlot, mainSlot, और bottomSlot.

हर स्लॉट का कॉन्टेंट इस तरह है:

  • titleSlot (ज़रूरी नहीं): आम तौर पर, text() से जनरेट किए गए कुछ शब्द.
  • mainSlot (ज़रूरी है): कॉम्पोनेंट को पंक्तियों, कॉलम, और बटन ग्रुप जैसे स्ट्रक्चर में व्यवस्थित किया गया है. इन कॉम्पोनेंट को एक-दूसरे के अंदर बार-बार एम्बेड भी किया जा सकता है. उदाहरण के लिए, किसी कॉलम में पंक्तियां हो सकती हैं.
  • bottomSlot (ज़रूरी नहीं): आम तौर पर, इसमें एज-हगिंग बटन या टेक्स्ट लेबल होता है.

टाइल को स्क्रोल नहीं किया जा सकता. इसलिए, पेजिंग, स्क्रोल करने या कॉन्टेंट की लंबी सूचियों को मैनेज करने के लिए कोई कॉम्पोनेंट नहीं है. ध्यान रखें कि फ़ॉन्ट का साइज़ बढ़ने या अनुवाद की वजह से टेक्स्ट लंबा होने पर भी, कॉन्टेंट दिखता रहे.

यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट

protolayout-material3 लाइब्रेरी में, मटीरियल 3 एक्सप्रेसिव की खास बातों और यूज़र इंटरफ़ेस के सुझावों के मुताबिक डिज़ाइन किए गए कई कॉम्पोनेंट उपलब्ध हैं.

बटन

बटन मुख्य रूप से ऐक्शन-ओरिएंटेड होते हैं. इनका इस्तेमाल, खास कार्रवाइयों को ट्रिगर करने के लिए किया जाता है. हर बटन का कॉन्टेंट, जैसे कि कोई आइकॉन या छोटा टेक्स्ट, कार्रवाई की पहचान करता है.

  • textButton(): (छोटे) टेक्स्ट कॉन्टेंट के लिए सिंगल स्लॉट वाला बटन
  • iconButton(): यह एक ऐसा बटन है जिसमें आइकॉन दिखाने के लिए सिर्फ़ एक स्लॉट होता है
  • avatarButton(): यह कैप्सूल के आकार का अवतार बटन होता है. इसमें कॉन्टेंट के लिए ज़्यादा से ज़्यादा तीन स्लॉट होते हैं. इनमें वर्टिकल तौर पर स्टैक किया गया लेबल और सेकंडरी लेबल होता है. साथ ही, इसके बगल में एक इमेज (अवतार) होती है
  • imageButton(): क्लिक किया जा सकने वाला इमेज बटन, जिसमें अन्य स्लॉट नहीं होते. इसमें सिर्फ़ इमेज होती है. उदाहरण के लिए, बैकग्राउंड के तौर पर backgroundImage
  • compactButton(): यह एक कॉम्पैक्ट बटन है, जिसमें ज़्यादा से ज़्यादा दो स्लॉट होते हैं. इनमें हॉरिज़ॉन्टल तौर पर स्टैक किया गया कॉन्टेंट शामिल होता है. इसमें एक आइकॉन और उसके बगल में टेक्स्ट होता है
  • button(): यह कैप्सूल के आकार का बटन होता है. इसमें कॉन्टेंट के लिए ज़्यादा से ज़्यादा तीन स्लॉट होते हैं. इनमें वर्टिकल तौर पर स्टैक किए गए लेबल और सेकंडरी लेबल के साथ-साथ, उसके बगल में मौजूद आइकॉन को दिखाया जाता है

Edge बटन

एज बटन, स्मार्टवॉच की गोल स्क्रीन पर सबसे नीचे मौजूद, पूरी चौड़ाई वाला एक खास बटन होता है. यह बटन, मौजूदा टाइल स्क्रीन पर की जाने वाली सबसे अहम कार्रवाई को दिखाता है.

  • iconEdgeButton(): यह एक एज बटन है, जिसमें आइकॉन या गोल और छोटे कॉन्टेंट के लिए एक स्लॉट होता है
  • textEdgeButton(): एज बटन, जिसमें टेक्स्ट या इसी तरह के लंबे और चौड़े कॉन्टेंट के लिए एक स्लॉट होता है

कार्ड

कार्ड मुख्य रूप से जानकारी देने के लिए होते हैं. इनमें मिलते-जुलते और स्ट्रक्चर्ड डेटा के कलेक्शन दिखते हैं. इंटरैक्टिव कार्ड बनाए जा सकते हैं. हालांकि, आम तौर पर वे जानकारी की खास जानकारी दिखाते हैं. इसके बाद, उपयोगकर्ता ज़्यादा जानकारी देखने या उससे जुड़ी कोई कार्रवाई करने के लिए, कार्ड पर टैप कर सकता है.

  • titleCard(): टाइटल कार्ड, जिसमें एक से तीन स्लॉट होते हैं. आम तौर पर, ये टेक्स्ट पर आधारित होते हैं
  • appCard(): ऐप्लिकेशन कार्ड, जिसमें ज़्यादा से ज़्यादा पांच स्लॉट होते हैं. आम तौर पर, ये टेक्स्ट पर आधारित होते हैं
  • textDataCard(): डेटा कार्ड, जिसमें वर्टिकल तौर पर स्टैक किए गए ज़्यादा से ज़्यादा तीन स्लॉट होते हैं. आम तौर पर, ये स्लॉट टेक्स्ट या अंकों पर आधारित होते हैं
  • iconDataCard(): यह डेटा कार्ड, वर्टिकल तौर पर स्टैक किए गए ज़्यादा से ज़्यादा तीन स्लॉट उपलब्ध कराता है. आम तौर पर, ये स्लॉट टेक्स्ट या संख्या पर आधारित होते हैं और इनमें एक आइकॉन होता है
  • graphicDataCard(): ग्राफ़िक डेटा कार्ड, जिसमें ग्राफ़िक डेटा के लिए एक स्लॉट होता है. जैसे, प्रोग्रेस इंडिकेटर. इसमें वर्टिकल तौर पर स्टैक किए गए ज़्यादा से ज़्यादा दो स्लॉट होते हैं. आम तौर पर, ये स्लॉट टेक्स्ट के ब्यौरे के लिए होते हैं

प्रोग्रेस इंडिकेटर

  • circularProgressIndicator(): यह रेडियल एलिमेंट का इस्तेमाल करके, किसी लक्ष्य की ओर प्रोग्रेस दिखाता है
  • segmentedCircularProgressIndicator(): यह अलग-अलग चरणों वाले रेडियल एलिमेंट का इस्तेमाल करके, लक्ष्य की ओर बढ़ने की प्रोग्रेस दिखाता है

ग्रुप लेआउट एलिमेंट

  • buttonGroup(): यह कॉम्पोनेंट-लेआउट, अपने चाइल्ड कॉम्पोनेंट को हॉरिज़ॉन्टल क्रम में रखता है
  • primaryLayout(): यह फ़ुल स्क्रीन लेआउट है, जो सुझाए गए M3 लेआउट स्टाइल को दिखाता है. यह स्टाइल रिस्पॉन्सिव है और एलिमेंट की प्लेसमेंट का ध्यान रखता है. साथ ही, इसमें सुझाए गए मार्जिन और पैडिंग लागू की जाती है

कोई थीम लागू करना

Material 3 Expressive में, कलर सिस्टम को 29 स्टैंडर्ड कलर रोल के हिसाब से तय किया जाता है. इन्हें छह ग्रुप में बांटा गया है: प्राइमरी, सेकंडरी, टर्शियरी, गड़बड़ी, सरफ़ेस, और आउटलाइन.

मटीरियल 3 एक्सप्रेसिव कलर सिस्टम, जिसमें कलर रोल को प्राइमरी, सेकंडरी, टर्शियरी, गड़बड़ी, सरफ़ेस, और आउटलाइन जैसे ग्रुप में व्यवस्थित करके दिखाया गया है.
तीसरी इमेज. मटीरियल 3 एक्सप्रेसिव कलर सिस्टम.

ColorScheme, इन 29 भूमिकाओं में से हर एक को उससे जुड़े रंग के साथ मैप करता है. साथ ही, यह MaterialScope का हिस्सा है और कॉम्पोनेंट इसके अंदर ही बनाए जाने चाहिए, इसलिए वे स्कीम से अपने-आप रंग चुन लेते हैं. इस तरीके से, सभी यूज़र इंटरफ़ेस (यूआई) एलिमेंट, मटीरियल डिज़ाइन के स्टैंडर्ड के मुताबिक अपने-आप काम करते हैं.

उपयोगकर्ताओं को आपकी तय की गई कलर स्कीम (जैसे, आपके ब्रैंड के रंगों को दिखाने वाली कलर स्कीम) और सिस्टम से मिली कलर स्कीम (उपयोगकर्ता के मौजूदा वॉच फ़ेस से ली गई कलर स्कीम या उपयोगकर्ता की चुनी गई कलर स्कीम) में से किसी एक को चुनने की सुविधा देने के लिए, MaterialScope को इस तरह शुरू करें:

val myColorScheme =
    ColorScheme(
        primary = Color.rgb(0, 0, 255).argb, // Blue
        onPrimary = Color.rgb(255, 255, 255).argb, // White
        // 27 more
    )

materialScope(
    context = context,
    deviceConfiguration = requestParams.deviceConfiguration,
    defaultColorScheme = myColorScheme
) {
    // If the user selects "no theme" in settings, myColorScheme is used.
    // Otherwise, the system-provided theme is used.
}

यह विकल्प चुनने पर, मोनोक्रोम टाइल आइकॉन उपलब्ध कराएं, ताकि किसी भी थीम के हिसाब से इसे सही तरीके से टिंट किया जा सके. इससे यह आइकॉन साफ़ तौर पर दिखेगा.

अपनी टाइल को अपनी चुनी गई कलर स्कीम में दिखाने के लिए, डाइनैमिक थीम की सुविधा बंद करें. इसके लिए, allowDynamicTheme को false पर सेट करें:

materialScope(
    context = context,
    deviceConfiguration = requestParams.deviceConfiguration,
    allowDynamicTheme = false,
    defaultColorScheme = myColorScheme
) {
    // myColorScheme is *always* used.
}

रंग

हर कॉम्पोनेंट, ColorScheme से तय किए गए 29 कलर रोल के सबसेट का इस्तेमाल करता है. उदाहरण के लिए, बटन में ज़्यादा से ज़्यादा चार रंगों का इस्तेमाल किया जाता है. ये रंग, डिफ़ॉल्ट रूप से चालू ColorScheme के "प्राइमरी" ग्रुप से लिए जाते हैं:

ButtonColors कॉम्पोनेंट टोकन ColorScheme भूमिका
containerColor प्राथमिक
iconColor onPrimary
labelColor onPrimary
secondaryLabelColor onPrimary (अपारदर्शिता 0.8)

Wear OS के डिज़ाइन में रंग लागू करने के बारे में ज़्यादा जानकारी के लिए, रंग के डिज़ाइन से जुड़ी गाइड देखें.

आपको कुछ यूज़र इंटरफ़ेस (यूआई) एलिमेंट के लिए, डिफ़ॉल्ट कलर टोकन से अलग टोकन इस्तेमाल करने पड़ सकते हैं. उदाहरण के लिए, हो सकता है कि आप किसी textEdgeButton के लिए "प्राइमरी" के बजाय, "सेकंडरी" या "टर्शियरी" ग्रुप के रंगों का इस्तेमाल करना चाहें. इससे, वह अलग दिखेगा और बेहतर कंट्रास्ट मिलेगा.

कॉम्पोनेंट के रंगों को कई तरीकों से पसंद के मुताबिक बनाया जा सकता है:

  1. पहले से तय किए गए रंगों के लिए, हेल्पर फ़ंक्शन का इस्तेमाल करें. मटीरियल 3 एक्सप्रेसिव के लिए स्टैंडर्ड बटन स्टाइल लागू करने के लिए, filledTonalButtonColors() जैसे हेल्पर फ़ंक्शन इस्तेमाल करें. ये फ़ंक्शन, पहले से कॉन्फ़िगर किए गए ButtonColors इंस्टेंस बनाते हैं. ये इंस्टेंस, फ़िल्ड, टोनल या आउटलाइन जैसी सामान्य स्टाइल को MaterialScope में मौजूद, चालू ColorScheme की सही भूमिकाओं से मैप करते हैं. इससे आपको सामान्य बटन टाइप के लिए, हर रंग को मैन्युअल तरीके से तय किए बिना, एक जैसी स्टाइल लागू करने की सुविधा मिलती है.

    textEdgeButton(
        colors = filledButtonColors(), // default
        /* OR colors = filledTonalButtonColors() */
        /* OR colors = filledVariantButtonColors() */
        // ... other parameters
    )

    कार्ड के लिए, filledCardColors() फ़ंक्शन के मिलते-जुलते फ़ैमिली फ़ंक्शन का इस्तेमाल करें.

    अगर आपको सिर्फ़ एक या दो टोकन बदलने हैं, तो हेल्पर फ़ंक्शन से मिले ButtonColors ऑब्जेक्ट में भी बदलाव किया जा सकता है. इसके लिए, उनके copy() तरीके का इस्तेमाल करें:

    textEdgeButton(
        colors =
        filledButtonColors()
            .copy(
                containerColor = colorScheme.tertiary,
                labelColor = colorScheme.onTertiary
            ),
        // ... other parameters
    )

  2. बदले गए कलर रोल की जानकारी साफ़ तौर पर दें. अपना ButtonColors ऑब्जेक्ट बनाएं और उसे कॉम्पोनेंट में पास करें. कार्ड के लिए, इसके बराबर का CardColors ऑब्जेक्ट इस्तेमाल करें.

    textEdgeButton(
        colors =
        ButtonColors(
            // the materialScope makes colorScheme available
            containerColor = colorScheme.secondary,
            iconColor = colorScheme.secondaryDim,
            labelColor = colorScheme.onSecondary,
            secondaryLabelColor = colorScheme.onSecondary
        ),
        // ... other parameters
    )

  3. तय किए गए रंगों का इस्तेमाल करें (सावधानी से इस्तेमाल करें). आम तौर पर, रंगों को उनकी सिमैंटिक भूमिका के हिसाब से तय करने का सुझाव दिया जाता है.जैसे, colorScheme.primary. हालांकि, रंगों की वैल्यू सीधे तौर पर भी दी जा सकती है. इस तरीके का इस्तेमाल कम से कम किया जाना चाहिए, क्योंकि इससे पूरी थीम में अंतर आ सकता है. खास तौर पर, तब जब थीम डाइनैमिक तौर पर बदलती हो.

    textEdgeButton(
        colors = filledButtonColors().copy(
            containerColor = android.graphics.Color.RED.argb, // Using named colors
            labelColor = 0xFFFFFF00.toInt().argb // Using a hex code for yellow
        ),
        // ... other parameters
    )

टाइपोग्राफ़ी

अपने डिज़ाइन में टाइपोग्राफ़ी का असरदार तरीके से इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, टाइपोग्राफ़ी डिज़ाइन गाइड देखें.

Wear OS प्लैटफ़ॉर्म पर विज़ुअल एक जैसे दिखें और परफ़ॉर्मेंस को ऑप्टिमाइज़ किया जा सके, इसके लिए टाइल पर मौजूद सभी टेक्स्ट को सिस्टम के फ़ॉन्ट का इस्तेमाल करके रेंडर किया जाता है. इसका मतलब है कि टाइल में कस्टम टाइपफ़ेस का इस्तेमाल नहीं किया जा सकता. Wear OS 6 और इसके बाद के वर्शन पर, यह ओईएम के हिसाब से तय किया गया फ़ॉन्ट है. ज़्यादातर मामलों में, यह एक वैरिएबल फ़ॉन्ट होगा. इससे आपको ज़्यादा बेहतर अनुभव और ज़्यादा कंट्रोल मिलेगा.

टेक्स्ट स्टाइल बनाने के लिए, आम तौर पर text() तरीके का इस्तेमाल किया जाता है. साथ ही, इसमें टाइपोग्राफ़िक कॉन्सटेंट भी शामिल होते हैं. इस कॉम्पोनेंट की मदद से, Material 3 Expressive में पहले से तय की गई टाइपोग्राफ़ी की भूमिकाओं का इस्तेमाल किया जा सकता है. इससे आपकी टाइल, टाइपोग्राफ़ी के सबसे सही तरीकों का पालन करती है. इससे टाइल को आसानी से पढ़ा जा सकता है और उसकी हैरारकी को समझा जा सकता है. लाइब्रेरी में 18 सिमैंटिक टाइपोग्राफ़ी कॉन्स्टेंट का सेट मौजूद है, जैसे कि BODY_MEDIUM. ये कॉन्सटेंट, साइज़ के अलावा फ़ॉन्ट ऐक्सिस पर भी असर डालते हैं.

text(
    text = "Hello, World!".layoutString,
    typography = BODY_MEDIUM,
)

ज़्यादा कंट्रोल के लिए, अन्य सेटिंग भी जोड़ी जा सकती हैं. Wear OS 6 और इसके बाद के वर्शन पर, वैरिएबल फ़ॉन्ट का इस्तेमाल किया जा सकता है. इसे इटैलिक, वेट, चौड़ाई, और गोलाई ऐक्सिस के हिसाब से बदला जा सकता है. settings पैरामीटर का इस्तेमाल करके, इन ऐक्सिस को कंट्रोल किया जा सकता है:

text(
    text = "Hello, World".layoutString,
    italic = true,

    // Use elements defined in androidx.wear.protolayout.LayoutElementBuilders.FontSetting
    settings =
    listOf(
        weight(500),
        width(100F),
        roundness(100)
    ),
)

आखिर में, अगर आपको साइज़ या अक्षरों के बीच की स्पेसिंग को कंट्रोल करना है (इसका सुझाव नहीं दिया जाता), तो text() के बजाय basicText() का इस्तेमाल करें. साथ ही, fontStyle() का इस्तेमाल करके, fontStyle प्रॉपर्टी के लिए कोई वैल्यू बनाएं.

आकार और मार्जिन

shape प्रॉपर्टी का इस्तेमाल करके, करीब-करीब हर कॉम्पोनेंट के कोने की रेडियस को बदला जा सकता है. वैल्यू, MaterialScope प्रॉपर्टी shapes से मिलती हैं:

textButton(
    height = expand(),
    width = expand(),
    shape = shapes.medium, // OR another value like shapes.full
    colors = filledVariantButtonColors(),
    labelContent = { text("Hello, World!".layoutString) },
)

किसी कॉम्पोनेंट का शेप बदलने के बाद, अगर आपको लगता है कि डिसप्ले के किनारे पर बहुत ज़्यादा या बहुत कम जगह बची है, तो primaryLayout() के margin पैरामीटर का इस्तेमाल करके मार्जिन अडजस्ट करें:

primaryLayout(
    mainSlot = {
        textButton(
            shape = shapes.small,
            /* ... */
        )
    },
    // margin constants defined in androidx.wear.protolayout.material3.PrimaryLayoutMargins
    margins = MAX_PRIMARY_LAYOUT_MARGIN,
)

के लिए कोई टाइल नहीं है.

आर्क

Arc कंटेनर के इन चाइल्ड एलिमेंट का इस्तेमाल किया जा सकता है:

  • ArcLine: यह आर्क के चारों ओर एक घुमावदार लाइन रेंडर करता है.
  • ArcText: यह आर्क में घुमावदार टेक्स्ट रेंडर करता है.
  • ArcAdapter: यह आर्क में एक बेसिक लेआउट एलिमेंट को रेंडर करता है. इसे आर्क के टेंजेंट पर ड्रॉ किया जाता है.

ज़्यादा जानकारी के लिए, हर एलिमेंट टाइप का रेफ़रंस दस्तावेज़ देखें.

मॉडिफ़ायर

उपलब्ध हर लेआउट एलिमेंट में, मॉडिफ़ायर लागू किए जा सकते हैं. हालांकि, ऐसा करना ज़रूरी नहीं है. इन मॉडिफ़ायर का इस्तेमाल, इन कामों के लिए करें:

  • लेआउट के विज़ुअल अपियरेंस में बदलाव करना. उदाहरण के लिए, अपने लेआउट एलिमेंट में बैकग्राउंड, बॉर्डर या पैडिंग जोड़ें.
  • लेआउट के बारे में मेटाडेटा जोड़ें. उदाहरण के लिए, स्क्रीन रीडर के साथ इस्तेमाल करने के लिए, अपने लेआउट एलिमेंट में सिमैंटिक मॉडिफ़ायर जोड़ें.
  • सुविधाएं जोड़ना. उदाहरण के लिए, अपनी टाइल को इंटरैक्टिव बनाने के लिए, लेआउट एलिमेंट में क्लिक किया जा सकने वाला मॉडिफ़ायर जोड़ें. ज़्यादा जानकारी के लिए, टाइल के साथ इंटरैक्ट करना लेख पढ़ें.

उदाहरण के लिए, हम Image के डिफ़ॉल्ट लुक और मेटाडेटा को पसंद के मुताबिक बना सकते हैं. इसके बारे में यहां दिए गए कोड सैंपल में बताया गया है:

private fun myImage(): LayoutElement =
    Image.Builder()
        .setWidth(dp(24f))
        .setHeight(dp(24f))
        .setResourceId("image_id")
        .setModifiers(
            Modifiers.Builder()
                .setBackground(Background.Builder().setColor(argb(0xFFFF0000.toInt())).build())
                .setPadding(ModifiersBuilders.Padding.Builder().setStart(dp(12f)).build())
                .setSemantics(Semantics.Builder().setContentDescription("Image description").build())
                .build()
        )
        .build()

Spannables

Spannable एक खास तरह का कंटेनर होता है, जो एलिमेंट को टेक्स्ट की तरह दिखाता है. यह तब काम आता है, जब आपको टेक्स्ट के किसी बड़े ब्लॉक में सिर्फ़ एक सबस्ट्रिंग पर कोई अलग स्टाइल लागू करनी हो. ऐसा Text एलिमेंट की मदद से नहीं किया जा सकता.

Spannable कंटेनर में Span चाइल्ड एलिमेंट हैं. अन्य चाइल्ड या नेस्ट किए गए Spannable इंस्टेंस की अनुमति नहीं है.

Span के दो तरह के चाइल्ड एलिमेंट होते हैं:

  • SpanText: यह किसी खास स्टाइल में टेक्स्ट रेंडर करता है.
  • SpanImage: टेक्स्ट के साथ इमेज रेंडर करता है.

उदाहरण के लिए, "Hello world" टाइल में "world" को इटैलिक किया जा सकता है और शब्दों के बीच में कोई इमेज डाली जा सकती है. इसके लिए, यहां दिए गए कोड सैंपल को देखें:

private fun mySpannable(): LayoutElement =
    LayoutElementBuilders.Spannable.Builder()
        .addSpan(SpanText.Builder().setText("Hello ").build())
        .addSpan(SpanImage.Builder().setWidth(dp(24f)).setHeight(dp(24f)).setResourceId("image_id").build())
        .addSpan(
            SpanText.Builder()
                .setText("world")
                .setFontStyle(FontStyle.Builder().setItalic(true).build())
                .build()
        )
        .build()

संसाधनों के साथ काम करना

टाइल के पास आपके ऐप्लिकेशन के किसी भी संसाधन का ऐक्सेस नहीं होता. इसका मतलब है कि किसी Image लेआउट एलिमेंट में Android इमेज आईडी पास नहीं किया जा सकता. साथ ही, यह उम्मीद नहीं की जा सकती कि वह समस्या हल हो जाएगी. इसके बजाय, onTileResourcesRequest() तरीके को बदलें और मैन्युअल तरीके से कोई भी संसाधन उपलब्ध कराएं.

onTileResourcesRequest() तरीके में इमेज उपलब्ध कराने के दो तरीके हैं:

  • setAndroidResourceByResId() का इस्तेमाल करके, ड्रॉ करने लायक संसाधन उपलब्ध कराएं.
  • setInlineResource() का इस्तेमाल करके, ByteArray के तौर पर डाइनैमिक इमेज दें.

override fun onTileResourcesRequest(
    requestParams: ResourcesRequest
) = Futures.immediateFuture(
    Resources.Builder()
        .setVersion("1")
        .addIdToImageMapping(
            "image_from_resource",
            ResourceBuilders.ImageResource.Builder()
                .setAndroidResourceByResId(
                    ResourceBuilders.AndroidImageResourceByResId.Builder()
                        .setResourceId(R.drawable.ic_walk)
                        .build()
                ).build()
        )
        .addIdToImageMapping(
            "image_inline",
            ResourceBuilders.ImageResource.Builder()
                .setInlineResource(
                    ResourceBuilders.InlineImageResource.Builder()
                        .setData(imageAsByteArray)
                        .setWidthPx(48)
                        .setHeightPx(48)
                        .setFormat(ResourceBuilders.IMAGE_FORMAT_RGB_565)
                        .build()
                ).build()
        ).build()
)

टाइल की झलक वाली इमेज की चेकलिस्ट

सिस्टम, टाइल की झलक वाली इमेज दिखाता है. इसे Android ऐप्लिकेशन मेनिफ़ेस्ट में रेफ़रंस के तौर पर इस्तेमाल किया जाता है. यह इमेज, नई टाइल जोड़ने के लिए टाइल कैरसेल एडिटर में दिखती है. यह एडिटर, Wear OS डिवाइसों और फ़ोन पर स्मार्टवॉच के कंपैनियन ऐप्लिकेशन, दोनों में दिखता है.

उपयोगकर्ता इस झलक वाली इमेज का ज़्यादा से ज़्यादा फ़ायदा ले सकें, इसके लिए अपनी टाइल के बारे में इस जानकारी की पुष्टि करें:

  • इससे नए डिज़ाइन के बारे में पता चलता है. झलक में, टाइल का सबसे नया डिज़ाइन सटीक तरीके से दिखना चाहिए.
  • सुझाए गए डाइमेंशन का इस्तेमाल करता है. झलक वाली इमेज का डाइमेंशन 400 पिक्सल x 400 पिक्सल होना चाहिए, ताकि वह अच्छी क्वालिटी में दिखे और उपयोगकर्ताओं को बेहतर अनुभव मिले.
  • स्टैटिक रंग वाली थीम का इस्तेमाल करता है. टाइल के लिए, डाइनैमिक रंग वाली थीम के बजाय स्टैटिक रंग वाली थीम का इस्तेमाल करें.
  • इसमें ऐप्लिकेशन का आइकॉन शामिल है. पुष्टि करें कि आपके ऐप्लिकेशन का आइकॉन, झलक वाली इमेज में सबसे ऊपर दिख रहा है.
  • लोड की गई/लॉग-इन की गई स्थिति दिखाता है. झलक में, पूरी तरह से काम करने वाली "लोड की गई" या "लॉग-इन की गई" स्थिति दिखनी चाहिए. इसमें कोई खाली या प्लेसहोल्डर कॉन्टेंट नहीं होना चाहिए.
  • पसंद के मुताबिक बनाने के लिए, रिसॉर्स रिज़ॉल्यूशन के नियमों का फ़ायदा लें (ज़रूरी नहीं). Android के रिसॉर्स रिज़ॉल्यूशन के नियमों का इस्तेमाल करके, ऐसी झलक दिखाएं जो डिवाइस के डिसप्ले साइज़, भाषा या स्थान-भाषा की सेटिंग से मेल खाती हों. यह खास तौर पर तब काम आता है, जब आपकी टाइल अलग-अलग डिवाइसों पर अलग-अलग दिखती है.