calendar/month/SimpleDayPickerFragment.kt

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

import com.android.calendar.R
import com.android.calendar.Utils
import android.app.Activity
import android.app.ListFragment
import android.content.Context
import android.content.res.Resources
import android.database.DataSetObserver
import android.os.Bundle
import android.os.Handler
import android.text.TextUtils
import android.text.format.DateUtils
import android.text.format.Time
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewConfiguration
import android.view.ViewGroup
import android.view.accessibility.AccessibilityEvent
import android.widget.AbsListView
import android.widget.AbsListView.OnScrollListener
import android.widget.ListView
import android.widget.TextView
import java.util.Calendar
import java.util.HashMap
import java.util.Locale

/**
 *
 *
 * This displays a titled list of weeks with selectable days. It can be
 * configured to display the week number, start the week on a given day, show a
 * reduced number of days, or display an arbitrary number of weeks at a time. By
 * overriding methods and changing variables this fragment can be customized to
 * easily display a month selection component in a given style.
 *
 */
open class SimpleDayPickerFragment(initialTime: Long) : ListFragment(), OnScrollListener {
    protected var WEEK_MIN_VISIBLE_HEIGHT = 12
    protected var BOTTOM_BUFFER = 20
    protected var mSaturdayColor = 0
    protected var mSundayColor = 0
    protected var mDayNameColor = 0

    // You can override these numbers to get a different appearance
    @JvmField protected var mNumWeeks = 6
    @JvmField protected var mShowWeekNumber = false
    @JvmField protected var mDaysPerWeek = 7

    // These affect the scroll speed and feel
    protected var mFriction = 1.0f
    @JvmField protected var mContext: Context? = null
    @JvmField protected var mHandler: Handler = Handler()
    protected var mMinimumFlingVelocity = 0f

    // highlighted time
    @JvmField protected var mSelectedDay: Time = Time()
    @JvmField protected var mAdapter: SimpleWeeksAdapter? = null
    @JvmField protected var mListView: ListView? = null
    @JvmField protected var mDayNamesHeader: ViewGroup? = null
    @JvmField protected var mDayLabels: Array<String?> = arrayOfNulls(7)

    // disposable variable used for time calculations
    @JvmField protected var mTempTime: Time = Time()

    // When the week starts; numbered like Time.<WEEKDAY> (e.g. SUNDAY=0).
    @JvmField protected var mFirstDayOfWeek = 0

    // The first day of the focus month
    @JvmField protected var mFirstDayOfMonth: Time = Time()

    // The first day that is visible in the view
    @JvmField protected var mFirstVisibleDay: Time = Time()

    // The name of the month to display
    protected var mMonthName: TextView? = null

    // The last name announced by accessibility
    protected var mPrevMonthName: CharSequence? = null

    // which month should be displayed/highlighted [0-11]
    protected var mCurrentMonthDisplayed = 0

    // used for tracking during a scroll
    protected var mPreviousScrollPosition: Long = 0

    // used for tracking which direction the view is scrolling
    protected var mIsScrollingUp = false

    // used for tracking what state listview is in
    protected var mPreviousScrollState: Int = OnScrollListener.SCROLL_STATE_IDLE

    // used for tracking what state listview is in
    protected var mCurrentScrollState: Int = OnScrollListener.SCROLL_STATE_IDLE

    // This causes an update of the view at midnight
    @JvmField protected var mTodayUpdater: Runnable = object : Runnable {
        @Override
        override fun run() {
            val midnight = Time(mFirstVisibleDay.timezone)
            midnight.setToNow()
            val currentMillis: Long = midnight.toMillis(true)
            midnight.hour = 0
            midnight.minute = 0
            midnight.second = 0
            midnight.monthDay++
            val millisToMidnight: Long = midnight.normalize(true) - currentMillis
            mHandler.postDelayed(this, millisToMidnight)
            if (mAdapter != null) {
                mAdapter?.notifyDataSetChanged()
            }
        }
    }

