deskclock/timer/TimerSetupView.kt

/*
 * 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.timer

import android.content.Context
import android.content.res.ColorStateList
import android.graphics.PorterDuff
import android.text.BidiFormatter
import android.text.TextUtils
import android.text.format.DateUtils
import android.text.style.RelativeSizeSpan
import android.util.AttributeSet
import android.view.KeyEvent
import android.view.LayoutInflater
import android.view.View
import android.view.View.OnLongClickListener
import android.widget.LinearLayout
import android.widget.TextView
import androidx.annotation.IdRes
import androidx.core.view.ViewCompat

import com.android.deskclock.FabContainer
import com.android.deskclock.FormattedTextUtils
import com.android.deskclock.R
import com.android.deskclock.ThemeUtils
import com.android.deskclock.uidata.UiDataModel

import java.io.Serializable

class TimerSetupView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : LinearLayout(context, attrs), View.OnClickListener, OnLongClickListener {
    private val mInput = intArrayOf(0, 0, 0, 0, 0, 0)

    private var mInputPointer = -1
    private val mTimeTemplate: CharSequence

    private lateinit var mTimeView: TextView
    private lateinit var mDeleteView: View
    private lateinit var mDividerView: View
    private lateinit var mDigitViews: Array<TextView>

    /** Updates to the fab are requested via this container.  */
    private lateinit var mFabContainer: FabContainer

    init {
        val bf = BidiFormatter.getInstance(false /* rtlContext */)
        val hoursLabel = bf.unicodeWrap(context.getString(R.string.hours_label))
        val minutesLabel = bf.unicodeWrap(context.getString(R.string.minutes_label))
        val secondsLabel = bf.unicodeWrap(context.getString(R.string.seconds_label))

        // Create a formatted template for "00h 00m 00s".
        mTimeTemplate = TextUtils.expandTemplate("^1^4 ^2^5 ^3^6",
                bf.unicodeWrap("^1"),
                bf.unicodeWrap("^2"),
                bf.unicodeWrap("^3"),
                FormattedTextUtils.formatText(hoursLabel, RelativeSizeSpan(0.5f)),
                FormattedTextUtils.formatText(minutesLabel, RelativeSizeSpan(0.5f)),
                FormattedTextUtils.formatText(secondsLabel, RelativeSizeSpan(0.5f)))

        LayoutInflater.from(context).inflate(R.layout.timer_setup_container, this)
    }

    override fun onFinishInflate() {
        super.onFinishInflate()

        mTimeView = findViewById<View>(R.id.timer_setup_time) as TextView
        mDeleteView = findViewById(R.id.timer_setup_delete)
        mDividerView = findViewById(R.id.timer_setup_divider)
        mDigitViews = arrayOf(
                findViewById<View>(R.id.timer_setup_digit_0) as TextView,
                findViewById<View>(R.id.timer_setup_digit_1) as TextView,
                findViewById<View>(R.id.timer_setup_digit_2) as TextView,
                findViewById<View>(R.id.timer_setup_digit_3) as TextView,
                findViewById<View>(R.id.timer_setup_digit_4) as TextView,
                findViewById<View>(R.id.timer_setup_digit_5) as TextView,
                findViewById<View>(R.id.timer_setup_digit_6) as TextView,
                findViewById<View>(R.id.timer_setup_digit_7) as TextView,
                findViewById<View>(R.id.timer_setup_digit_8) as TextView,
                findViewById<View>(R.id.timer_setup_digit_9) as TextView)

        // Tint the divider to match the disabled control color by default and used the activated
        // control color when there is valid input.
        val dividerContext = mDividerView.context
        val colorControlActivated = ThemeUtils.resolveColor(dividerContext,
                R.attr.colorControlActivated)
        val colorControlDisabled = ThemeUtils.resolveColor(dividerContext,
                R.attr.colorControlNormal, intArrayOf(android.R.attr.state_enabled.inv()))
        ViewCompat.setBackgroundTintList(mDividerView,
                ColorStateList(
                        arrayOf(intArrayOf(android.R.attr.state_activated), intArrayOf()),
                        intArrayOf(colorControlActivated, colorControlDisabled)))
        ViewCompat.setBackgroundTintMode(mDividerView, PorterDuff.Mode.SRC)

        // Initialize the digit buttons.
        val uidm = UiDataModel.uiDataModel
        for (digitView in mDigitViews) {
            val digit = getDigitForId(digitView.id)
            digitView.text = uidm.getFormattedNumber(digit, 1)
            digitView.setOnClickListener(this)
        }

        mDeleteView.setOnClickListener(this)
        mDeleteView.setOnLongClickListener(this)

        updateTime()
        updateDeleteAndDivider()
    }

    fun setFabContainer(fabContainer: FabContainer) {
        mFabContainer = fabContainer
    }

    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
        var view: View? = null
        if (keyCode == KeyEvent.KEYCODE_DEL) {
            view = mDeleteView
        } else if (keyCode >= KeyEvent.KEYCODE_0 && keyCode <= KeyEvent.KEYCODE_9) {
            view = mDigitViews[keyCode - KeyEvent.KEYCODE_0]
        }

        if (view != null) {
            val result = view.performClick()
            if (result && hasValidInput()) {
                mFabContainer.updateFab(FabContainer.FAB_REQUEST_FOCUS)
            }
            return result
        }

        return false
    }

    override fun onClick(view: View) {
        if (view === mDeleteView) {
            delete()
        } else {
            append(getDigitForId(view.id))
        }
    }

    override fun onLongClick(view: View): Boolean {
        if (view === mDeleteView) {
            reset()
            updateFab()
            return true
        }
        return false
    }

    private fun getDigitForId(@IdRes id: Int): Int = when (id) {
        R.id.timer_setup_digit_0 -> 0
        R.id.timer_setup_digit_1 -> 1
        R.id.timer_setup_digit_2 -> 2
        R.id.timer_setup_digit_3 -> 3
        R.id.timer_setup_digit_4 -> 4
        R.id.timer_setup_digit_5 -> 5
        R.id.timer_setup_digit_6 -> 6
        R.id.timer_setup_digit_7 -> 7
        R.id.timer_setup_digit_8 -> 8
        R.id.timer_setup_digit_9 -> 9
        else -> throw IllegalArgumentException("Invalid id: $id")
    }

    private fun updateTime() {
        val seconds = mInput[1] * 10 + mInput[0]
        val minutes = mInput[3] * 10 + mInput[2]
        val hours = mInput[5] * 10 + mInput[4]

        val uidm = UiDataModel.uiDataModel
        mTimeView.text = TextUtils.expandTemplate(mTimeTemplate,
                uidm.getFormattedNumber(hours, 2),
                uidm.getFormattedNumber(minutes, 2),
                uidm.getFormattedNumber(seconds, 2))

        val r = resources
        mTimeView.contentDescription = r.getString(R.string.timer_setup_description,
                r.getQuantityString(R.plurals.hours, hours, hours),
                r.getQuantityString(R.plurals.minutes, minutes, minutes),
                r.getQuantityString(R.plurals.seconds, seconds, seconds))
    }

    private fun updateDeleteAndDivider() {
        val enabled = hasValidInput()
        mDeleteView.isEnabled = enabled
        mDividerView.isActivated = enabled
    }

    private fun updateFab() {
        mFabContainer.updateFab(FabContainer.FAB_SHRINK_AND_EXPAND)
    }

    private fun append(digit: Int) {
        require(!(digit < 0 || digit > 9)) { "Invalid digit: $digit" }

        // Pressing "0" as the first digit does nothing.
        if (mInputPointer == -1 && digit == 0) {
            return
        }

        // No space for more digits, so ignore input.
        if (mInputPointer == mInput.size - 1) {
            return
        }

        // Append the new digit.
        System.arraycopy(mInput, 0, mInput, 1, mInputPointer + 1)
        mInput[0] = digit
        mInputPointer++
        updateTime()

        // Update TalkBack to read the number being deleted.
        mDeleteView.contentDescription = context.getString(
                R.string.timer_descriptive_delete,
                UiDataModel.uiDataModel.getFormattedNumber(digit))

        // Update the fab, delete, and divider when we have valid input.
        if (mInputPointer == 0) {
            updateFab()
            updateDeleteAndDivider()
        }
    }

    private fun delete() {
        // Nothing exists to delete so return.
        if (mInputPointer < 0) {
            return
        }

        System.arraycopy(mInput, 1, mInput, 0, mInputPointer)
        mInput[mInputPointer] = 0
        mInputPointer--
        updateTime()

        // Update TalkBack to read the number being deleted or its original description.
        if (mInputPointer >= 0) {
            mDeleteView.contentDescription = context.getString(
                    R.string.timer_descriptive_delete,
                    UiDataModel.uiDataModel.getFormattedNumber(mInput[0]))
        } else {
            mDeleteView.contentDescription = context.getString(R.string.timer_delete)
        }

        // Update the fab, delete, and divider when we no longer have valid input.
        if (mInputPointer == -1) {
            updateFab()
            updateDeleteAndDivider()
        }
    }

    fun reset() {
        if (mInputPointer != -1) {
            mInput.fill(0)
            mInputPointer = -1
            updateTime()
            updateDeleteAndDivider()
        }
    }

    fun hasValidInput(): Boolean {
        return mInputPointer != -1
    }

    val timeInMillis: Long
        get() {
            val seconds = mInput[1] * 10 + mInput[0]
            val minutes = mInput[3] * 10 + mInput[2]
            val hours = mInput[5] * 10 + mInput[4]
            return seconds * DateUtils.SECOND_IN_MILLIS +
                    minutes * DateUtils.MINUTE_IN_MILLIS +
                    hours * DateUtils.HOUR_IN_MILLIS
        }

    var state: Serializable?
        /**
         * @return an opaque representation of the state of timer setup
         */
        get() = mInput.copyOf(mInput.size)
        /**
         * @param state an opaque state of this view previously produced by [.getState]
         */
        set(state) {
            val input = state as IntArray?
            if (input != null && mInput.size == input.size) {
                for (i in mInput.indices) {
                    mInput[i] = input[i]
                    if (mInput[i] != 0) {
                        mInputPointer = i
                    }
                }
                updateTime()
                updateDeleteAndDivider()
            }
        }
}