| /* |
| * 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 android.content.Context |
| import android.content.res.Configuration |
| import android.os.Handler |
| import android.os.Message |
| import android.text.format.Time |
| import android.util.Log |
| import android.view.GestureDetector |
| import android.view.HapticFeedbackConstants |
| import android.view.MotionEvent |
| import android.view.View |
| import android.view.ViewConfiguration |
| import android.view.ViewGroup |
| import android.widget.AbsListView.LayoutParams |
| import com.android.calendar.CalendarController |
| import com.android.calendar.CalendarController.EventType |
| import com.android.calendar.CalendarController.ViewType |
| import com.android.calendar.Event |
| import com.android.calendar.R |
| import com.android.calendar.Utils |
| import java.util.ArrayList |
| import java.util.HashMap |
| |
| class MonthByWeekAdapter(context: Context?, params: HashMap<String?, Int?>) : |
| SimpleWeeksAdapter(context as Context, params) { |
| protected var mController: CalendarController? = null |
| protected var mHomeTimeZone: String? = null |
| protected var mTempTime: Time? = null |
| protected var mToday: Time? = null |
| protected var mFirstJulianDay = 0 |
| protected var mQueryDays = 0 |
| protected var mIsMiniMonth = true |
| protected var mOrientation: Int = Configuration.ORIENTATION_LANDSCAPE |
| private val mShowAgendaWithMonth: Boolean |
| protected var mEventDayList: ArrayList<ArrayList<Event>> = ArrayList<ArrayList<Event>>() |
| protected var mEvents: ArrayList<Event>? = null |
| private var mAnimateToday = false |
| private var mAnimateTime: Long = 0 |
| private val mEventDialogHandler: Handler? = null |
| var mClickedView: MonthWeekEventsView? = null |
| var mSingleTapUpView: MonthWeekEventsView? = null |
| var mLongClickedView: MonthWeekEventsView? = null |
| var mClickedXLocation = 0f // Used to find which day was clicked |
| var mClickTime: Long = 0 // Used to calculate minimum click animation time |
| |
| fun animateToday() { |
| mAnimateToday = true |
| mAnimateTime = System.currentTimeMillis() |
| } |
| |
| @Override |
| protected override fun init() { |
| super.init() |
| mGestureDetector = GestureDetector(mContext, CalendarGestureListener()) |
| mController = CalendarController.getInstance(mContext) |
| mHomeTimeZone = Utils.getTimeZone(mContext, null) |
| mSelectedDay?.switchTimezone(mHomeTimeZone) |
| mToday = Time(mHomeTimeZone) |
| mToday?.setToNow() |
| mTempTime = Time(mHomeTimeZone) |
| } |
| |
| private fun updateTimeZones() { |
| mSelectedDay!!.timezone = mHomeTimeZone |
| mSelectedDay?.normalize(true) |
| mToday!!.timezone = mHomeTimeZone |
| mToday?.setToNow() |
| mTempTime?.switchTimezone(mHomeTimeZone) |
| } |
| |
| @Override |
| override fun setSelectedDay(selectedTime: Time?) { |
| mSelectedDay?.set(selectedTime) |
| val millis: Long = mSelectedDay!!.normalize(true) |
| mSelectedWeek = Utils.getWeeksSinceEpochFromJulianDay( |
| Time.getJulianDay(millis, mSelectedDay!!.gmtoff), mFirstDayOfWeek |
| ) |
| notifyDataSetChanged() |
| } |
| |
| fun setEvents(firstJulianDay: Int, numDays: Int, events: ArrayList<Event>?) { |
| if (mIsMiniMonth) { |
| if (Log.isLoggable(TAG, Log.ERROR)) { |
| Log.e( |
| TAG, "Attempted to set events for mini view. Events only supported in full" + |
| " view." |
| ) |
| } |
| return |
| } |
| mEvents = events |
| mFirstJulianDay = firstJulianDay |
| mQueryDays = numDays |
| // Create a new list, this is necessary since the weeks are referencing |
| // pieces of the old list |
| val eventDayList: ArrayList<ArrayList<Event>> = ArrayList<ArrayList<Event>>() |
| for (i in 0 until numDays) { |
| eventDayList.add(ArrayList<Event>()) |
| } |
| if (events == null || events.size == 0) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "No events. Returning early--go schedule something fun.") |
| } |
| mEventDayList = eventDayList |
| refresh() |
| return |
| } |
| |
| // Compute the new set of days with events |
| for (event in events) { |
| var startDay: Int = event.startDay - mFirstJulianDay |
| var endDay: Int = event.endDay - mFirstJulianDay + 1 |
| if (startDay < numDays || endDay >= 0) { |
| if (startDay < 0) { |
| startDay = 0 |
| } |
| if (startDay > numDays) { |
| continue |
| } |
| if (endDay < 0) { |
| continue |
| } |
| if (endDay > numDays) { |
| endDay = numDays |
| } |
| for (j in startDay until endDay) { |
| eventDayList.get(j).add(event) |
| } |
| } |
| } |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Processed " + events.size.toString() + " events.") |
| } |
| mEventDayList = eventDayList |
| refresh() |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| override fun getView(position: Int, convertView: View?, parent: ViewGroup): View { |
| if (mIsMiniMonth) { |
| return super.getView(position, convertView, parent) |
| } |
| var v: MonthWeekEventsView |
| val params = LayoutParams( |
| LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT |
| ) |
| var drawingParams: HashMap<String?, Int?>? = null |
| var isAnimatingToday = false |
| if (convertView != null) { |
| v = convertView as MonthWeekEventsView |
| // Checking updateToday uses the current params instead of the new |
| // params, so this is assuming the view is relatively stable |
| if (mAnimateToday && v.updateToday(mSelectedDay!!.timezone)) { |
| val currentTime: Long = System.currentTimeMillis() |
| // If it's been too long since we tried to start the animation |
| // don't show it. This can happen if the user stops a scroll |
| // before reaching today. |
| if (currentTime - mAnimateTime > ANIMATE_TODAY_TIMEOUT) { |
| mAnimateToday = false |
| mAnimateTime = 0 |
| } else { |
| isAnimatingToday = true |
| // There is a bug that causes invalidates to not work some |
| // of the time unless we recreate the view. |
| v = MonthWeekEventsView(mContext) |
| } |
| } else { |
| drawingParams = v.getTag() as HashMap<String?, Int?> |
| } |
| } else { |
| v = MonthWeekEventsView(mContext) |
| } |
| if (drawingParams == null) { |
| drawingParams = HashMap<String?, Int?>() |
| } |
| drawingParams.clear() |
| v.setLayoutParams(params) |
| v.setClickable(true) |
| v.setOnTouchListener(this) |
| var selectedDay = -1 |
| if (mSelectedWeek === position) { |
| selectedDay = mSelectedDay!!.weekDay |
| } |
| drawingParams.put( |
| SimpleWeekView.VIEW_PARAMS_HEIGHT, |
| (parent.getHeight() + parent.getTop()) / mNumWeeks |
| ) |
| drawingParams.put(SimpleWeekView.VIEW_PARAMS_SELECTED_DAY, selectedDay) |
| drawingParams.put(SimpleWeekView.VIEW_PARAMS_SHOW_WK_NUM, if (mShowWeekNumber) 1 else 0) |
| drawingParams.put(SimpleWeekView.VIEW_PARAMS_WEEK_START, mFirstDayOfWeek) |
| drawingParams.put(SimpleWeekView.VIEW_PARAMS_NUM_DAYS, mDaysPerWeek) |
| drawingParams.put(SimpleWeekView.VIEW_PARAMS_WEEK, position) |
| drawingParams.put(SimpleWeekView.VIEW_PARAMS_FOCUS_MONTH, mFocusMonth) |
| drawingParams.put(MonthWeekEventsView.VIEW_PARAMS_ORIENTATION, mOrientation) |
| if (isAnimatingToday) { |
| drawingParams.put(MonthWeekEventsView.VIEW_PARAMS_ANIMATE_TODAY, 1) |
| mAnimateToday = false |
| } |
| v.setWeekParams(drawingParams, mSelectedDay!!.timezone) |
| return v |
| } |
| |
| @Override |
| internal override fun refresh() { |
| mFirstDayOfWeek = Utils.getFirstDayOfWeek(mContext) |
| mShowWeekNumber = Utils.getShowWeekNumber(mContext) |
| mHomeTimeZone = Utils.getTimeZone(mContext, null) |
| mOrientation = mContext.getResources().getConfiguration().orientation |
| updateTimeZones() |
| notifyDataSetChanged() |
| } |
| |
| @Override |
| protected override fun onDayTapped(day: Time) { |
| setDayParameters(day) |
| if (mShowAgendaWithMonth || mIsMiniMonth) { |
| // If agenda view is visible with month view , refresh the views |
| // with the selected day's info |
| mController?.sendEvent( |
| mContext as Object?, EventType.GO_TO, day, day, -1, |
| ViewType.CURRENT, CalendarController.EXTRA_GOTO_DATE, null, null |
| ) |
| } else { |
| // Else , switch to the detailed view |
| mController?.sendEvent( |
| mContext as Object?, EventType.GO_TO, day, day, -1, |
| ViewType.DETAIL, CalendarController.EXTRA_GOTO_DATE |
| or CalendarController.EXTRA_GOTO_BACK_TO_PREVIOUS, null, null |
| ) |
| } |
| } |
| |
| private fun setDayParameters(day: Time) { |
| day.timezone = mHomeTimeZone |
| val currTime = Time(mHomeTimeZone) |
| currTime.set(mController!!.time as Long) |
| day.hour = currTime.hour |
| day.minute = currTime.minute |
| day.allDay = false |
| day.normalize(true) |
| } |
| |
| @Override |
| override fun onTouch(v: View, event: MotionEvent): Boolean { |
| if (v !is MonthWeekEventsView) { |
| return super.onTouch(v, event) |
| } |
| val action: Int = event!!.getAction() |
| |
| // Event was tapped - switch to the detailed view making sure the click animation |
| // is done first. |
| if (mGestureDetector!!.onTouchEvent(event)) { |
| mSingleTapUpView = v as MonthWeekEventsView? |
| val delay: Long = System.currentTimeMillis() - mClickTime |
| // Make sure the animation is visible for at least mOnTapDelay - mOnDownDelay ms |
| mListView?.postDelayed( |
| mDoSingleTapUp, |
| if (delay > mTotalClickDelay) 0 else mTotalClickDelay - delay |
| ) |
| return true |
| } else { |
| // Animate a click - on down: show the selected day in the "clicked" color. |
| // On Up/scroll/move/cancel: hide the "clicked" color. |
| when (action) { |
| MotionEvent.ACTION_DOWN -> { |
| mClickedView = v as MonthWeekEventsView |
| mClickedXLocation = event.getX() |
| mClickTime = System.currentTimeMillis() |
| mListView?.postDelayed(mDoClick, mOnDownDelay.toLong()) |
| } |
| MotionEvent.ACTION_UP, MotionEvent.ACTION_SCROLL, MotionEvent.ACTION_CANCEL -> |
| clearClickedView( |
| v as MonthWeekEventsView? |
| ) |
| MotionEvent.ACTION_MOVE -> // No need to cancel on vertical movement, |
| // ACTION_SCROLL will do that. |
| if (Math.abs(event.getX() - mClickedXLocation) > mMovedPixelToCancel) { |
| clearClickedView(v as MonthWeekEventsView?) |
| } |
| else -> { |
| } |
| } |
| } |
| // Do not tell the frameworks we consumed the touch action so that fling actions can be |
| // processed by the fragment. |
| return false |
| } |
| |
| /** |
| * This is here so we can identify events and process them |
| */ |
| protected inner class CalendarGestureListener : GestureDetector.SimpleOnGestureListener() { |
| @Override |
| override fun onSingleTapUp(e: MotionEvent?): Boolean { |
| return true |
| } |
| |
| @Override |
| override fun onLongPress(e: MotionEvent?) { |
| if (mLongClickedView != null) { |
| val day: Time? = mLongClickedView?.getDayFromLocation(mClickedXLocation) |
| if (day != null) { |
| mLongClickedView?.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS) |
| val message = Message() |
| message.obj = day |
| } |
| mLongClickedView?.clearClickedDay() |
| mLongClickedView = null |
| } |
| } |
| } |
| |
| // Clear the visual cues of the click animation and related running code. |
| private fun clearClickedView(v: MonthWeekEventsView?) { |
| mListView?.removeCallbacks(mDoClick) |
| synchronized(v as Any) { v?.clearClickedDay() } |
| mClickedView = null |
| } |
| |
| // Perform the tap animation in a runnable to allow a delay before showing the tap color. |
| // This is done to prevent a click animation when a fling is done. |
| private val mDoClick: Runnable = object : Runnable { |
| @Override |
| override fun run() { |
| if (mClickedView != null) { |
| synchronized(mClickedView as MonthWeekEventsView) { |
| mClickedView?.setClickedDay(mClickedXLocation) } |
| mLongClickedView = mClickedView |
| mClickedView = null |
| // This is a workaround , sometimes the top item on the listview doesn't refresh on |
| // invalidate, so this forces a re-draw. |
| mListView?.invalidate() |
| } |
| } |
| } |
| |
| // Performs the single tap operation: go to the tapped day. |
| // This is done in a runnable to allow the click animation to finish before switching views |
| private val mDoSingleTapUp: Runnable = object : Runnable { |
| @Override |
| override fun run() { |
| if (mSingleTapUpView != null) { |
| val day: Time? = mSingleTapUpView?.getDayFromLocation(mClickedXLocation) |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d( |
| TAG, |
| "Touched day at Row=" + mSingleTapUpView?.mWeek?.toString() + |
| " day=" + day?.toString() |
| ) |
| } |
| if (day != null) { |
| onDayTapped(day) |
| } |
| clearClickedView(mSingleTapUpView) |
| mSingleTapUpView = null |
| } |
| } |
| } |
| |
| companion object { |
| private const val TAG = "MonthByWeekAdapter" |
| const val WEEK_PARAMS_IS_MINI = "mini_month" |
| protected var DEFAULT_QUERY_DAYS = 7 * 8 // 8 weeks |
| private const val ANIMATE_TODAY_TIMEOUT: Long = 1000 |
| |
| // Used to insure minimal time for seeing the click animation before switching views |
| private const val mOnTapDelay = 100 |
| |
| // Minimal time for a down touch action before stating the click animation, this ensures |
| // that there is no click animation on flings |
| private var mOnDownDelay: Int = 0 |
| private var mTotalClickDelay: Int = 0 |
| |
| // Minimal distance to move the finger in order to cancel the click animation |
| private var mMovedPixelToCancel: Float = 0f |
| } |
| |
| init { |
| if (params.containsKey(WEEK_PARAMS_IS_MINI)) { |
| mIsMiniMonth = params.get(WEEK_PARAMS_IS_MINI) != 0 |
| } |
| mShowAgendaWithMonth = Utils.getConfigBool(context as Context, |
| R.bool.show_agenda_with_month) |
| val vc: ViewConfiguration = ViewConfiguration.get(context) |
| mOnDownDelay = ViewConfiguration.getTapTimeout() |
| mMovedPixelToCancel = vc.getScaledTouchSlop().toFloat() |
| mTotalClickDelay = mOnDownDelay + mOnTapDelay |
| } |
| } |
