Moving to version 2.0

app/src/main/java/com/tommasoberlose/anotherwidget/utils/CalendarUtil.kt

@@ -0,0 +1,186 @@
+package com.tommasoberlose.anotherwidget.utils
+
+import android.Manifest
+import android.content.ContentUris
+import android.content.Context
+import android.provider.CalendarContract
+import android.util.Log
+import com.chibatching.kotpref.blockingBulk
+import com.chibatching.kotpref.bulk
+import com.tommasoberlose.anotherwidget.components.events.Event
+import com.tommasoberlose.anotherwidget.global.Preferences
+import com.tommasoberlose.anotherwidget.receivers.UpdatesReceiver
+import io.realm.Realm
+import io.realm.RealmResults
+import me.everything.providers.android.calendar.CalendarProvider
+import java.util.*
+import kotlin.Comparator
+import kotlin.collections.ArrayList
+
+/**
+ * Created by tommaso on 08/10/17.
+ */
+
+object CalendarUtil {
+
+    fun updateEventList(context: Context) {
+        if (Preferences.showEvents) {
+            val eventList = ArrayList<Event>()
+
+            val now = Calendar.getInstance()
+            val limit = Calendar.getInstance()
+            when (Preferences.showUntil) {
+                0 -> limit.add(Calendar.HOUR, 3)
+                1 -> limit.add(Calendar.HOUR, 6)
+                2 -> limit.add(Calendar.HOUR, 12)
+                3 -> limit.add(Calendar.DAY_OF_MONTH, 1)
+                4 -> limit.add(Calendar.DAY_OF_MONTH, 3)
+                5 -> limit.add(Calendar.DAY_OF_MONTH, 7)
+                6 -> limit.add(Calendar.MINUTE, 30)
+                7 -> limit.add(Calendar.HOUR, 1)
+                else -> limit.add(Calendar.HOUR, 6)
+            }
+
+            val builder = CalendarContract.Instances.CONTENT_URI.buildUpon()
+            ContentUris.appendId(builder, now.timeInMillis)
+            ContentUris.appendId(builder, limit.timeInMillis)
+
+            if (!Util.checkGrantedPermission(context, Manifest.permission.READ_CALENDAR)) {
+                resetNextEventData(context)
+            } else {
+                val provider = CalendarProvider(context)
+                val data = provider.getInstances(now.timeInMillis, limit.timeInMillis)
+                if (data != null) {
+                    val instances = data.list
+                    for (instance in instances) {
+                        try {
+                            val e = provider.getEvent(instance.eventId)
+                            if (e != null && instance.begin <= limit.timeInMillis && (Preferences.calendarAllDay || !e.allDay) && !(Preferences.calendarFilter.contains(" " + e.calendarId + ",")) && (Preferences.showDeclinedEvents || e.selfAttendeeStatus.toInt() != CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED)) {
+                                if (e.allDay) {
+                                    val start = Calendar.getInstance()
+                                    start.timeInMillis = instance.begin
+                                    val end = Calendar.getInstance()
+                                    end.timeInMillis = instance.end
+                                    instance.begin = start.timeInMillis - start.timeZone.getOffset(start.timeInMillis)
+                                    instance.end = end.timeInMillis - end.timeZone.getOffset(end.timeInMillis)
+                                }
+                                eventList.add(Event(instance.id, e.id, e.title ?: "", instance.begin, instance.end, e.calendarId.toInt(), e.allDay, e.eventLocation ?: ""))
+                            }
+                        } catch (ignored: Exception) {}
+                    }
+                }
+
+                if (eventList.isEmpty()) {
+                    resetNextEventData(context)
+                } else {
+                    eventList.sortWith(Comparator { event: Event, event1: Event ->
+                        if (event.allDay && event1.allDay) {
+                            event.startDate.compareTo(event1.startDate)
+                        } else if (event.allDay) {
+                            1
+                        } else if (event1.allDay) {
+                            -1
+                        } else {
+                            event1.startDate.compareTo(event.startDate)
+                        }
+                    })
+                    eventList.reverse()
+                    saveEvents(eventList)
+                    saveNextEventData(context, eventList[0])
+                }
+            }
+        } else {
+            resetNextEventData(context)
+        }
+
+        UpdatesReceiver.setUpdates(context)
+        Util.updateWidget(context)
+    }
+
+    fun getCalendarList(context: Context): List<me.everything.providers.android.calendar.Calendar> {
+        val calendarList = ArrayList<me.everything.providers.android.calendar.Calendar>()
+
+        if (!Util.checkGrantedPermission(context, Manifest.permission.READ_CALENDAR)) {
+            return calendarList
+        }
+        val provider = CalendarProvider(context)
+        val data = provider.calendars
+        return if (data != null) {
+            data.list
+        } else {
+            calendarList
+        }
+    }
+
+    private fun saveEvents(eventList: ArrayList<Event>) {
+        Realm.getDefaultInstance().executeTransactionAsync { realm ->
+            realm.where(Event::class.java).findAll().deleteAllFromRealm()
+            realm.copyToRealm(eventList)
+        }
+    }
+
+    private fun resetNextEventData(context: Context) {
+        Realm.getDefaultInstance().executeTransactionAsync {
+            it.where(Event::class.java).findAll().deleteAllFromRealm()
+        }
+
+        Preferences.bulk {
+            remove(Preferences::nextEventId)
+            remove(Preferences::nextEventName)
+            remove(Preferences::nextEventStartDate)
+            remove(Preferences::nextEventAllDay)
+            remove(Preferences::nextEventLocation)
+            remove(Preferences::nextEventEndDate)
+            remove(Preferences::nextEventCalendarId)
+        }
+
+        Util.updateWidget(context)
+    }
+
+    private fun saveNextEventData(context: Context, event: Event) {
+        Preferences.nextEventId = event.id
+        Util.updateWidget(context)
+    }
+
+    fun getNextEvent(): Event? {
+        val realm = Realm.getDefaultInstance()
+        return realm.where(Event::class.java).equalTo("id", Preferences.nextEventId).findFirst() ?: realm.where(Event::class.java).findFirst()
+    }
+
+    fun goToNextEvent(context: Context) {
+        val eventList = Realm.getDefaultInstance().where(Event::class.java).findAll()
+
+        if (eventList.isNotEmpty()) {
+            val index = eventList.indexOfFirst { it.id == Preferences.nextEventId }
+            if (index > -1 && index < eventList.size - 1) {
+                Preferences.nextEventId = eventList[index + 1]!!.id
+            } else {
+                Preferences.nextEventId = eventList.first()!!.id
+            }
+        } else {
+            resetNextEventData(context)
+        }
+        UpdatesReceiver.setUpdates(context)
+        Util.updateWidget(context)
+    }
+
+    fun goToPreviousEvent(context: Context) {
+        val eventList = Realm.getDefaultInstance().where(Event::class.java).findAll()
+
+        if (eventList.isNotEmpty()) {
+            val index = eventList.indexOfFirst { it.id == Preferences.nextEventId }
+            if (index > 0) {
+                Preferences.nextEventId = eventList[index - 1]!!.id
+            } else {
+                Preferences.nextEventId = eventList.last()!!.id
+            }
+        } else {
+            resetNextEventData(context)
+        }
+        UpdatesReceiver.setUpdates(context)
+        Util.updateWidget(context)
+    }
+
+    fun getEvents(): RealmResults<Event> = Realm.getDefaultInstance().where(Event::class.java).findAll()
+    fun getEventsCount(): Int = Realm.getDefaultInstance().where(Event::class.java).findAll().size
+}

