टाइल में समय-समय पर होने वाले अपडेट दिखाएं

ऐसा कॉन्टेंट दिखाने वाली टाइलें बनाएं जो समय के साथ बदलता रहता है.

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

टाइमलाइन में एक या उससे ज़्यादा TimelineEntry इंस्टेंस होते हैं. हर इंस्टेंस में एक लेआउट होता है, जो किसी खास समयावधि के दौरान दिखता है. सभी टाइल के लिए टाइमलाइन ज़रूरी है.

एक बार इस्तेमाल होने वाली टाइल

आम तौर पर, किसी टाइल के बारे में बताने के लिए एक ही TimelineEntry काफ़ी होता है. लेआउट तय होता है और सिर्फ़ लेआउट में मौजूद जानकारी बदलती है. उदाहरण के लिए, दिन भर की फ़िटनेस की प्रोग्रेस दिखाने वाली टाइल हमेशा एक ही प्रोग्रेस लेआउट दिखाती है. हालाँकि, अलग-अलग वैल्यू दिखाने के लिए, इस लेआउट को अडजस्ट किया जा सकता है. इन मामलों में, आपको पहले से यह नहीं पता होता कि कॉन्टेंट कब बदल सकता है.

एक TimelineEntry वाले टाइल का यह उदाहरण देखें:

override fun onTileRequest(
    requestParams: RequestBuilders.TileRequest
): ListenableFuture<Tile?> {
    val tile =
        Tile.Builder()
            .setResourcesVersion(RESOURCES_VERSION)
            // We add a single timeline entry when our layout is fixed, and
            // we don't know in advance when its contents might change.
            .setTileTimeline(Timeline.fromLayoutElement(simpleLayout(this)))
            .build()
    return Futures.immediateFuture(tile)
}
Tile.kt

टाइमलाइन में तय समय के लिए की गई एंट्री

TimelineEntry के पास, वैधता की अवधि तय करने का विकल्प होता है. इससे किसी टाइल को तय समय पर अपना लेआउट बदलने की अनुमति मिलती है. इसके लिए, ऐप्लिकेशन को नई टाइल पुश करने की ज़रूरत नहीं होती.

इसका सबसे अच्छा उदाहरण, एजेंडा टाइल है. इसकी टाइमलाइन में, आने वाले इवेंट की सूची होती है. आने वाले हर इवेंट में, एक अवधि होती है. इससे यह पता चलता है कि इवेंट को कब दिखाना है.

Tiles API में, वैधता की अवधि एक-दूसरे से ओवरलैप हो सकती है. ऐसे में, जिस स्क्रीन की वैधता की अवधि सबसे कम बची है उसे दिखाया जाता है. एक बार में सिर्फ़ एक इवेंट दिखता है.

डेवलपर, डिफ़ॉल्ट फ़ॉलबैक एंट्री दे सकते हैं. उदाहरण के लिए, एजेंडा टाइल में ऐसी टाइल हो सकती है जिसकी समयसीमा कभी खत्म नहीं होती. इसका इस्तेमाल तब किया जाता है, जब टाइमलाइन की कोई अन्य एंट्री मान्य नहीं होती. इसे इस कोड सैंपल में दिखाया गया है:

override fun onTileRequest(
    requestParams: RequestBuilders.TileRequest
): ListenableFuture<Tile?> {
    val timeline = Timeline.Builder()

    // Add fallback "no meetings" entry
    // Use the version of TimelineEntry that's in androidx.wear.protolayout.
    timeline.addTimelineEntry(
        TimelineBuilders.TimelineEntry.Builder().setLayout(getNoMeetingsLayout()).build()
    )

    // Retrieve a list of scheduled meetings
    val meetings = MeetingsRepo.getMeetings()
    // Add a timeline entry for each meeting
    meetings.forEach { meeting ->
        timeline.addTimelineEntry(
            TimelineBuilders.TimelineEntry.Builder()
                .setLayout(getMeetingLayout(meeting))
                .setValidity(
                    // The tile should disappear when the meeting begins
                    // Use the version of TimeInterval that's in
                    // androidx.wear.protolayout.
                    TimelineBuilders.TimeInterval.Builder()
                        .setEndMillis(meeting.dateTimeMillis)
                        .build()
                )
                .build()
        )
    }

    val tile =
        Tile.Builder()
            .setResourcesVersion(RESOURCES_VERSION)
            .setTileTimeline(timeline.build())
            .build()
    return Futures.immediateFuture(tile)
}
Tile.kt

