Android पर विजेट। पता लगाने के लिए एक दुर्लभ सुविधा

विजेट निर्माण

1. विजेट घटकों की विशेषताएं।
2. स्क्रीन ग्रिड में विजेट प्रदर्शित करने की सुविधाएँ।
3. विजेट अद्यतन सुविधाएँ।

विजेट घटकों की विशेषताएं

स्क्रीन के "ग्रिड" में विजेट प्रदर्शित करने की विशेषताएं

प्रत्येक विजेट को न्यूनतम और न्यूनतम ऊंचाई को परिभाषित करना चाहिए, जो कि डिफ़ॉल्ट रूप से उपभोग की जाने वाली न्यूनतम मात्रा को दर्शाता है। जब उपयोगकर्ता अपनी होम स्क्रीन पर एक विजेट जोड़ते हैं, तो यह आम तौर पर आपके द्वारा निर्दिष्ट न्यूनतम चौड़ाई और ऊंचाई से अधिक पर कब्जा करेगा। एंड्रॉइड होम स्क्रीन उपयोगकर्ताओं को उपलब्ध रिक्त स्थान का एक ग्रिड प्रदान करते हैं जिसमें वे विजेट और आइकन रख सकते हैं। यह ग्रिड एक उपकरण द्वारा भिन्न हो सकता है; उदाहरण के लिए, कई हैंडसेट 4x4 ग्रिड की पेशकश करते हैं, और टैबलेट एक बड़ी, 8x7 ग्रिड की पेशकश कर सकते हैं।

विजेट अद्यतन सुविधाएँ

विजेट मामला

• अधिकृत उपयोगकर्ता के लिए
• एक अनधिकृत उपयोगकर्ता के लिए

override fun onUpdate(
        context: Context,
        appWidgetManager: AppWidgetManager,
        appWidgetIds: IntArray
    ) {
        injector.openScope(this, *arrayOf(this))
        // update each of the widgets with the remote adapter
        appWidgetIds
            .forEach {
                updateWidget(context, appWidgetManager, it)
          }
    }

private fun updateWidget(
        context: Context,
        appWidgetManager: AppWidgetManager,
        appWidgetId: Int
    ) {
// remoteViews   widgetId
        val remoteViews = RemoteViews(
            context.packageName,
            R.layout.app_widget_layout
...
//        
...
//    remoteViews
updateRemoteAdapter(context, remoteViews, appWidgetId)
 
//   remoteViews 
appWidgetManager.updateAppWidget(appWidgetId, remoteViews)
// collection view  
appWidgetManager.notifyAppWidgetViewDataChanged(
            appWidgetId,
            R.id.lvWidgetItems
        )
    }

private fun updateRemoteAdapter(context: Context, remoteViews: RemoteViews, appWidgetId: Int) {
//   RemoteViewsService   RemoteAdapter   
        val adapterIntent = Intent(context, StolotoAppWidgetRemoteViewsService::class.java).apply {
            putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId)
        }
        remoteViews.setRemoteAdapter(R.id.lvWidgetItems, adapterIntent)
// actionIntent  pendingIntent      
        val actionIntent = Intent(context, StolotoAppWidgetProvider::class.java).apply {
            action = WIDGET_CLICK_ACTION
            putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId)
        }
        val pendingIntent = PendingIntent.getBroadcast(
            context, 0, actionIntent,
            PendingIntent.FLAG_UPDATE_CURRENT
        )
// pendingIntent      
        remoteViews.setPendingIntentTemplate(R.id.lvWidgetItems, pendingIntent)
    }

class StolotoAppWidgetRemoteViewsService : RemoteViewsService() {
    override fun onGetViewFactory(intent: Intent): RemoteViewsFactory =
        StolotoAppWidgetRemoteViewsFactory(
            this.applicationContext,
            intent
        )
}

1. onCreate - एडॉप्टर बनाना।
2. getLoadingView - विधि व्यू को वापस भेजने का सुझाव देती है, जिसे सिस्टम सूची आइटम के बजाय प्रदर्शित करेगा जबकि वे बनाए जा रहे हैं। यदि आप यहां कुछ भी नहीं बनाते हैं, तो सिस्टम कुछ डिफ़ॉल्ट दृश्य का उपयोग करता है।
3. getViewAt - विधि सूची आइटम बनाने का सुझाव देती है। यहाँ RemoteViews का मानक उपयोग आता है।
4. जब सूची में डेटा को अपडेट करने के लिए अनुरोध प्राप्त होता है, तो onDataSetChanged को कहा जाता है। उन। इस पद्धति में, हम सूची के लिए डेटा तैयार करते हैं। विधि को भारी, लंबे कोड के निष्पादन से तेज किया जाता है।
5. onDestroy को तब कहा जाता है जब अंतिम सूची जो कि उपयोग किए गए एडाप्टर को हटा दी जाती है (एक एडाप्टर को कई सूचियों द्वारा उपयोग किया जा सकता है)।
6. RemoteViewsFactory रहता है जबकि सूची के सभी उदाहरण जीवित हैं, इसलिए हम इसमें वर्तमान डेटा संग्रहीत कर सकते हैं, उदाहरण के लिए, वर्तमान आइटमों की सूची।

private val widgetItems = ArrayList<WidgetItem>()

override fun onCreate() {
        updateDataSync()
}

   override fun onDataSetChanged() {
        updateDataSync()
    }

 private fun updateDataSync() {
        widgetItems.clear()
        updateProfileSync()
        updateGamesSync()
    }