app/src/main/java/com/tommasoberlose/anotherwidget/utils/Extensions.kt

@@ -0,0 +1,130 @@
+package com.tommasoberlose.anotherwidget.utils
+
+import android.content.pm.PackageManager
+import android.view.Gravity
+import android.view.View
+import android.view.ViewAnimationUtils
+import android.widget.Toast
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.app.Activity
+import android.content.*
+import android.net.Uri
+import androidx.browser.customtabs.CustomTabsIntent
+import androidx.core.content.ContextCompat
+import android.content.res.Configuration
+import android.provider.Settings
+import android.util.Patterns
+import java.security.NoSuchAlgorithmException
+import kotlin.math.max
+import android.content.Intent
+import android.util.TypedValue
+import com.tommasoberlose.anotherwidget.R
+
+
+fun PackageManager.missingSystemFeature(name: String): Boolean = !hasSystemFeature(name)
+
+fun Context.toast(message: String) {
+    val toast = Toast.makeText(this, message, Toast.LENGTH_SHORT)
+//    toast.setGravity(Gravity.CENTER, 0, 0)
+    toast.show()
+}
+
+fun Int.toPixel(context: Context): Int = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, this.toFloat(), context.resources.displayMetrics).toInt()
+fun Float.toPixel(context: Context): Float = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, this, context.resources.displayMetrics)
+
+fun View.reveal(initialX: Int, initialY: Int) {
+    when (visibility) {
+        View.VISIBLE -> {
+            val anim = ViewAnimationUtils.createCircularReveal(this, initialX, initialY, max(width.toFloat(), height.toFloat()), 0f)
+                .apply {
+                    duration = 200
+                }
+            anim.addListener(object : AnimatorListenerAdapter() {
+                override fun onAnimationEnd(animation: Animator) {
+                    visibility = View.GONE
+                    super.onAnimationEnd(animation)
+                }
+            })
+            anim.start()
+        } else -> {
+            val anim = ViewAnimationUtils.createCircularReveal(this, initialX, initialY, 0f, max(width.toFloat(), height.toFloat()))
+                .apply {
+                    duration = 200
+                }
+            visibility = View.VISIBLE
+            anim.start()
+        }
+    }
+}
+
+fun Context.openURI(url: String) {
+    try {
+        val builder: CustomTabsIntent.Builder = CustomTabsIntent.Builder()
+        builder.setToolbarColor(ContextCompat.getColor(this, R.color.colorPrimary))
+        val customTabsIntent: CustomTabsIntent = builder.build()
+        customTabsIntent.launchUrl(this, Uri.parse(url))
+    } catch (e: Exception) {
+        try {
+            val openIntent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
+            startActivity(openIntent)
+        } catch (ignored: Exception) {
+            val clipboard: ClipboardManager = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+            val clip = ClipData.newPlainText(getString(R.string.app_name), url)
+            clipboard.setPrimaryClip(clip)
+            Toast.makeText(this, R.string.error_opening_uri, Toast.LENGTH_LONG).show()
+        }
+    }
+}
+
+fun Context.isTablet(): Boolean {
+    return (resources.configuration.screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK) >= Configuration.SCREENLAYOUT_SIZE_LARGE
+}
+
+fun String.md5(): String {
+    val MD5 = "MD5"
+    try {
+        // Create MD5 Hash
+        val digest = java.security.MessageDigest
+            .getInstance(MD5)
+        digest.update(toByteArray())
+        val messageDigest = digest.digest()
+
+        // Create Hex String
+        val hexString = StringBuilder()
+        for (aMessageDigest in messageDigest) {
+            var h = Integer.toHexString(0xFF and aMessageDigest.toInt())
+            while (h.length < 2)
+                h = "0$h"
+            hexString.append(h)
+        }
+        return hexString.toString()
+
+    } catch (e: NoSuchAlgorithmException) {
+        e.printStackTrace()
+    }
+
+    return ""
+}
+
+fun String.isValidEmail(): Boolean
+        = this.isNotEmpty() &&
+        Patterns.EMAIL_ADDRESS.matcher(this).matches()
+
+fun Activity.isDarkTheme(): Boolean {
+    return resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES
+}
+
+fun Activity.isNotificationAccessGranted(): Boolean = Settings.Secure.getString(this.contentResolver,"enabled_notification_listeners").contains(this.packageName)
+
+//fun Activity.sendEmailTo(email: String) {
+//    val i = Intent(Intent.ACTION_VIEW).apply {
+//        data = Uri.parse("mailto:$email")
+//    }
+//    try {
+//        startActivity(Intent.createChooser(i, getString(R.string.settings_title_feedback)))
+//    } catch (ex: java.lang.Exception) {
+//        toast(getString(R.string.generic_error))
+//    }
+//
+//}

