heyalex / widgetupdatehelper Goto Github PK

class SmallWidgetUpdater : WidgetUpdater() {
    override fun update(context: Context, dataBundle: Bundle?, vararg ids: Int) {
        //This callback will be running on background thread
        val appWidgetManager = AppWidgetManager.getInstance(context)
        var weatherData: WeatherMapper? = null
        try {
            //DB or Internet requests
//            Thread.sleep(10000)
            getWeather(context, getCity(context), getUnit(context))
            weatherData = WeatherMapper.fromJson(getWeatherData(context))
        } catch (e: InterruptedException) {
            e.printStackTrace()
        }

        val pendingIntent: PendingIntent = Intent(context, MainActivity::class.java)
                .let { intent ->
                    PendingIntent.getActivity(context, 0, intent, 0)
                }

        //make RemoteViews depends on dataBundle and update by widget ID
        val remoteViews = RemoteViews(context.packageName, R.layout.current_weather).apply {}
        remoteViews.setOnClickPendingIntent(R.id.city, pendingIntent)
        if (weatherData?.weather != null){
            remoteViews.setTextViewText(R.id.condition, weatherData.weather!![0].description)
            remoteViews.setImageViewResource(R.id.icon, context.resources.getIdentifier("ic_" + weatherData.weather!![0].icon, "drawable", context.packageName))
            remoteViews.setTextViewText(R.id.city, weatherData.name)
            remoteViews.setTextViewText(R.id.temperature, weatherData.main?.temp.toString().substringBefore(".") + getUnitString(context))
        }
        for (widgetId in ids) {
            appWidgetManager.updateAppWidget(widgetId, remoteViews)
        }
    }

    @RequiresApi(Build.VERSION_CODES.O)
    override fun makeNotification(context: Context): Notification {
        val notifChannelID = "widget_updater"
        val channelName = "widget updating"
        val chan = NotificationChannel(notifChannelID, channelName, NotificationManager.IMPORTANCE_NONE)
        val manager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
        manager.createNotificationChannel(chan)

        val notificationBuilder = Notification.Builder(context, notifChannelID)
        return notificationBuilder.build()
    }

    companion object {

        private fun getCity(context: Context): String {
            val prefs: Prefs?
            prefs = Prefs(context)
            return prefs.city!!
        }

        private fun getWeatherData(context: Context): String {
            val prefs: Prefs?
            prefs = Prefs(context)
            return prefs.currentWeather!!
        }

        private fun getLat(context: Context): Double {
            val prefs: Prefs?
            prefs = Prefs(context)
            return prefs.lat
        }

        private fun getLon(context: Context): Double {
            val prefs: Prefs?
            prefs = Prefs(context)
            return prefs.lon
        }

        private fun getUnitString(context: Context): String {
            val prefs: Prefs?
            prefs = Prefs(context)
            val unit = prefs.unit
            val unitString: String
            unitString = when (unit) {
                0.toLong() -> {
                    "°C"
                }
                1.toLong() -> {
                    "°F"
                }
                else -> {
                    "K"
                }
            }
            return unitString
        }

        private fun getUnit(context: Context): String {
            val prefs: Prefs?
            prefs = Prefs(context)
            val unit = prefs.unit
            val unitString: String
            unitString = when (unit) {
                0.toLong() -> {
                    "/metric"
                }
                1.toLong() -> {
                    "/imperial"
                }
                else -> {
                    ""
                }
            }
            return unitString
        }

        private fun getWeather(context: Context, city: String, unitString: String) {

            val url: URL = if (getCity(context) != "") {
                URL("...")
            } else {
                URL("...")
            }
            val client = OkHttpClient()
            val request = Request.Builder()
                    .url(url)
                    .get()
                    .build()
            client.newCall(request).enqueue(object : Callback {
                override fun onFailure(call: Call, e: IOException) {
                    e.printStackTrace()
                }

                override fun onResponse(call: Call, response: Response) {
                    response.use {
                        if (!response.isSuccessful) throw IOException("Unexpected code $response")

                        val responseBody = response.body
                        val content = responseBody!!.string()

                        val prefs: Prefs?
                        prefs = Prefs(context)
                        println("content")
                        println(content)
                        prefs.currentWeather = content
                    }
                }
            })
        }
    }
}

@RemoteViewsUpdater(SmallWidgetUpdater::class)
class SmallWidgetProvider : AppWidgetProvider() {

    override fun onReceive(context: Context?, intent: Intent?) {
        println("updateWidgets onReceive")
        super.onReceive(context, intent)
        val appWidgetManager = AppWidgetManager.getInstance(context)
        val widgetIds = appWidgetManager.getAppWidgetIds(
                context?.let { ComponentName(it, SmallWidgetProvider::class.java) })
        // update widgets
        for (widgetId in widgetIds) {
            WidgetUpdateService.updateWidgets(context, this, null, widgetId)
        }
    }

    override fun onUpdate(context: Context, appWidgetManager: AppWidgetManager, appWidgetIds: IntArray) {
        println("updateWidgets onUpdate")
        // trigger you WidgetUpdater by this call
        for (widgetId in appWidgetIds) {
            WidgetUpdateService.updateWidgets(context, this, null, widgetId)
        }
    }

    override fun onEnabled(context: Context) {
        println("updateWidgets onEnabled")
        val appWidgetManager = AppWidgetManager.getInstance(context)
        val widgetIds = appWidgetManager.getAppWidgetIds(
                ComponentName(context, SmallWidgetProvider::class.java))
        // update widgets
        for (widgetId in widgetIds) {
            WidgetUpdateService.updateWidgets(context, this, null, widgetId)
        }
    }

    override fun onDisabled(context: Context) {
        println("updateWidgets onDisabled")
    }
}

<receiver android:name=".SmallWidgetProvider">
            <intent-filter>
                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
            </intent-filter>

            <meta-data
                android:name="android.appwidget.provider"
                android:resource="@xml/current_weather_info" />
</receiver>

<?xml version="1.0" encoding="utf-8"?>
<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
    android:initialKeyguardLayout="@layout/current_weather"
    android:initialLayout="@layout/current_weather"
    android:minHeight="110dp"
    android:minResizeHeight="40dp"
    android:minWidth="110dp"
    android:minResizeWidth="40dp"
    android:previewImage="@drawable/current_preview"
    android:resizeMode="horizontal|vertical"
    android:updatePeriodMillis="1800000"
    android:widgetCategory="home_screen" />