private fun updateProfileSync() {

val isUserFullAuth = isUserFullAuthInteractor
            .execute()
            .blockingGet()
        if (isUserFullAuth) {
            val profile = getWidgetProfileInteractor
                .execute()
                .onErrorReturn {
                    WidgetProfile()
//           
                }
                .blockingGet()

  if (profile.walletAmount >= 0L) {
                widgetItems.add(
                    WidgetItem.Profile(
                        wallet = profile.walletAmount.toMoneyFormat(),
                        waitingTickets = if (profile.waitingTicketsCount >= 0) profile.waitingTicketsCount.toString() else "",
                        unpaidPrizeAmount = if (profile.unpaidPrizeAmount >= 0) profile.unpaidPrizeAmoount.toMoneyFormat() else ""
                    )
                )
            }
        }
    }

sealed class WidgetItem {
 
    data class Profile(
        val wallet: String,
        val waitingTickets: String,
        val unpaidPrizeAmount: String
    ) : WidgetItem()
 
    data class Game(
        val id: String,
        val iconId: Int,
        val prizeValue: String,
        val date: String
    ) : WidgetItem()
}

override fun getViewAt(position: Int): RemoteViews {
        return when (val item = widgetItems[position]) {
            is WidgetItem.Profile -> {
              RemoteViews(
                        context.packageName,
                        R.layout.item_widget_user_profile
                    ).apply {
                        setTextViewText(R.id.tvWidgetWalletMoney, item.wallet)
                        setTextViewText(R.id.tvWidgetUnpaidCount, item.unpaidPrizeAmount)
                        setTextViewText(R.id.tvWidgetWaitingCount, item.waitingTickets)
                        setOnClickFillInIntent(
                            R.id.llWidgetProfileWallet, Intent().putExtra(
                                StolotoAppWidgetProvider.KEY_PROFILE_OPTIONS,
                                StolotoAppWidgetProvider.VALUE_USER_WALLET
                            )
                        )
                        setOnClickFillInIntent(
                            R.id.llWidgetProfileUnpaid, Intent().putExtra(
                                StolotoAppWidgetProvider.KEY_PROFILE_OPTIONS,
                                StolotoAppWidgetProvider.VALUE_UNPAID_PRIZE
                            )
                        )
                        setOnClickFillInIntent(
                            R.id.llWidgetProfileWaiting, Intent().putExtra(
                                StolotoAppWidgetProvider.KEY_PROFILE_OPTIONS,
                                StolotoAppWidgetProvider.VALUE_WAITING_TICKETS
                            )
                        )
                    }
 
            is WidgetItem.Game -> {
                RemoteViews(
                    context.packageName,
                    R.layout.item_widget_game
                ).apply {
                    setImageViewResource(R.id.ivWidgetGame, item.iconId)
                    setTextViewText(R.id.tvWidgetGamePrize, item.prizeValue)
                    setTextViewText(R.id.tvWidgetGameDate, item.date)
                    setOnClickFillInIntent(
                        R.id.llWidgetGame, Intent().putExtra(
                            StolotoAppWidgetProvider.KEY_GAME_CLICK, item.id
                        )
                    )
                }
            }
        }
    }

मैनुअल विजेट अद्यतन

...
// Intent   AppWidgetManager.ACTION_APPWIDGET_UPDATE
val intentUpdate = Intent(context, StolotoAppWidgetProvider::class.java)
intentUpdate.action = AppWidgetManager.ACTION_APPWIDGET_UPDATE

//    
val ids = AppWidgetManager.getInstance(context)
   .getAppWidgetIds(ComponentName(context, StolotoAppWidgetProvider::class.java))
intentUpdate.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, ids)

//  intent  PendingIntent,  PendingIntent.getBroadcast()
val pendingUpdate = PendingIntent.getBroadcast(
   context,
   appWidgetId,
   intentUpdate,
   PendingIntent.FLAG_UPDATE_CURRENT
)
//  pendingIntent      ‘’
remoteViews.setOnClickPendingIntent(R.id.ivWidgetRefresh, pendingUpdate)
…

1. OnReceive प्रदाता 'कार्रवाई' में आशय प्राप्त करें।
2. AppWidgetManager.ACTION_APPWIDGET_UPDATE।
3. इरादे-ई में निर्दिष्ट सभी widgetsIds के लिए onUpdate पर कॉल करें।
4. नए डेटा के लिए ऑनलाइन जाएं।
5. स्थानीय डेटा ताज़ा करें और नए सूची कार्ड प्रदर्शित करें।

enum class LoadingStep {
   START,
   MIDDLE,
   END
}

if (isFullAuthorized && !widgetLoadingStateInteractor.isWidgetLoading) {
   remoteViews.setViewVisibility(R.id.ivWidgetRefresh, View.VISIBLE)
...
//     ,    
...   
} else {
   remoteViews.setViewVisibility(
       R.id.ivWidgetRefresh,
       if (isFullAuthorized) View.INVISIBLE else View.GONE //       .
   )
}

private fun updateDataSync() {
   when (loadingStep) {
       START -> {
           widgetItems.forEach { it.isLoading = true }
           widgetLoadingStateInteractor.isWidgetLoading = true
           loadingStep = MIDDLE
           widgetManager.updateWidgets()
       }
       MIDDLE -> {
           widgetItems.clear()
           updateProfileSync()
           updateGamesSync()
           widgetLoadingStateInteractor.isWidgetLoading = false
           loadingStep = END
           widgetManager.updateWidgets()
       }
       END -> {
           loadingStep = START
       }
   }
}

1. START और MIDDLE चरणों के अंत में, मैं प्रदाता द्वारा प्रबंधित दृश्य स्थिति को अपडेट करने के लिए updateWidgets विधि को कॉल करता हूं।
2. START «» , MIDDLE.
3. MIDDLE, «».
4. MIDDLE, END.
5. , END, «». , END loadingStep START.