app/src/main/java/com/tommasoberlose/anotherwidget/utils/Util.kt

@@ -0,0 +1,521 @@
+package com.tommasoberlose.anotherwidget.utils
+
+import android.app.*
+import android.appwidget.AppWidgetManager
+import android.content.*
+import android.content.pm.PackageManager
+import android.content.res.Resources
+import android.graphics.*
+import android.graphics.drawable.Drawable
+import android.net.Uri
+import android.util.DisplayMetrics
+import com.tommasoberlose.anotherwidget.R
+
+import android.graphics.Bitmap
+import android.graphics.drawable.BitmapDrawable
+import android.util.TypedValue
+import android.content.Intent
+import android.content.ComponentName
+import android.provider.AlarmClock
+import android.provider.CalendarContract
+import android.text.format.DateFormat
+import android.text.format.DateUtils
+import android.util.Log
+import android.view.View
+import android.view.animation.Animation
+import android.view.animation.Transformation
+import android.widget.LinearLayout
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.drawable.DrawableCompat
+import com.tommasoberlose.anotherwidget.components.events.Event
+import com.tommasoberlose.anotherwidget.global.Actions
+import com.tommasoberlose.anotherwidget.global.Constants
+import com.tommasoberlose.anotherwidget.global.Preferences
+import com.tommasoberlose.anotherwidget.ui.widgets.TheWidget
+import org.joda.time.DateTime
+import java.text.SimpleDateFormat
+import java.util.*
+import java.util.concurrent.TimeUnit
+
+
+/**
+ * Created by tommaso on 05/10/17.
+ */
+
+object Util {
+
+    fun checkGrantedPermission(context: Context, permission: String): Boolean {
+        return ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
+    }
+
+    fun updateWidget(context: Context) {
+        val widgetManager = AppWidgetManager.getInstance(context)
+        val widgetComponent = ComponentName(context, TheWidget::class.java)
+        val widgetIds = widgetManager.getAppWidgetIds(widgetComponent)
+        val update = Intent(context, TheWidget::class.java)
+        update.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, widgetIds)
+        update.action = AppWidgetManager.ACTION_APPWIDGET_UPDATE
+        context.sendBroadcast(update)
+    }
+
+    fun showWeatherErrorNotification(context: Context) {
+        TODO("weather notification")
+//        val mNotificationManager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+//        val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+//        val SP = PreferenceManager.getDefaultSharedPreferences(context)
+//
+//        if (SP.getBoolean(Constants.PREF_SHOW_GPS_NOTIFICATION, true) && !locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER) && SP.getInt(Constants.PREF_WEATHER_PROVIDER, Constants.WEATHER_PROVIDER_GOOGLE_AWARENESS) == Constants.WEATHER_PROVIDER_GOOGLE_AWARENESS) {
+//            val settingsIntent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)
+//            val pi: PendingIntent = PendingIntent.getActivity(context, 50, settingsIntent, PendingIntent.FLAG_UPDATE_CURRENT)
+//
+//            val providerIntent2 = Intent(context, MainActivity::class.java)
+//            providerIntent2.flags = Intent.FLAG_ACTIVITY_NEW_TASK
+//            providerIntent2.putExtra(Constants.ACTION_EXTRA_OPEN_WEATHER_PROVIDER, true)
+//            val pi2: PendingIntent = PendingIntent.getActivity(context, 51, providerIntent2, PendingIntent.FLAG_UPDATE_CURRENT)
+//
+//            val providerIntentDisable = Intent(context, MainActivity::class.java)
+//            providerIntentDisable.flags = Intent.FLAG_ACTIVITY_NEW_TASK
+//            providerIntentDisable.putExtra(Constants.ACTION_EXTRA_DISABLE_GPS_NOTIFICATION, true)
+//            val piDisable: PendingIntent = PendingIntent.getActivity(context, 52, providerIntentDisable, PendingIntent.FLAG_UPDATE_CURRENT)
+//
+//            val mBuilder: NotificationCompat.Builder = NotificationCompat.Builder(context, "Error")
+//                    .setSmallIcon(R.drawable.ic_stat_name)
+//                    .setColor(ContextCompat.getColor(context, R.color.colorPrimary))
+//                    .setContentTitle(context.getString(R.string.notification_gps_title))
+//                    .setContentText(context.getString(R.string.notification_gps_subtitle))
+//                    .addAction(R.drawable.ic_action_sync, context.getString(R.string.change_provider), pi2)
+//                    .addAction(R.drawable.ic_action_settings, context.getString(R.string.disable_notification), piDisable)
+//                    .setContentIntent(pi)
+//
+//            mNotificationManager.notify(10, mBuilder.build());
+//        } else {
+//            mNotificationManager.cancel(10)
+//        }
+    }
+
+    fun getGoogleMapsIntentFromAddress(context: Context, address:String): Intent {
+        val gmmIntentUri: Uri = Uri.parse("geo:0,0?q=$address")
+        val mapIntent = Intent(Intent.ACTION_VIEW, gmmIntentUri)
+        mapIntent.`package` = "com.google.android.apps.maps"
+
+        return if (mapIntent.resolveActivity(context.packageManager) != null) {
+            mapIntent
+        } else {
+            val map = "http://maps.google.co.in/maps?q=$address"
+            val i = Intent(Intent.ACTION_VIEW, Uri.parse(map));
+            i
+        }
+    }
+
+    fun getCurrentWallpaper(context: Context): Drawable? = try {
+        WallpaperManager.getInstance(context).drawable
+    } catch (e: Exception) {
+//        BitmapDrawable(context.resources, getResizedBitmap(BitmapFactory.decodeResource(context.resources, R.drawable.pixel_2_wallpaper), 800))
+        null
+    }
+
+    fun getBitmapFromView(view: View): Bitmap {
+        //Define a bitmap with the same size as the view
+        val measuredWidth = View.MeasureSpec.makeMeasureSpec(view.width, View.MeasureSpec.UNSPECIFIED)
+        val measuredHeight = View.MeasureSpec.makeMeasureSpec(view.height, View.MeasureSpec.UNSPECIFIED)
+        view.measure(measuredWidth, measuredHeight)
+        view.layout(0,0, measuredWidth, measuredHeight)
+        val returnedBitmap = Bitmap.createBitmap(view.measuredWidth, view.measuredHeight, Bitmap.Config.ARGB_8888)
+        //Bind a canvas to it
+        val canvas = Canvas(returnedBitmap)
+        // draw the view on the canvas
+        view.draw(canvas)
+        //return the bitmap
+        return returnedBitmap
+    }
+
+    fun getBitmapFromView(view: View, w: Int, h: Int): Bitmap {
+        //Define a bitmap with the same size as the view
+        val measuredWidth = View.MeasureSpec.makeMeasureSpec(w, View.MeasureSpec.EXACTLY)
+        val measuredHeight = View.MeasureSpec.makeMeasureSpec(h, View.MeasureSpec.EXACTLY)
+        view.measure(measuredWidth, measuredHeight)
+        view.layout(0,0, measuredWidth, measuredHeight)
+        val returnedBitmap = Bitmap.createBitmap(view.measuredWidth, view.measuredHeight, Bitmap.Config.ARGB_8888)
+        //Bind a canvas to it
+        val canvas = Canvas(returnedBitmap)
+        // draw the view on the canvas
+        view.draw(canvas)
+        //return the bitmap
+        return returnedBitmap
+    }
+
+    fun convertDpToPixel(dp: Float, context: Context): Float {
+        val resources: Resources = context.resources
+        val metrics: DisplayMetrics = resources.displayMetrics
+        val px: Float = dp * (metrics.densityDpi / DisplayMetrics.DENSITY_DEFAULT)
+        return px
+    }
+
+    fun convertSpToPixels(sp: Float, context: Context): Float {
+        return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, sp, context.resources.displayMetrics)
+    }
+
+    fun getResizedBitmap(image: Bitmap, maxSize: Int): Bitmap {
+        var width = image.width
+        var height = image.height
+
+        val bitmapRatio = width.toFloat() / height.toFloat()
+        if (bitmapRatio > 1) {
+            width = maxSize
+            height = (width / bitmapRatio).toInt()
+        } else {
+            height = maxSize
+            width = (height * bitmapRatio).toInt()
+        }
+
+        return Bitmap.createScaledBitmap(image, width, height, true)
+    }
+
+    fun getRefreshPeriodString(period: Int): Int {
+        return when (period) {
+            0 -> R.string.settings_weather_refresh_period_subtitle_0
+            1 -> R.string.settings_weather_refresh_period_subtitle_1
+            2 -> R.string.settings_weather_refresh_period_subtitle_2
+            3 -> R.string.settings_weather_refresh_period_subtitle_3
+            4 -> R.string.settings_weather_refresh_period_subtitle_4
+            5 -> R.string.settings_weather_refresh_period_subtitle_5
+            else -> R.string.settings_weather_refresh_period_subtitle_0
+        }
+    }
+
+    fun getShowUntilString(period: Int): Int {
+        return when (period) {
+            0 -> R.string.settings_show_until_subtitle_0
+            1 -> R.string.settings_show_until_subtitle_1
+            2 -> R.string.settings_show_until_subtitle_2
+            3 -> R.string.settings_show_until_subtitle_3
+            4 -> R.string.settings_show_until_subtitle_4
+            5 -> R.string.settings_show_until_subtitle_5
+            6 -> R.string.settings_show_until_subtitle_6
+            7 -> R.string.settings_show_until_subtitle_7
+            else -> R.string.settings_show_until_subtitle_1
+        }
+    }
+
+    fun getSecondRowInfoString(info: Int): Int {
+        return when (info) {
+            0 -> R.string.settings_second_row_info_subtitle_0
+            1 -> R.string.settings_second_row_info_subtitle_1
+            2 -> R.string.settings_second_row_info_subtitle_2
+            else -> R.string.settings_second_row_info_subtitle_0
+        }
+    }
+
+    fun getTextShadowString(shadow: Int): Int {
+        return when (shadow) {
+            0 -> R.string.settings_text_shadow_subtitle_none
+            1 -> R.string.settings_text_shadow_subtitle_low
+            2 -> R.string.settings_text_shadow_subtitle_high
+            else -> R.string.settings_text_shadow_subtitle_low
+        }
+    }
+
+    fun getCustomFontLabel(shadow: Int): Int {
+        return when (shadow) {
+            0 -> R.string.custom_font_subtitle_0
+            1 -> R.string.custom_font_subtitle_1
+            else -> R.string.custom_font_subtitle_1
+        }
+    }
+
+    fun getCalendarIntent(context: Context): Intent {
+        return when (Preferences.calendarAppPackage) {
+            "" -> {
+                Intent(Intent.ACTION_MAIN).apply {
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    addCategory(Intent.CATEGORY_APP_CALENDAR)
+                }
+            }
+            "_" -> {
+                Intent()
+            }
+            else -> {
+                val pm: PackageManager = context.packageManager
+                try {
+                    pm.getLaunchIntentForPackage(Preferences.calendarAppPackage)!!.apply {
+                        addCategory(Intent.CATEGORY_LAUNCHER)
+                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    }
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    Intent(Intent.ACTION_MAIN).apply {
+                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                        addCategory(Intent.CATEGORY_APP_CALENDAR)
+                    }
+                }
+            }
+        }
+    }
+
+    fun getWeatherIntent(context: Context): Intent {
+        return when (Preferences.weatherAppPackage) {
+            "" -> {
+                Intent(Intent.ACTION_VIEW).apply {
+                    addCategory(Intent.CATEGORY_DEFAULT)
+                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                    data = Uri.parse("dynact://velour/weather/ProxyActivity")
+                    component = ComponentName("com.google.android.googlequicksearchbox", "com.google.android.apps.gsa.velour.DynamicActivityTrampoline")
+                }
+            }
+            "_" -> {
+                Intent()
+            }
+            else -> {
+                val pm: PackageManager = context.packageManager
+                try {
+                    pm.getLaunchIntentForPackage(Preferences.weatherAppPackage)!!.apply {
+                        addCategory(Intent.CATEGORY_LAUNCHER)
+                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                    }
+                } catch (e: Exception) {
+                    Intent(Intent.ACTION_VIEW).apply {
+                        addCategory(Intent.CATEGORY_DEFAULT)
+                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                        data = Uri.parse("dynact://velour/weather/ProxyActivity")
+                        component = ComponentName("com.google.android.googlequicksearchbox", "com.google.android.apps.gsa.velour.DynamicActivityTrampoline")
+                    }
+                }
+            }
+        }
+    }
+
+    fun getEventIntent(context: Context, e: Event): Intent {
+        return when (Preferences.eventAppPackage) {
+            "" -> {
+                val uri = ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, e.eventID)
+                Intent(Intent.ACTION_VIEW).apply {
+                    data = uri
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    putExtra("beginTime", e.startDate)
+                    putExtra("endTime", e.endDate)
+                }
+            }
+            "_" -> {
+                Intent()
+            }
+            else -> {
+                val pm: PackageManager = context.packageManager
+                try {
+                    pm.getLaunchIntentForPackage(Preferences.eventAppPackage)!!.apply {
+                        addCategory(Intent.CATEGORY_LAUNCHER)
+                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    }
+                } catch (ex: Exception) {
+                    val uri = ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, e.id)
+                    Intent(Intent.ACTION_VIEW).apply {
+                        data = uri
+                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                        putExtra("beginTime", e.startDate)
+                        putExtra("endTime", e.endDate)
+                    }
+                }
+            }
+        }
+    }
+
+    fun getClockIntent(context: Context): Intent {
+        return when (Preferences.clockAppPackage) {
+            "" -> {
+                Intent(AlarmClock.ACTION_SHOW_ALARMS).apply {
+                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                }
+            }
+            "_" -> {
+                Intent()
+            }
+            else -> {
+                val pm: PackageManager = context.packageManager
+                try {
+                    pm.getLaunchIntentForPackage(Preferences.clockAppPackage)!!.apply {
+                        addCategory(Intent.CATEGORY_LAUNCHER)
+                    }
+                } catch (e: Exception) {
+                    Intent(AlarmClock.ACTION_SHOW_ALARMS).apply {
+                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                    }
+                }
+            }
+        }
+    }
+
+    fun getCapWordString(text: String): String {
+        return try {
+            val ar = text.split(" ")
+            var newText = ""
+            for (t: String in ar) {
+                newText += " "
+                newText += t.substring(0, 1).toUpperCase(Locale.getDefault())
+                newText += t.substring(1)
+            }
+            newText.substring(1)
+        } catch (e: Exception) {
+            text
+        }
+    }
+
+    fun showLocationNotification(context: Context, show: Boolean) {
+        TODO("Show location notification")
+//        val mNotificationManager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager;
+//
+//        if (show) {
+//            val mBuilder: NotificationCompat.Builder = NotificationCompat.Builder(context, "Config")
+//                    .setSmallIcon(R.drawable.ic_stat_name)
+//                    .setPriority(Notification.PRIORITY_MIN)
+//                    .setColor(ContextCompat.getColor(context, R.color.colorPrimary))
+//                    .setContentTitle(context.getString(R.string.notification_gps_title))
+//                    .setContentText(context.getString(R.string.notification_gps_subtitle))
+//                    .setAutoCancel(true);
+//
+//            val intent: Intent = Intent( Settings.ACTION_LOCATION_SOURCE_SETTINGS);
+//            val pi: PendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
+//            mBuilder.setContentIntent(pi);
+//            mNotificationManager.notify(1, mBuilder.build());
+//        } else {
+//            mNotificationManager.cancel(1);
+//        }
+
+    }
+
+    fun showWeatherNotification(context: Context, show: Boolean) {
+        TODO("Show location notification")
+//        val mNotificationManager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager;
+//
+//        if (show) {
+//            val mBuilder: NotificationCompat.Builder = NotificationCompat.Builder(context, "Config")
+//                    .setSmallIcon(R.drawable.ic_stat_name)
+//                    .setColor(ContextCompat.getColor(context, R.color.colorPrimary))
+//                    .setContentTitle(context.getString(R.string.settings_weather_provider_api_key_title))
+//                    .setContentText(context.getString(R.string.settings_weather_provider_api_key_subtitle_not_set))
+//                    .setAutoCancel(true);
+//
+//            val intent: Intent = Intent(context, MainActivity::class.java);
+//            intent.putExtra(Constants.ACTION_EXTRA_OPEN_WEATHER_PROVIDER, true)
+//            val pi: PendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
+//            mBuilder.setContentIntent(pi);
+//            mNotificationManager.notify(2, mBuilder.build());
+//        } else {
+//            mNotificationManager.cancel(2);
+//        }
+    }
+
+    fun expand(v: View) {
+        if (v.visibility != View.VISIBLE) {
+            v.measure(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)
+            val targetHeight = v.measuredHeight
+
+            v.layoutParams.height = 0
+            v.visibility = View.VISIBLE
+            val a = object : Animation() {
+                protected override fun applyTransformation(interpolatedTime: Float, t: Transformation) {
+                    v.layoutParams.height = if (interpolatedTime == 1f)
+                        LinearLayout.LayoutParams.WRAP_CONTENT
+                    else
+                        (targetHeight * interpolatedTime).toInt()
+                    v.translationY = 0f
+                    v.requestLayout()
+                }
+
+                override fun willChangeBounds(): Boolean {
+                    return true
+                }
+            }
+
+            a.duration = 500L
+            v.startAnimation(a)
+        }
+    }
+
+    fun collapse(v: View) {
+        if (v.visibility != View.GONE) {
+            val initialHeight = v.measuredHeight
+
+            val a = object : Animation() {
+                protected override fun applyTransformation(interpolatedTime: Float, t: Transformation) {
+                    if (interpolatedTime == 1f) {
+                        v.visibility = View.GONE
+                    } else {
+                        v.layoutParams.height = initialHeight - (initialHeight * interpolatedTime).toInt()
+                        v.requestLayout()
+                    }
+                }
+
+                override fun willChangeBounds(): Boolean {
+                    return true
+                }
+            }
+
+            a.duration = 500L //(initialHeight / v.context.resources.displayMetrics.density).toLong()
+            v.startAnimation(a)
+        }
+    }
+
+    fun getEmojiByUnicode(unicode: Int): String {
+        return String(Character.toChars(unicode))
+    }
+
+    fun getDifferenceText(context: Context, now: Long, start: Long): String {
+        val nowDate = DateTime(now)
+        val eventDate = DateTime(start)
+
+        var difference = start - now
+        difference += 60 * 1000 - (difference % (60 * 1000))
+
+        when {
+            difference <= 0 || TimeUnit.MILLISECONDS.toHours(difference) < 1 -> {
+                return ""
+            }
+            TimeUnit.MILLISECONDS.toHours(difference) < 12 -> {
+                return DateUtils.getRelativeTimeSpanString(start, now, DateUtils.HOUR_IN_MILLIS).toString()
+            }
+            eventDate.dayOfYear == nowDate.plusDays(1).dayOfYear -> {
+                return String.format("%s", context.getString(R.string.tomorrow))
+            }
+            eventDate.dayOfYear == nowDate.dayOfYear -> {
+                return String.format("%s", context.getString(R.string.today))
+            }
+            else -> {
+                return DateUtils.getRelativeTimeSpanString(start, now, DateUtils.DAY_IN_MILLIS).toString()
+            }
+        }
+
+    }
+
+    fun getFontColor(): Int {
+        return try {
+            Color.parseColor(Preferences.textGlobalColor)
+        } catch (e: Exception) {
+            Color.parseColor("#FFFFFF")
+        }
+    }
+
+    fun getTintedDrawable(context: Context, inputDrawable: Int, color: Int): Drawable?  = ContextCompat.getDrawable(context, inputDrawable)?.apply {
+        DrawableCompat.setTint(this, color)
+        DrawableCompat.setTintMode(this, PorterDuff.Mode.SRC_IN)
+    }
+
+    fun changeBitmapColor(sourceBitmap: Bitmap, color: Int): Bitmap {
+        val resultBitmap = Bitmap.createBitmap(sourceBitmap, 0, 0,
+                sourceBitmap.width - 1, sourceBitmap.height - 1)
+        val p = Paint()
+        val filter = PorterDuffColorFilter(color, PorterDuff.Mode.SRC_IN)
+        p.colorFilter = filter
+
+        val canvas = Canvas(resultBitmap)
+        canvas.drawBitmap(resultBitmap, 0f, 0f, p)
+
+        return resultBitmap
+    }
+
+    fun getNextAlarm(context: Context): String = with(context.getSystemService(Context.ALARM_SERVICE) as AlarmManager) {
+        return if (nextAlarmClock != null && nextAlarmClock.triggerTime - Calendar.getInstance().timeInMillis > 5 * 60 * 1000) {
+            DateFormat.getTimeFormat(context).format(Date(nextAlarmClock.triggerTime))
+        } else {
+            ""
+        }
+    }
+}