किसी टाइल को रीफ़्रेश करना

किसी टाइल पर दिखाई गई जानकारी कुछ समय बाद एक्सपायर हो सकती है. उदाहरण के लिए, मौसम की जानकारी देने वाली ऐसी टाइल सही नहीं है जिसमें पूरे दिन एक ही तापमान दिखाया गया हो.

डेटा के खत्म होने की समस्या से निपटने के लिए, टाइल बनाते समय डेटा अपडेट होने का इंटरवल सेट करें. इससे यह तय होता है कि टाइल कब तक मान्य रहेगी. मौसम की जानकारी देने वाली टाइल के उदाहरण में, हर घंटे इसके कॉन्टेंट को अपडेट किया जा सकता है. इसे कोड के इस सैंपल में दिखाया गया है:

override fun onTileRequest(
    requestParams: RequestBuilders.TileRequest
): ListenableFuture<Tile?> =
    Futures.immediateFuture(
        Tile.Builder()
            .setResourcesVersion(RESOURCES_VERSION)
            .setFreshnessIntervalMillis(60 * 60 * 1000) // 60 minutes
            .setTileTimeline(Timeline.fromLayoutElement(getWeatherLayout()))
            .build()
    )
Tile.kt

फ़्रेशनेस इंटरवल सेट करने पर, इंटरवल खत्म होने के कुछ समय बाद सिस्टम onTileRequest() को कॉल करता है. अगर आपने रीफ़्रेश होने का समय सेट नहीं किया है, तो सिस्टम onTileRequest() को कॉल नहीं करता है.

किसी बाहरी इवेंट की वजह से भी टाइल की समयसीमा खत्म हो सकती है. उदाहरण के लिए, कोई उपयोगकर्ता अपने कैलेंडर से किसी मीटिंग को हटा सकता है. अगर टाइल रीफ़्रेश नहीं हुई है, तो टाइल में अब भी वह मीटिंग दिखेगी जिसे मिटाया गया है. इस मामले में, अपने ऐप्लिकेशन कोड में किसी भी जगह से रीफ़्रेश करने का अनुरोध करें. इसके लिए, यहां दिए गए कोड सैंपल का इस्तेमाल करें:

fun eventDeletedCallback() {
     TileService.getUpdater(context)
             .requestUpdate(MyTileService::class.java)
}

अपडेट करने का वर्कफ़्लो चुनें

टाइल अपडेट को कॉन्फ़िगर करने का तरीका तय करने के लिए, इन सबसे सही तरीकों का इस्तेमाल करें:

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

• अगर अपडेट को उपयोगकर्ता के डिवाइस पर कम समय में कैलकुलेट किया जा सकता है, तो onTileRequest() का इस्तेमाल करें. जैसे, सूर्योदय की टाइल पर किसी इमेज की पोज़िशन अपडेट करना.

  यह खास तौर पर तब काम आता है, जब आपको सभी इमेज पहले से जनरेट करनी हों. अगर आपको आने वाले समय में कोई नई इमेज जनरेट करनी है, तो setFreshnessIntervalMillis() को कॉल करें.

• अगर आपको बैकग्राउंड में बार-बार कोई काम करना है, जैसे कि मौसम के डेटा के लिए पोलिंग, तो WorkManager का इस्तेमाल करें और अपनी टाइल पर अपडेट पुश करें.

• अगर अपडेट किसी बाहरी इवेंट की वजह से हुआ है, जैसे कि लाइटें चालू होना, ईमेल मिलना या नोट अपडेट करना, तो Firebase Cloud Messaging (FCM) मैसेज भेजकर, अपने ऐप्लिकेशन को फिर से चालू करें. इसके बाद, टाइल पर अपडेट पुश करें.

• अगर टाइल के डेटा को सिंक करने की प्रोसेस महंगी हो सकती है, तो यह तरीका अपनाएं:

  1. डेटा सिंक करने का समय शेड्यूल करना.
  2. एक से दो सेकंड के लिए टाइमर शुरू करें.
  3. अगर आपको रिमोट डेटा सोर्स से समयसीमा खत्म होने से पहले अपडेट मिलता है, तो डेटा सिंक से अपडेट की गई वैल्यू दिखाएं. ऐसा न होने पर, कैश की गई स्थानीय वैल्यू दिखाएं.