| /* |
| * Copyright (C) 2021 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.android.calendar.widget |
| |
| import android.app.AlarmManager |
| import android.app.PendingIntent |
| import android.appwidget.AppWidgetManager |
| import android.content.BroadcastReceiver |
| import android.content.Context |
| import android.content.CursorLoader |
| import android.content.Intent |
| import android.content.Loader |
| import android.content.res.Resources |
| import android.database.Cursor |
| import android.database.MatrixCursor |
| import android.net.Uri |
| import android.os.Handler |
| import android.provider.CalendarContract.Attendees |
| import android.provider.CalendarContract.Calendars |
| import android.provider.CalendarContract.Instances |
| import android.text.format.DateUtils |
| import android.text.format.Time |
| import android.util.Log |
| import android.view.View |
| import android.widget.RemoteViews |
| import android.widget.RemoteViewsService |
| import com.android.calendar.R |
| import com.android.calendar.Utils |
| import com.android.calendar.widget.CalendarAppWidgetModel.DayInfo |
| import com.android.calendar.widget.CalendarAppWidgetModel.EventInfo |
| import com.android.calendar.widget.CalendarAppWidgetModel.RowInfo |
| import java.util.concurrent.ExecutorService |
| import java.util.concurrent.Executors |
| import java.util.concurrent.atomic.AtomicInteger |
| |
| class CalendarAppWidgetService : RemoteViewsService() { |
| companion object { |
| private const val TAG = "CalendarWidget" |
| const val EVENT_MIN_COUNT = 20 |
| const val EVENT_MAX_COUNT = 100 |
| |
| // Minimum delay between queries on the database for widget updates in ms |
| const val WIDGET_UPDATE_THROTTLE = 500 |
| private val EVENT_SORT_ORDER: String = (Instances.START_DAY.toString() + " ASC, " + |
| Instances.START_MINUTE + " ASC, " + Instances.END_DAY + " ASC, " + |
| Instances.END_MINUTE + " ASC LIMIT " + EVENT_MAX_COUNT) |
| private val EVENT_SELECTION: String = Calendars.VISIBLE.toString() + "=1" |
| private val EVENT_SELECTION_HIDE_DECLINED: String = |
| (Calendars.VISIBLE.toString() + "=1 AND " + |
| Instances.SELF_ATTENDEE_STATUS + "!=" + Attendees.ATTENDEE_STATUS_DECLINED) |
| @JvmField |
| val EVENT_PROJECTION = arrayOf<String>( |
| Instances.ALL_DAY, |
| Instances.BEGIN, |
| Instances.END, |
| Instances.TITLE, |
| Instances.EVENT_LOCATION, |
| Instances.EVENT_ID, |
| Instances.START_DAY, |
| Instances.END_DAY, |
| Instances.DISPLAY_COLOR, // If SDK < 16, set to Instances.CALENDAR_COLOR. |
| Instances.SELF_ATTENDEE_STATUS |
| ) |
| const val INDEX_ALL_DAY = 0 |
| const val INDEX_BEGIN = 1 |
| const val INDEX_END = 2 |
| const val INDEX_TITLE = 3 |
| const val INDEX_EVENT_LOCATION = 4 |
| const val INDEX_EVENT_ID = 5 |
| const val INDEX_START_DAY = 6 |
| const val INDEX_END_DAY = 7 |
| const val INDEX_COLOR = 8 |
| const val INDEX_SELF_ATTENDEE_STATUS = 9 |
| const val MAX_DAYS = 7 |
| private val SEARCH_DURATION: Long = MAX_DAYS * DateUtils.DAY_IN_MILLIS |
| |
| /** |
| * Update interval used when no next-update calculated, or bad trigger time in past. |
| * Unit: milliseconds. |
| */ |
| private val UPDATE_TIME_NO_EVENTS: Long = DateUtils.HOUR_IN_MILLIS * 6 |
| |
| /** |
| * Format given time for debugging output. |
| * |
| * @param unixTime Target time to report. |
| * @param now Current system time from [System.currentTimeMillis] |
| * for calculating time difference. |
| */ |
| fun formatDebugTime(unixTime: Long, now: Long): String { |
| val time = Time() |
| time.set(unixTime) |
| var delta = unixTime - now |
| return if (delta > DateUtils.MINUTE_IN_MILLIS) { |
| delta /= DateUtils.MINUTE_IN_MILLIS |
| String.format( |
| "[%d] %s (%+d mins)", unixTime, |
| time.format("%H:%M:%S"), delta |
| ) |
| } else { |
| delta /= DateUtils.SECOND_IN_MILLIS |
| String.format( |
| "[%d] %s (%+d secs)", unixTime, |
| time.format("%H:%M:%S"), delta |
| ) |
| } |
| } |
| |
| init { |
| if (!Utils.isJellybeanOrLater()) { |
| EVENT_PROJECTION[INDEX_COLOR] = Instances.CALENDAR_COLOR |
| } |
| } |
| } |
| |
| @Override |
| override fun onGetViewFactory(intent: Intent): RemoteViewsFactory { |
| return CalendarFactory(getApplicationContext(), intent) |
| } |
| |
| class CalendarFactory : BroadcastReceiver, RemoteViewsService.RemoteViewsFactory, |
| Loader.OnLoadCompleteListener<Cursor?> { |
| private var mContext: Context? = null |
| private var mResources: Resources? = null |
| private var mLastSerialNum = -1 |
| private var mLoader: CursorLoader? = null |
| private val mHandler: Handler = Handler() |
| private val executor: ExecutorService = Executors.newSingleThreadExecutor() |
| private var mAppWidgetId = 0 |
| private var mDeclinedColor = 0 |
| private var mStandardColor = 0 |
| private var mAllDayColor = 0 |
| private val mTimezoneChanged: Runnable = object : Runnable { |
| @Override |
| override fun run() { |
| if (mLoader != null) { |
| mLoader?.forceLoad() |
| } |
| } |
| } |
| |
| private fun createUpdateLoaderRunnable( |
| selection: String, |
| result: PendingResult, |
| version: Int |
| ): Runnable { |
| return object : Runnable { |
| @Override |
| override fun run() { |
| // If there is a newer load request in the queue, skip loading. |
| if (mLoader != null && version >= currentVersion.get()) { |
| val uri: Uri = createLoaderUri() |
| mLoader?.setUri(uri) |
| mLoader?.setSelection(selection) |
| synchronized(mLock) { mLastSerialNum = ++mSerialNum } |
| mLoader?.forceLoad() |
| } |
| result.finish() |
| } |
| } |
| } |
| |
| constructor(context: Context, intent: Intent) { |
| mContext = context |
| mResources = context.getResources() |
| mAppWidgetId = intent.getIntExtra( |
| AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID |
| ) |
| mDeclinedColor = mResources?.getColor(R.color.appwidget_item_declined_color) as Int |
| mStandardColor = mResources?.getColor(R.color.appwidget_item_standard_color) as Int |
| mAllDayColor = mResources?.getColor(R.color.appwidget_item_allday_color) as Int |
| } |
| |
| constructor() { |
| // This is being created as part of onReceive |
| } |
| |
| @Override |
| override fun onCreate() { |
| val selection = queryForSelection() |
| initLoader(selection) |
| } |
| |
| @Override |
| override fun onDataSetChanged() { |
| } |
| |
| @Override |
| override fun onDestroy() { |
| if (mLoader != null) { |
| mLoader?.reset() |
| } |
| } |
| |
| @Override |
| override fun getLoadingView(): RemoteViews { |
| val views = RemoteViews(mContext?.getPackageName(), R.layout.appwidget_loading) |
| return views |
| } |
| |
| @Override |
| override fun getViewAt(position: Int): RemoteViews? { |
| // we use getCount here so that it doesn't return null when empty |
| if (position < 0 || position >= getCount()) { |
| return null |
| } |
| if (mModel == null) { |
| val views = RemoteViews( |
| mContext?.getPackageName(), |
| R.layout.appwidget_loading |
| ) |
| val intent: Intent = CalendarAppWidgetProvider.getLaunchFillInIntent( |
| mContext, |
| 0, |
| 0, |
| 0, |
| false |
| ) |
| views.setOnClickFillInIntent(R.id.appwidget_loading, intent) |
| return views |
| } |
| if (mModel!!.mEventInfos!!.isEmpty() || mModel!!.mRowInfos!!.isEmpty()) { |
| val views = RemoteViews( |
| mContext?.getPackageName(), |
| R.layout.appwidget_no_events |
| ) |
| val intent: Intent = CalendarAppWidgetProvider.getLaunchFillInIntent( |
| mContext, |
| 0, |
| 0, |
| 0, |
| false |
| ) |
| views.setOnClickFillInIntent(R.id.appwidget_no_events, intent) |
| return views |
| } |
| val rowInfo: RowInfo? = mModel?.mRowInfos?.get(position) |
| return if (rowInfo!!.mType == RowInfo!!.TYPE_DAY) { |
| val views = RemoteViews( |
| mContext?.getPackageName(), |
| R.layout.appwidget_day |
| ) |
| val dayInfo: DayInfo? = mModel?.mDayInfos?.get(rowInfo!!.mIndex) |
| updateTextView(views, R.id.date, View.VISIBLE, dayInfo!!.mDayLabel) |
| views |
| } else { |
| val views: RemoteViews? |
| val eventInfo: EventInfo? = mModel?.mEventInfos?.get(rowInfo.mIndex) |
| if (eventInfo!!.allDay) { |
| views = RemoteViews( |
| mContext?.getPackageName(), |
| R.layout.widget_all_day_item |
| ) |
| } else { |
| views = RemoteViews(mContext?.getPackageName(), R.layout.widget_item) |
| } |
| val displayColor: Int = Utils.getDisplayColorFromColor(eventInfo!!.color) |
| val now: Long = System.currentTimeMillis() |
| if (!eventInfo!!.allDay && eventInfo!!.start <= now && now <= eventInfo!!.end) { |
| views?.setInt( |
| R.id.widget_row, "setBackgroundResource", |
| R.drawable.agenda_item_bg_secondary |
| ) |
| } else { |
| views?.setInt( |
| R.id.widget_row, "setBackgroundResource", |
| R.drawable.agenda_item_bg_primary |
| ) |
| } |
| if (!eventInfo?.allDay) { |
| updateTextView(views, R.id.`when`, eventInfo?.visibWhen |
| as Int, eventInfo?.`when`) |
| updateTextView(views, R.id.where, eventInfo?.visibWhere |
| as Int, eventInfo?.where) |
| } |
| updateTextView(views, R.id.title, eventInfo?.visibTitle as Int, eventInfo?.title) |
| views.setViewVisibility(R.id.agenda_item_color, View.VISIBLE) |
| val selfAttendeeStatus: Int = eventInfo?.selfAttendeeStatus as Int |
| if (eventInfo!!.allDay) { |
| if (selfAttendeeStatus == Attendees.ATTENDEE_STATUS_INVITED) { |
| views?.setInt( |
| R.id.agenda_item_color, "setImageResource", |
| R.drawable.widget_chip_not_responded_bg |
| ) |
| views?.setInt(R.id.title, "setTextColor", displayColor) |
| } else { |
| views?.setInt( |
| R.id.agenda_item_color, "setImageResource", |
| R.drawable.widget_chip_responded_bg |
| ) |
| views?.setInt(R.id.title, "setTextColor", mAllDayColor) |
| } |
| if (selfAttendeeStatus == Attendees.ATTENDEE_STATUS_DECLINED) { |
| // 40% opacity |
| views?.setInt( |
| R.id.agenda_item_color, "setColorFilter", |
| Utils.getDeclinedColorFromColor(displayColor) |
| ) |
| } else { |
| views?.setInt(R.id.agenda_item_color, "setColorFilter", displayColor) |
| } |
| } else if (selfAttendeeStatus == Attendees.ATTENDEE_STATUS_DECLINED) { |
| views?.setInt(R.id.title, "setTextColor", mDeclinedColor) |
| views?.setInt(R.id.`when`, "setTextColor", mDeclinedColor) |
| views?.setInt(R.id.where, "setTextColor", mDeclinedColor) |
| views?.setInt( |
| R.id.agenda_item_color, "setImageResource", |
| R.drawable.widget_chip_responded_bg |
| ) |
| // 40% opacity |
| views?.setInt( |
| R.id.agenda_item_color, "setColorFilter", |
| Utils.getDeclinedColorFromColor(displayColor) |
| ) |
| } else { |
| views?.setInt(R.id.title, "setTextColor", mStandardColor) |
| views?.setInt(R.id.`when`, "setTextColor", mStandardColor) |
| views?.setInt(R.id.where, "setTextColor", mStandardColor) |
| if (selfAttendeeStatus == Attendees.ATTENDEE_STATUS_INVITED) { |
| views?.setInt( |
| R.id.agenda_item_color, "setImageResource", |
| R.drawable.widget_chip_not_responded_bg |
| ) |
| } else { |
| views?.setInt( |
| R.id.agenda_item_color, "setImageResource", |
| R.drawable.widget_chip_responded_bg |
| ) |
| } |
| views?.setInt(R.id.agenda_item_color, "setColorFilter", displayColor) |
| } |
| var start: Long = eventInfo?.start as Long |
| var end: Long = eventInfo?.end as Long |
| // An element in ListView. |
| if (eventInfo!!.allDay) { |
| val tz: String? = Utils.getTimeZone(mContext, null) |
| val recycle = Time() |
| start = Utils.convertAlldayLocalToUTC(recycle, start, tz as String) |
| end = Utils.convertAlldayLocalToUTC(recycle, end, tz as String) |
| } |
| val fillInIntent: Intent = CalendarAppWidgetProvider.getLaunchFillInIntent( |
| mContext, eventInfo?.id, start, end, eventInfo?.allDay |
| ) |
| views.setOnClickFillInIntent(R.id.widget_row, fillInIntent) |
| views |
| } |
| } |
| |
| @Override |
| override fun getViewTypeCount(): Int { |
| return 5 |
| } |
| |
| @Override |
| override fun getCount(): Int { |
| // if there are no events, we still return 1 to represent the "no |
| // events" view |
| if (mModel == null) { |
| return 1 |
| } |
| return Math.max(1, mModel?.mRowInfos?.size as Int) |
| } |
| |
| @Override |
| override fun getItemId(position: Int): Long { |
| if (mModel == null || mModel?.mRowInfos?.isEmpty() as Boolean || |
| position >= getCount()) { |
| return 0 |
| } |
| val rowInfo: RowInfo = mModel?.mRowInfos?.get(position) as RowInfo |
| if (rowInfo.mType == RowInfo.TYPE_DAY) { |
| return rowInfo.mIndex.toLong() |
| } |
| val eventInfo: EventInfo = mModel?.mEventInfos?.get(rowInfo.mIndex) as EventInfo |
| val prime: Long = 31 |
| var result: Long = 1 |
| result = prime * result + (eventInfo.id xor (eventInfo.id ushr 32)) as Int |
| result = prime * result + (eventInfo.start xor (eventInfo.start ushr 32)) as Int |
| return result |
| } |
| |
| @Override |
| override fun hasStableIds(): Boolean { |
| return true |
| } |
| |
| /** |
| * Query across all calendars for upcoming event instances from now |
| * until some time in the future. Widen the time range that we query by |
| * one day on each end so that we can catch all-day events. All-day |
| * events are stored starting at midnight in UTC but should be included |
| * in the list of events starting at midnight local time. This may fetch |
| * more events than we actually want, so we filter them out later. |
| * |
| * @param selection The selection string for the loader to filter the query with. |
| */ |
| fun initLoader(selection: String?) { |
| if (LOGD) Log.d(TAG, "Querying for widget events...") |
| |
| // Search for events from now until some time in the future |
| val uri: Uri = createLoaderUri() |
| mLoader = CursorLoader( |
| mContext, uri, EVENT_PROJECTION, selection, null, |
| EVENT_SORT_ORDER |
| ) |
| mLoader?.setUpdateThrottle(WIDGET_UPDATE_THROTTLE.toLong()) |
| synchronized(mLock) { mLastSerialNum = ++mSerialNum } |
| mLoader?.registerListener(mAppWidgetId, this) |
| mLoader?.startLoading() |
| } |
| |
| /** |
| * This gets the selection string for the loader. This ends up doing a query in the |
| * shared preferences. |
| */ |
| private fun queryForSelection(): String { |
| return if (Utils.getHideDeclinedEvents(mContext)) EVENT_SELECTION_HIDE_DECLINED |
| else EVENT_SELECTION |
| } |
| |
| /** |
| * @return The uri for the loader |
| */ |
| private fun createLoaderUri(): Uri { |
| val now: Long = System.currentTimeMillis() |
| // Add a day on either side to catch all-day events |
| val begin: Long = now - DateUtils.DAY_IN_MILLIS |
| val end: Long = |
| now + SEARCH_DURATION + DateUtils.DAY_IN_MILLIS |
| return Uri.withAppendedPath( |
| Instances.CONTENT_URI, |
| begin.toString() + "/" + end |
| ) |
| } |
| |
| /** |
| * Calculates and returns the next time we should push widget updates. |
| */ |
| private fun calculateUpdateTime( |
| model: CalendarAppWidgetModel, |
| now: Long, |
| timeZone: String |
| ): Long { |
| // Make sure an update happens at midnight or earlier |
| var minUpdateTime = getNextMidnightTimeMillis(timeZone) |
| for (event in model.mEventInfos) { |
| val start: Long |
| val end: Long |
| start = event.start |
| end = event.end |
| |
| // We want to update widget when we enter/exit time range of an event. |
| if (now < start) { |
| minUpdateTime = Math.min(minUpdateTime, start) |
| } else if (now < end) { |
| minUpdateTime = Math.min(minUpdateTime, end) |
| } |
| } |
| return minUpdateTime |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see |
| * android.content.Loader.OnLoadCompleteListener#onLoadComplete(android |
| * .content.Loader, java.lang.Object) |
| */ |
| @Override |
| override fun onLoadComplete(loader: Loader<Cursor?>?, cursor: Cursor?) { |
| if (cursor == null) { |
| return |
| } |
| // If a newer update has happened since we started clean up and |
| // return |
| synchronized(mLock) { |
| if (cursor.isClosed()) { |
| Log.wtf(TAG, "Got a closed cursor from onLoadComplete") |
| return |
| } |
| if (mLastSerialNum != mSerialNum) { |
| return |
| } |
| val now: Long = System.currentTimeMillis() |
| val tz: String? = Utils.getTimeZone(mContext, mTimezoneChanged) |
| |
| // Copy it to a local static cursor. |
| val matrixCursor: MatrixCursor? = Utils.matrixCursorFromCursor(cursor) |
| try { |
| mModel = buildAppWidgetModel(mContext, matrixCursor, tz) |
| } finally { |
| if (matrixCursor != null) { |
| matrixCursor?.close() |
| } |
| if (cursor != null) { |
| cursor?.close() |
| } |
| } |
| |
| // Schedule an alarm to wake ourselves up for the next update. |
| // We also cancel |
| // all existing wake-ups because PendingIntents don't match |
| // against extras. |
| var triggerTime = calculateUpdateTime(mModel as CalendarAppWidgetModel, |
| now, tz as String) |
| |
| // If no next-update calculated, or bad trigger time in past, |
| // schedule |
| // update about six hours from now. |
| if (triggerTime < now) { |
| Log.w(TAG, "Encountered bad trigger time " + formatDebugTime(triggerTime, now)) |
| triggerTime = now + UPDATE_TIME_NO_EVENTS |
| } |
| val alertManager: AlarmManager = mContext |
| ?.getSystemService(Context.ALARM_SERVICE) as AlarmManager |
| val pendingUpdate: PendingIntent = CalendarAppWidgetProvider |
| .getUpdateIntent(mContext) |
| alertManager.cancel(pendingUpdate) |
| alertManager.set(AlarmManager.RTC, triggerTime, pendingUpdate) |
| val time = Time(Utils.getTimeZone(mContext, null)) |
| time.setToNow() |
| if (time.normalize(true) !== sLastUpdateTime) { |
| val time2 = Time(Utils.getTimeZone(mContext, null)) |
| time2.set(sLastUpdateTime) |
| time2.normalize(true) |
| if (time.year !== time2.year || time.yearDay !== time2.yearDay) { |
| val updateIntent = Intent( |
| Utils.getWidgetUpdateAction(mContext as Context) |
| ) |
| mContext?.sendBroadcast(updateIntent) |
| } |
| sLastUpdateTime = time.toMillis(true) |
| } |
| val widgetManager: AppWidgetManager = AppWidgetManager.getInstance(mContext) |
| if (widgetManager == null) { |
| return |
| } |
| if (mAppWidgetId == -1) { |
| val ids: IntArray = widgetManager.getAppWidgetIds( |
| CalendarAppWidgetProvider |
| .getComponentName(mContext) |
| ) |
| widgetManager.notifyAppWidgetViewDataChanged(ids, R.id.events_list) |
| } else { |
| widgetManager.notifyAppWidgetViewDataChanged(mAppWidgetId, R.id.events_list) |
| } |
| } |
| } |
| |
| @Override |
| override fun onReceive(context: Context?, intent: Intent) { |
| if (LOGD) Log.d(TAG, "AppWidgetService received an intent. It was " + intent.toString()) |
| mContext = context |
| |
| // We cannot do any queries from the UI thread, so push the 'selection' query |
| // to a background thread. However the implementation of the latter query |
| // (cursor loading) uses CursorLoader which must be initiated from the UI thread, |
| // so there is some convoluted handshaking here. |
| // |
| // Note that as currently implemented, this must run in a single threaded executor |
| // or else the loads may be run out of order. |
| // |
| // TODO: Remove use of mHandler and CursorLoader, and do all the work synchronously |
| // in the background thread. All the handshaking going on here between the UI and |
| // background thread with using goAsync, mHandler, and CursorLoader is confusing. |
| val result: PendingResult = goAsync() |
| executor.submit(object : Runnable { |
| @Override |
| override fun run() { |
| // We always complete queryForSelection() even if the load task ends up being |
| // canceled because of a more recent one. Optimizing this to allow |
| // canceling would require keeping track of all the PendingResults |
| // (from goAsync) to abort them. Defer this until it becomes a problem. |
| val selection = queryForSelection() |
| if (mLoader == null) { |
| mAppWidgetId = -1 |
| mHandler.post(object : Runnable { |
| @Override |
| override fun run() { |
| initLoader(selection) |
| result.finish() |
| } |
| }) |
| } else { |
| mHandler.post( |
| createUpdateLoaderRunnable( |
| selection, result, |
| currentVersion.incrementAndGet() |
| ) |
| ) |
| } |
| } |
| }) |
| } |
| |
| internal companion object { |
| private const val LOGD = false |
| |
| // Suppress unnecessary logging about update time. Need to be static as this object is |
| // re-instantiated frequently. |
| // TODO: It seems loadData() is called via onCreate() four times, which should mean |
| // unnecessary CalendarFactory object is created and dropped. It is not efficient. |
| private var sLastUpdateTime = UPDATE_TIME_NO_EVENTS |
| private var mModel: CalendarAppWidgetModel? = null |
| private val mLock: Object = Object() |
| |
| @Volatile |
| private var mSerialNum = 0 |
| private val currentVersion: AtomicInteger = AtomicInteger(0) |
| |
| /* @VisibleForTesting */ |
| @JvmStatic protected fun buildAppWidgetModel( |
| context: Context?, |
| cursor: Cursor?, |
| timeZone: String? |
| ): CalendarAppWidgetModel { |
| val model = CalendarAppWidgetModel(context as Context, timeZone) |
| model.buildFromCursor(cursor as Cursor, timeZone) |
| return model |
| } |
| |
| @JvmStatic private fun getNextMidnightTimeMillis(timezone: String): Long { |
| val time = Time() |
| time.setToNow() |
| time.monthDay++ |
| time.hour = 0 |
| time.minute = 0 |
| time.second = 0 |
| val midnightDeviceTz: Long = time.normalize(true) |
| time.timezone = timezone |
| time.setToNow() |
| time.monthDay++ |
| time.hour = 0 |
| time.minute = 0 |
| time.second = 0 |
| val midnightHomeTz: Long = time.normalize(true) |
| return Math.min(midnightDeviceTz, midnightHomeTz) |
| } |
| |
| @JvmStatic fun updateTextView( |
| views: RemoteViews, |
| id: Int, |
| visibility: Int, |
| string: String? |
| ) { |
| views.setViewVisibility(id, visibility) |
| if (visibility == View.VISIBLE) { |
| views.setTextViewText(id, string) |
| } |
| } |
| } |
| } |
| } |