    // This allows us to update our position when a day is tapped
    @JvmField protected var mObserver: DataSetObserver = object : DataSetObserver() {
        @Override
        override fun onChanged() {
            val day: Time? = mAdapter!!.getSelectedDay()
            if (day!!.year !== mSelectedDay.year || day!!.yearDay !== mSelectedDay.yearDay) {
                goTo(day!!.toMillis(true), true, true, false)
            }
        }
    }

    @Override
    override fun onAttach(activity: Activity) {
        super.onAttach(activity)
        mContext = activity
        val tz: String = Time.getCurrentTimezone()
        val viewConfig: ViewConfiguration = ViewConfiguration.get(activity)
        mMinimumFlingVelocity = (viewConfig.getScaledMinimumFlingVelocity()).toFloat()

        // Ensure we're in the correct time zone
        mSelectedDay.switchTimezone(tz)
        mSelectedDay.normalize(true)
        mFirstDayOfMonth.timezone = tz
        mFirstDayOfMonth.normalize(true)
        mFirstVisibleDay.timezone = tz
        mFirstVisibleDay.normalize(true)
        mTempTime.timezone = tz
        val res: Resources = activity.getResources()
        mSaturdayColor = res.getColor(R.color.month_saturday)
        mSundayColor = res.getColor(R.color.month_sunday)
        mDayNameColor = res.getColor(R.color.month_day_names_color)

        // Adjust sizes for screen density
        if (mScale == 0f) {
            mScale = activity.getResources().getDisplayMetrics().density
            if (mScale != 1f) {
                WEEK_MIN_VISIBLE_HEIGHT *= mScale.toInt()
                BOTTOM_BUFFER *= mScale.toInt()
                LIST_TOP_OFFSET *= mScale.toInt()
            }
        }
        setUpAdapter()
        setListAdapter(mAdapter)
    }

    /**
     * Creates a new adapter if necessary and sets up its parameters. Override
     * this method to provide a custom adapter.
     */
    protected open fun setUpAdapter() {
        val weekParams = HashMap<String?, Int?>()
        weekParams.put(SimpleWeeksAdapter.WEEK_PARAMS_NUM_WEEKS, mNumWeeks)
        weekParams.put(SimpleWeeksAdapter.WEEK_PARAMS_SHOW_WEEK, if (mShowWeekNumber) 1 else 0)
        weekParams.put(SimpleWeeksAdapter.WEEK_PARAMS_WEEK_START, mFirstDayOfWeek)
        weekParams.put(SimpleWeeksAdapter.WEEK_PARAMS_JULIAN_DAY,
                Time.getJulianDay(mSelectedDay.toMillis(false), mSelectedDay.gmtoff))
        if (mAdapter == null) {
            mAdapter = SimpleWeeksAdapter(getActivity(), weekParams)
            mAdapter?.registerDataSetObserver(mObserver)
        } else {
            mAdapter?.updateParams(weekParams)
        }
        // refresh the view with the new parameters
        mAdapter?.notifyDataSetChanged()
    }