app/src/main/java/com/tommasoberlose/anotherwidget/utils/WeatherUtil.kt

@@ -0,0 +1,145 @@
+package com.tommasoberlose.anotherwidget.utils
+
+import android.content.Context
+import com.google.android.gms.location.LocationServices
+import com.kwabenaberko.openweathermaplib.constants.Units
+import com.kwabenaberko.openweathermaplib.implementation.OpenWeatherMapHelper
+import com.kwabenaberko.openweathermaplib.implementation.callbacks.CurrentWeatherCallback
+import com.kwabenaberko.openweathermaplib.models.currentweather.CurrentWeather
+import com.tommasoberlose.anotherwidget.R
+import com.tommasoberlose.anotherwidget.global.Preferences
+
+
+/**
+ * Created by tommaso on 08/10/17.
+ */
+
+object WeatherUtil {
+
+    fun updateWeather(context: Context) {
+        if (Preferences.customLocationAdd != "") {
+            weatherNetworkRequest(
+                context
+            )
+        } else {
+            LocationServices.getFusedLocationProviderClient(context).lastLocation.addOnSuccessListener {
+                Preferences.customLocationLat = it.latitude.toString()
+                Preferences.customLocationLon = it.longitude.toString()
+
+                weatherNetworkRequest(context)
+            }
+        }
+    }
+
+    private fun weatherNetworkRequest(context: Context) {
+        if (Preferences.showWeather && Preferences.weatherProviderApi != "" && Preferences.customLocationLat != "" && Preferences.customLocationLon != "") {
+            val helper = OpenWeatherMapHelper(Preferences.weatherProviderApi)
+            helper.setUnits(if (Preferences.weatherTempUnit == "F") Units.IMPERIAL else Units.METRIC)
+            helper.getCurrentWeatherByGeoCoordinates(Preferences.customLocationLat.toDouble(), Preferences.customLocationLon.toDouble(), object : CurrentWeatherCallback {
+                override fun onSuccess(currentWeather: CurrentWeather?) {
+                    currentWeather?.let {
+                        Preferences.weatherTemp = currentWeather.main.temp.toFloat()
+                        Preferences.weatherIcon = currentWeather.weather[0].icon
+                        Preferences.weatherRealTempUnit = Preferences.weatherTempUnit
+                        Util.updateWidget(context)
+                    }
+                }
+
+                override fun onFailure(throwable: Throwable?) {
+                }
+
+            })
+        } else {
+            removeWeather(context)
+        }
+    }
+
+    private fun removeWeather(context: Context) {
+        Preferences.remove(Preferences::weatherTemp)
+        Preferences.remove(Preferences::weatherTempUnit)
+        Util.updateWidget(context)
+    }
+
+    fun getWeatherIconResource(icon: String): Int {
+        when (icon) {
+            "01d" -> {
+                return R.drawable.clear_day
+            }
+            "02d" -> {
+                return R.drawable.partly_cloudy
+            }
+            "03d" -> {
+                return R.drawable.mostly_cloudy
+            }
+            "04d" -> {
+                return R.drawable.cloudy_weather
+            }
+            "09d" -> {
+                return R.drawable.storm_weather_day
+            }
+            "10d" -> {
+                return R.drawable.rainy_day
+            }
+            "11d" -> {
+                return R.drawable.thunder_day
+            }
+            "13d" -> {
+                return R.drawable.snow_day
+            }
+            "50d" -> {
+                return R.drawable.haze_day
+            }
+            "80d" -> {
+                return R.drawable.windy_day
+            }
+            "81d" -> {
+                return R.drawable.rain_snow_day
+            }
+            "82d" -> {
+                return R.drawable.haze_weather
+            }
+
+
+
+            "01n" -> {
+                return R.drawable.clear_night
+            }
+            "02n" -> {
+                return R.drawable.partly_cloudy_night
+            }
+            "03n" -> {
+                return R.drawable.mostly_cloudy_night
+            }
+            "04n" -> {
+                return R.drawable.cloudy_weather
+            }
+            "09n" -> {
+                return R.drawable.storm_weather_night
+            }
+            "10n" -> {
+                return R.drawable.rainy_night
+            }
+            "11n" -> {
+                return R.drawable.thunder_night
+            }
+            "13n" -> {
+                return R.drawable.snow_night
+            }
+            "50n" -> {
+                return R.drawable.haze_night
+            }
+            "80n" -> {
+                return R.drawable.windy_night
+            }
+            "81n" -> {
+                return R.drawable.rain_snow_night
+            }
+            "82n" -> {
+                return R.drawable.haze_weather
+            }
+            else -> {
+                return R.drawable.unknown
+            }
+        }
+    }
+}