android-12.0.0_r34/s

/*
 * Copyright (C) 2020 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.deskclock.provider

import android.content.ContentResolver
import android.content.ContentUris
import android.content.ContentValues
import android.content.Context
import android.content.Intent
import android.database.Cursor
import android.media.RingtoneManager
import android.net.Uri
import android.provider.BaseColumns._ID

import com.android.deskclock.LogUtils
import com.android.deskclock.R
import com.android.deskclock.alarms.AlarmStateManager
import com.android.deskclock.data.DataModel
import com.android.deskclock.provider.ClockContract.AlarmSettingColumns
import com.android.deskclock.provider.ClockContract.InstancesColumns

import java.util.Calendar
import java.util.LinkedList

class AlarmInstance : InstancesColumns {
    // Public fields
    var mYear = 0
    var mMonth = 0
    var mDay = 0
    var mHour = 0
    var mMinute = 0

    @JvmField
    var mId: Long = 0

    @JvmField
    var mLabel: String? = null

    @JvmField
    var mVibrate = false

    @JvmField
    var mRingtone: Uri? = null

    @JvmField
    var mAlarmId: Long? = null

    @JvmField
    var mAlarmState: Int

    constructor(calendar: Calendar, alarmId: Long?) : this(calendar) {
        mAlarmId = alarmId
    }

    constructor(calendar: Calendar) {
        mId = INVALID_ID
        alarmTime = calendar
        mLabel = ""
        mVibrate = false
        mRingtone = null
        mAlarmState = InstancesColumns.SILENT_STATE
    }

    constructor(instance: AlarmInstance) {
        mId = instance.mId
        mYear = instance.mYear
        mMonth = instance.mMonth
        mDay = instance.mDay
        mHour = instance.mHour
        mMinute = instance.mMinute
        mLabel = instance.mLabel
        mVibrate = instance.mVibrate
        mRingtone = instance.mRingtone
        mAlarmId = instance.mAlarmId
        mAlarmState = instance.mAlarmState
    }

    constructor(c: Cursor, joinedTable: Boolean) {
        if (joinedTable) {
            mId = c.getLong(Alarm.INSTANCE_ID_INDEX)
            mYear = c.getInt(Alarm.INSTANCE_YEAR_INDEX)
            mMonth = c.getInt(Alarm.INSTANCE_MONTH_INDEX)
            mDay = c.getInt(Alarm.INSTANCE_DAY_INDEX)
            mHour = c.getInt(Alarm.INSTANCE_HOUR_INDEX)
            mMinute = c.getInt(Alarm.INSTANCE_MINUTE_INDEX)
            mLabel = c.getString(Alarm.INSTANCE_LABEL_INDEX)
            mVibrate = c.getInt(Alarm.INSTANCE_VIBRATE_INDEX) == 1
        } else {
            mId = c.getLong(ID_INDEX)
            mYear = c.getInt(YEAR_INDEX)
            mMonth = c.getInt(MONTH_INDEX)
            mDay = c.getInt(DAY_INDEX)
            mHour = c.getInt(HOUR_INDEX)
            mMinute = c.getInt(MINUTES_INDEX)
            mLabel = c.getString(LABEL_INDEX)
            mVibrate = c.getInt(VIBRATE_INDEX) == 1
        }
        mRingtone = if (c.isNull(RINGTONE_INDEX)) {
            // Should we be saving this with the current ringtone or leave it null
            // so it changes when user changes default ringtone?
            RingtoneManager.getDefaultUri(RingtoneManager.TYPE_ALARM)
        } else {
            Uri.parse(c.getString(RINGTONE_INDEX))
        }

        if (!c.isNull(ALARM_ID_INDEX)) {
            mAlarmId = c.getLong(ALARM_ID_INDEX)
        }
        mAlarmState = c.getInt(ALARM_STATE_INDEX)
    }

    /**
     * @return the deeplink that identifies this alarm instance
     */
    val contentUri: Uri
        get() = getContentUri(mId)

    fun getLabelOrDefault(context: Context): String {
        return if (mLabel.isNullOrEmpty()) context.getString(R.string.default_label) else mLabel!!
    }

    /**
     * Return the time when a alarm should fire.
     *
     * @return the time
     */
    var alarmTime: Calendar
        get() {
            val calendar = Calendar.getInstance()
            calendar[Calendar.YEAR] = mYear
            calendar[Calendar.MONTH] = mMonth
            calendar[Calendar.DAY_OF_MONTH] = mDay
            calendar[Calendar.HOUR_OF_DAY] = mHour
            calendar[Calendar.MINUTE] = mMinute
            calendar[Calendar.SECOND] = 0
            calendar[Calendar.MILLISECOND] = 0
            return calendar
        }
        set(calendar) {
            mYear = calendar[Calendar.YEAR]
            mMonth = calendar[Calendar.MONTH]
            mDay = calendar[Calendar.DAY_OF_MONTH]
            mHour = calendar[Calendar.HOUR_OF_DAY]
            mMinute = calendar[Calendar.MINUTE]
        }

    /**
     * Return the time when a low priority notification should be shown.
     *
     * @return the time
     */
    val lowNotificationTime: Calendar
        get() {
            val calendar = alarmTime
            calendar.add(Calendar.HOUR_OF_DAY, LOW_NOTIFICATION_HOUR_OFFSET)
            return calendar
        }

    /**
     * Return the time when a high priority notification should be shown.
     *
     * @return the time
     */
    val highNotificationTime: Calendar
        get() {
            val calendar = alarmTime
            calendar.add(Calendar.MINUTE, HIGH_NOTIFICATION_MINUTE_OFFSET)
            return calendar
        }

    /**
     * Return the time when a missed notification should be removed.
     *
     * @return the time
     */
    val missedTimeToLive: Calendar
        get() {
            val calendar = alarmTime
            calendar.add(Calendar.HOUR, MISSED_TIME_TO_LIVE_HOUR_OFFSET)
            return calendar
        }

    /**
     * Return the time when the alarm should stop firing and be marked as missed.
     *
     * @return the time when alarm should be silence, or null if never
     */
    val timeout: Calendar?
        get() {
            val timeoutMinutes = DataModel.dataModel.alarmTimeout

            // Alarm silence has been set to "None"
            if (timeoutMinutes < 0) {
                return null
            }

            val calendar = alarmTime
            calendar.add(Calendar.MINUTE, timeoutMinutes)
            return calendar
        }

    override fun equals(other: Any?): Boolean {
        if (other !is AlarmInstance) return false
        return mId == other.mId
    }

    override fun hashCode(): Int {
        return java.lang.Long.valueOf(mId).hashCode()
    }

    override fun toString(): String {
        return "AlarmInstance{" +
                "mId=" + mId +
                ", mYear=" + mYear +
                ", mMonth=" + mMonth +
                ", mDay=" + mDay +
                ", mHour=" + mHour +
                ", mMinute=" + mMinute +
                ", mLabel=" + mLabel +
                ", mVibrate=" + mVibrate +
                ", mRingtone=" + mRingtone +
                ", mAlarmId=" + mAlarmId +
                ", mAlarmState=" + mAlarmState +
                '}'
    }

    companion object {
        /**
         * Offset from alarm time to show low priority notification
         */
        const val LOW_NOTIFICATION_HOUR_OFFSET = -2

        /**
         * Offset from alarm time to show high priority notification
         */
        const val HIGH_NOTIFICATION_MINUTE_OFFSET = -30

        /**
         * Offset from alarm time to stop showing missed notification.
         */
        private const val MISSED_TIME_TO_LIVE_HOUR_OFFSET = 12

        /**
         * AlarmInstances start with an invalid id when it hasn't been saved to the database.
         */
        const val INVALID_ID: Long = -1

        private val QUERY_COLUMNS = arrayOf(
                _ID,
                InstancesColumns.YEAR,
                InstancesColumns.MONTH,
                InstancesColumns.DAY,
                InstancesColumns.HOUR,
                InstancesColumns.MINUTES,
                AlarmSettingColumns.LABEL,
                AlarmSettingColumns.VIBRATE,
                AlarmSettingColumns.RINGTONE,
                InstancesColumns.ALARM_ID,
                InstancesColumns.ALARM_STATE
        )

        /**
         * These save calls to cursor.getColumnIndexOrThrow()
         * THEY MUST BE KEPT IN SYNC WITH ABOVE QUERY COLUMNS
         */
        private const val ID_INDEX = 0
        private const val YEAR_INDEX = 1
        private const val MONTH_INDEX = 2
        private const val DAY_INDEX = 3
        private const val HOUR_INDEX = 4
        private const val MINUTES_INDEX = 5
        private const val LABEL_INDEX = 6
        private const val VIBRATE_INDEX = 7
        private const val RINGTONE_INDEX = 8
        private const val ALARM_ID_INDEX = 9
        private const val ALARM_STATE_INDEX = 10

        private const val COLUMN_COUNT = ALARM_STATE_INDEX + 1

        @JvmStatic
        fun createContentValues(instance: AlarmInstance): ContentValues {
            val values = ContentValues(COLUMN_COUNT)
            if (instance.mId != INVALID_ID) {
                values.put(_ID, instance.mId)
            }

            values.put(InstancesColumns.YEAR, instance.mYear)
            values.put(InstancesColumns.MONTH, instance.mMonth)
            values.put(InstancesColumns.DAY, instance.mDay)
            values.put(InstancesColumns.HOUR, instance.mHour)
            values.put(InstancesColumns.MINUTES, instance.mMinute)
            values.put(AlarmSettingColumns.LABEL, instance.mLabel)
            values.put(AlarmSettingColumns.VIBRATE, if (instance.mVibrate) 1 else 0)
            if (instance.mRingtone == null) {
                // We want to put null in the database, so we'll be able
                // to pick up on changes to the default alarm
                values.putNull(AlarmSettingColumns.RINGTONE)
            } else {
                values.put(AlarmSettingColumns.RINGTONE, instance.mRingtone.toString())
            }
            values.put(InstancesColumns.ALARM_ID, instance.mAlarmId)
            values.put(InstancesColumns.ALARM_STATE, instance.mAlarmState)
            return values
        }

        fun createIntent(action: String?, instanceId: Long): Intent {
            return Intent(action).setData(getContentUri(instanceId))
        }

        @JvmStatic
        fun createIntent(context: Context?, cls: Class<*>?, instanceId: Long): Intent {
            return Intent(context, cls).setData(getContentUri(instanceId))
        }

        @JvmStatic
        fun getId(contentUri: Uri): Long {
            return ContentUris.parseId(contentUri)
        }

        /**
         * @return the [Uri] identifying the alarm instance
         */
        fun getContentUri(instanceId: Long): Uri {
            return ContentUris.withAppendedId(InstancesColumns.CONTENT_URI, instanceId)
        }

        /**
         * Get alarm instance from instanceId.
         *
         * @param cr provides access to the content model
         * @param instanceId for the desired instance.
         * @return instance if found, null otherwise
         */
        @JvmStatic
        fun getInstance(cr: ContentResolver, instanceId: Long): AlarmInstance? {
            val cursor: Cursor? =
                    cr.query(getContentUri(instanceId), QUERY_COLUMNS, null, null, null)
            cursor?.let {
                if (cursor.moveToFirst()) {
                    return AlarmInstance(cursor, false /* joinedTable */)
                }
            }
            return null
        }

        /**
         * Get alarm instance for the `contentUri`.
         *
         * @param cr provides access to the content model
         * @param contentUri the [deeplink][.getContentUri] for the desired instance
         * @return instance if found, null otherwise
         */
        fun getInstance(cr: ContentResolver, contentUri: Uri): AlarmInstance? {
            val instanceId: Long = ContentUris.parseId(contentUri)
            return getInstance(cr, instanceId)
        }

        /**
         * Get an alarm instances by alarmId.
         *
         * @param contentResolver provides access to the content model
         * @param alarmId of instances desired.
         * @return list of alarms instances that are owned by alarmId.
         */
        @JvmStatic
        fun getInstancesByAlarmId(
            contentResolver: ContentResolver,
            alarmId: Long
        ): List<AlarmInstance> {
            return getInstances(contentResolver, InstancesColumns.ALARM_ID + "=" + alarmId)
        }

        /**
         * Get the next instance of an alarm given its alarmId
         * @param contentResolver provides access to the content model
         * @param alarmId of instance desired
         * @return the next instance of an alarm by alarmId.
         */
        @JvmStatic
        fun getNextUpcomingInstanceByAlarmId(
            contentResolver: ContentResolver,
            alarmId: Long
        ): AlarmInstance? {
            val alarmInstances = getInstancesByAlarmId(contentResolver, alarmId)
            if (alarmInstances.isEmpty()) {
                return null
            }
            var nextAlarmInstance = alarmInstances[0]
            for (instance in alarmInstances) {
                if (instance.alarmTime.before(nextAlarmInstance.alarmTime)) {
                    nextAlarmInstance = instance
                }
            }
            return nextAlarmInstance
        }

        /**
         * Get alarm instance by id and state.
         */
        fun getInstancesByInstanceIdAndState(
            contentResolver: ContentResolver,
            alarmInstanceId: Long,
            state: Int
        ): List<AlarmInstance> {
            return getInstances(contentResolver,
                    _ID.toString() + "=" + alarmInstanceId + " AND " +
                            InstancesColumns.ALARM_STATE + "=" + state)
        }

        /**
         * Get alarm instances in the specified state.
         */
        @JvmStatic
        fun getInstancesByState(
            contentResolver: ContentResolver,
            state: Int
        ): List<AlarmInstance> {
            return getInstances(contentResolver,
                    InstancesColumns.ALARM_STATE + "=" + state)
        }

        /**
         * Get a list of instances given selection.
         *
         * @param cr provides access to the content model
         * @param selection A filter declaring which rows to return, formatted as an
         * SQL WHERE clause (excluding the WHERE itself). Passing null will
         * return all rows for the given URI.
         * @param selectionArgs You may include ?s in selection, which will be
         * replaced by the values from selectionArgs, in the order that they
         * appear in the selection. The values will be bound as Strings.
         * @return list of alarms matching where clause or empty list if none found.
         */
        @JvmStatic
        fun getInstances(
            cr: ContentResolver,
            selection: String?,
            vararg selectionArgs: String?
        ): MutableList<AlarmInstance> {
            val result: MutableList<AlarmInstance> = LinkedList()
            val cursor: Cursor? =
                    cr.query(InstancesColumns.CONTENT_URI, QUERY_COLUMNS,
                            selection, selectionArgs, null)
            cursor?.let {
                if (cursor.moveToFirst()) {
                    do {
                        result.add(AlarmInstance(cursor, false /* joinedTable */))
                    } while (cursor.moveToNext())
                }
            }

            return result
        }

        @JvmStatic
        fun addInstance(
            contentResolver: ContentResolver,
            instance: AlarmInstance
        ): AlarmInstance {
            // Make sure we are not adding a duplicate instances. This is not a
            // fix and should never happen. This is only a safe guard against bad code, and you
            // should fix the root issue if you see the error message.
            val dupSelector = InstancesColumns.ALARM_ID + " = " + instance.mAlarmId
            for (otherInstances in getInstances(contentResolver, dupSelector)) {
                if (otherInstances.alarmTime == instance.alarmTime) {
                    LogUtils.i("Detected duplicate instance in DB. Updating " +
                            otherInstances + " to " + instance)
                    // Copy over the new instance values and update the db
                    instance.mId = otherInstances.mId
                    updateInstance(contentResolver, instance)
                    return instance
                }
            }

            val values: ContentValues = createContentValues(instance)
            val uri: Uri = contentResolver.insert(InstancesColumns.CONTENT_URI, values)!!
            instance.mId = getId(uri)
            return instance
        }

        @JvmStatic
        fun updateInstance(contentResolver: ContentResolver, instance: AlarmInstance): Boolean {
            if (instance.mId == INVALID_ID) return false
            val values: ContentValues = createContentValues(instance)
            val rowsUpdated: Long =
                    contentResolver.update(getContentUri(instance.mId), values, null, null).toLong()
            return rowsUpdated == 1L
        }

        @JvmStatic
        fun deleteInstance(contentResolver: ContentResolver, instanceId: Long): Boolean {
            if (instanceId == INVALID_ID) return false
            val deletedRows: Int = contentResolver.delete(getContentUri(instanceId), "", null)
            return deletedRows == 1
        }

        @JvmStatic
        fun deleteOtherInstances(
            context: Context,
            contentResolver: ContentResolver,
            alarmId: Long,
            instanceId: Long
        ) {
            val instances = getInstancesByAlarmId(contentResolver, alarmId)
            for (instance in instances) {
                if (instance.mId != instanceId) {
                    AlarmStateManager.unregisterInstance(context, instance)
                    deleteInstance(contentResolver, instance.mId)
                }
            }
        }
    }
}