    @Override
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
    }

    @Override
    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        setUpListView()
        setUpHeader()
        mMonthName = getView()?.findViewById(R.id.month_name) as? TextView
        val child = mListView?.getChildAt(0) as? SimpleWeekView
        if (child == null) {
            return
        }
        val julianDay: Int = child.getFirstJulianDay()
        mFirstVisibleDay.setJulianDay(julianDay)
        // set the title to the month of the second week
        mTempTime.setJulianDay(julianDay + DAYS_PER_WEEK)
        setMonthDisplayed(mTempTime, true)
    }

    /**
     * Sets up the strings to be used by the header. Override this method to use
     * different strings or modify the view params.
     */
    protected open fun setUpHeader() {
        mDayLabels = arrayOfNulls(7)
        for (i in Calendar.SUNDAY..Calendar.SATURDAY) {
            mDayLabels[i - Calendar.SUNDAY] = DateUtils.getDayOfWeekString(i,
                    DateUtils.LENGTH_SHORTEST).toUpperCase()
        }
    }

    /**
     * Sets all the required fields for the list view. Override this method to
     * set a different list view behavior.
     */
    protected fun setUpListView() {
        // Configure the listview
        mListView = getListView()
        // Transparent background on scroll
        mListView?.setCacheColorHint(0)
        // No dividers
        mListView?.setDivider(null)
        // Items are clickable
        mListView?.setItemsCanFocus(true)
        // The thumb gets in the way, so disable it
        mListView?.setFastScrollEnabled(false)
        mListView?.setVerticalScrollBarEnabled(false)
        mListView?.setOnScrollListener(this)
        mListView?.setFadingEdgeLength(0)
        // Make the scrolling behavior nicer
        mListView?.setFriction(ViewConfiguration.getScrollFriction() * mFriction)
    }

    @Override
    override fun onResume() {
        super.onResume()
        setUpAdapter()
        doResumeUpdates()
    }

    @Override
    override fun onPause() {
        super.onPause()
        mHandler.removeCallbacks(mTodayUpdater)
    }

    @Override
    override fun onSaveInstanceState(outState: Bundle) {
        outState.putLong(KEY_CURRENT_TIME, mSelectedDay.toMillis(true))
    }

    /**
     * Updates the user preference fields. Override this to use a different
     * preference space.
     */
    protected open fun doResumeUpdates() {
        // Get default week start based on locale, subtracting one for use with android Time.
        val cal: Calendar = Calendar.getInstance(Locale.getDefault())
        mFirstDayOfWeek = cal.getFirstDayOfWeek() - 1
        mShowWeekNumber = false
        updateHeader()
        goTo(mSelectedDay.toMillis(true), false, false, false)
        mAdapter?.setSelectedDay(mSelectedDay)
        mTodayUpdater.run()
    }

    /**
     * Fixes the day names header to provide correct spacing and updates the
     * label text. Override this to set up a custom header.
     */
    protected fun updateHeader() {
        var label: TextView = mDayNamesHeader!!.findViewById(R.id.wk_label) as TextView
        if (mShowWeekNumber) {
            label.setVisibility(View.VISIBLE)
        } else {
            label.setVisibility(View.GONE)
        }
        val offset = mFirstDayOfWeek - 1
        for (i in 1..7) {
            label = mDayNamesHeader!!.getChildAt(i) as TextView
            if (i < mDaysPerWeek + 1) {
                val position = (offset + i) % 7
                label.setText(mDayLabels[position])
                label.setVisibility(View.VISIBLE)
                if (position == Time.SATURDAY) {
                    label.setTextColor(mSaturdayColor)
                } else if (position == Time.SUNDAY) {
                    label.setTextColor(mSundayColor)
                } else {
                    label.setTextColor(mDayNameColor)
                }
            } else {
                label.setVisibility(View.GONE)
            }
        }
        mDayNamesHeader?.invalidate()
    }

    @Override
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        val v: View = inflater.inflate(R.layout.month_by_week,
                container, false)
        mDayNamesHeader = v.findViewById(R.id.day_names) as ViewGroup
        return v
    }

    /**
     * Returns the UTC millis since epoch representation of the currently
     * selected time.
     *
     * @return
     */
    val selectedTime: Long
        get() = mSelectedDay.toMillis(true)

    /**
     * This moves to the specified time in the view. If the time is not already
     * in range it will move the list so that the first of the month containing
     * the time is at the top of the view. If the new time is already in view
     * the list will not be scrolled unless forceScroll is true. This time may
     * optionally be highlighted as selected as well.
     *
     * @param time The time to move to
     * @param animate Whether to scroll to the given time or just redraw at the
     * new location
     * @param setSelected Whether to set the given time as selected
     * @param forceScroll Whether to recenter even if the time is already
     * visible
     * @return Whether or not the view animated to the new location
     */
    fun goTo(time: Long, animate: Boolean, setSelected: Boolean, forceScroll: Boolean): Boolean {
        if (time == -1L) {
            Log.e(TAG, "time is invalid")
            return false
        }

        // Set the selected day
        if (setSelected) {
            mSelectedDay.set(time)
            mSelectedDay.normalize(true)
        }

        // If this view isn't returned yet we won't be able to load the lists
        // current position, so return after setting the selected day.
        if (!isResumed()) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "We're not visible yet")
            }
            return false
        }
        mTempTime.set(time)
        var millis: Long = mTempTime.normalize(true)
        // Get the week we're going to
        // TODO push Util function into Calendar public api.
        var position: Int = Utils.getWeeksSinceEpochFromJulianDay(
                Time.getJulianDay(millis, mTempTime.gmtoff), mFirstDayOfWeek)
        var child: View?
        var i = 0
        var top = 0
        // Find a child that's completely in the view
        do {
            child = mListView?.getChildAt(i++)
            if (child == null) {
                break
            }
            top = child.getTop()
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "child at " + (i - 1) + " has top " + top)
            }
        } while (top < 0)

        // Compute the first and last position visible
        val firstPosition: Int
        firstPosition = if (child != null) {
            mListView!!.getPositionForView(child)
        } else {
            0
        }
        var lastPosition = firstPosition + mNumWeeks - 1
        if (top > BOTTOM_BUFFER) {
            lastPosition--
        }
        if (setSelected) {
            mAdapter?.setSelectedDay(mSelectedDay)
        }
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "GoTo position $position")
        }
        // Check if the selected day is now outside of our visible range
        // and if so scroll to the month that contains it
        if (position < firstPosition || position > lastPosition || forceScroll) {
            mFirstDayOfMonth.set(mTempTime)
            mFirstDayOfMonth.monthDay = 1
            millis = mFirstDayOfMonth.normalize(true)
            setMonthDisplayed(mFirstDayOfMonth, true)
            position = Utils.getWeeksSinceEpochFromJulianDay(
                    Time.getJulianDay(millis, mFirstDayOfMonth.gmtoff), mFirstDayOfWeek)
            mPreviousScrollState = OnScrollListener.SCROLL_STATE_FLING
            if (animate) {
                mListView?.smoothScrollToPositionFromTop(
                        position, LIST_TOP_OFFSET, GOTO_SCROLL_DURATION)
                return true
            } else {
                mListView?.setSelectionFromTop(position, LIST_TOP_OFFSET)
                // Perform any after scroll operations that are needed
                onScrollStateChanged(mListView, OnScrollListener.SCROLL_STATE_IDLE)
            }
        } else if (setSelected) {
            // Otherwise just set the selection
            setMonthDisplayed(mSelectedDay, true)
        }
        return false
    }

    /**
     * Updates the title and selected month if the view has moved to a new
     * month.
     */
    @Override
    override fun onScroll(
        view: AbsListView,
        firstVisibleItem: Int,
        visibleItemCount: Int,
        totalItemCount: Int
    ) {
        val child = view.getChildAt(0) as? SimpleWeekView
        if (child == null) {
            return
        }

        // Figure out where we are
        val currScroll: Long = (view.getFirstVisiblePosition() * child.getHeight() -
                                child.getBottom()).toLong()
        mFirstVisibleDay.setJulianDay(child.getFirstJulianDay())

        // If we have moved since our last call update the direction
        mIsScrollingUp = if (currScroll < mPreviousScrollPosition) {
            true
        } else if (currScroll > mPreviousScrollPosition) {
            false
        } else {
            return
        }
        mPreviousScrollPosition = currScroll
        mPreviousScrollState = mCurrentScrollState
        updateMonthHighlight(mListView as? AbsListView)
    }

    /**
     * Figures out if the month being shown has changed and updates the
     * highlight if needed
     *
     * @param view The ListView containing the weeks
     */
    private fun updateMonthHighlight(view: AbsListView?) {
        var child = view?.getChildAt(0) as? SimpleWeekView
        if (child == null) {
            return
        }

        // Figure out where we are
        val offset = if (child.getBottom() < WEEK_MIN_VISIBLE_HEIGHT) 1 else 0
        // Use some hysteresis for checking which month to highlight. This
        // causes the month to transition when two full weeks of a month are
        // visible.
        child = view?.getChildAt(SCROLL_HYST_WEEKS + offset) as? SimpleWeekView
        if (child == null) {
            return
        }

        // Find out which month we're moving into
        val month: Int
        month = if (mIsScrollingUp) {
            child.getFirstMonth()
        } else {
            child.getLastMonth()
        }

        // And how it relates to our current highlighted month
        val monthDiff: Int
        monthDiff = if (mCurrentMonthDisplayed == 11 && month == 0) {
            1
        } else if (mCurrentMonthDisplayed == 0 && month == 11) {
            -1
        } else {
            month - mCurrentMonthDisplayed
        }

        // Only switch months if we're scrolling away from the currently
        // selected month
        if (monthDiff != 0) {
            var julianDay: Int = child.getFirstJulianDay()
            if (mIsScrollingUp) {
                // Takes the start of the week
            } else {
                // Takes the start of the following week
                julianDay += DAYS_PER_WEEK
            }
            mTempTime.setJulianDay(julianDay)
            setMonthDisplayed(mTempTime, false)
        }
    }

    /**
     * Sets the month displayed at the top of this view based on time. Override
     * to add custom events when the title is changed.
     *
     * @param time A day in the new focus month.
     * @param updateHighlight TODO(epastern):
     */
    protected open fun setMonthDisplayed(time: Time, updateHighlight: Boolean) {
        val oldMonth: CharSequence = mMonthName!!.getText()
        mMonthName?.setText(Utils.formatMonthYear(mContext, time))
        mMonthName?.invalidate()
        if (!TextUtils.equals(oldMonth, mMonthName?.getText())) {
            mMonthName?.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED)
        }
        mCurrentMonthDisplayed = time.month
        if (updateHighlight) {
            mAdapter?.updateFocusMonth(mCurrentMonthDisplayed)
        }
    }

    @Override
    override fun onScrollStateChanged(view: AbsListView?, scrollState: Int) {
        // use a post to prevent re-entering onScrollStateChanged before it
        // exits
        mScrollStateChangedRunnable.doScrollStateChange(view, scrollState)
    }

    @JvmField protected var mScrollStateChangedRunnable: ScrollStateRunnable = ScrollStateRunnable()

    protected inner class ScrollStateRunnable : Runnable {
        private var mNewState = 0

        /**
         * Sets up the runnable with a short delay in case the scroll state
         * immediately changes again.
         *
         * @param view The list view that changed state
         * @param scrollState The new state it changed to
         */
        fun doScrollStateChange(view: AbsListView?, scrollState: Int) {
            mHandler.removeCallbacks(this)
            mNewState = scrollState
            mHandler.postDelayed(this, SCROLL_CHANGE_DELAY.toLong())
        }

        override fun run() {
            mCurrentScrollState = mNewState
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG,
                        "new scroll state: $mNewState old state: $mPreviousScrollState")
            }
            // Fix the position after a scroll or a fling ends
            if (mNewState == OnScrollListener.SCROLL_STATE_IDLE &&
                    mPreviousScrollState != OnScrollListener.SCROLL_STATE_IDLE) {
                mPreviousScrollState = mNewState
                mAdapter?.updateFocusMonth(mCurrentMonthDisplayed)
            } else {
                mPreviousScrollState = mNewState
            }
        }
    }

    companion object {
        private const val TAG = "MonthFragment"
        private const val KEY_CURRENT_TIME = "current_time"

        // Affects when the month selection will change while scrolling up
        protected const val SCROLL_HYST_WEEKS = 2

        // How long the GoTo fling animation should last
        @JvmStatic protected val GOTO_SCROLL_DURATION = 500

        // How long to wait after receiving an onScrollStateChanged notification
        // before acting on it
        protected const val SCROLL_CHANGE_DELAY = 40

        // The number of days to display in each week
        const val DAYS_PER_WEEK = 7

        // The size of the month name displayed above the week list
        protected const val MINI_MONTH_NAME_TEXT_SIZE = 18
        var LIST_TOP_OFFSET = -1 // so that the top line will be under the separator
        private var mScale = 0f
    }

    init {
        goTo(initialTime, false, true, true)
        mHandler = Handler()
    }
}