content: /*
   * Copyright (C) 2008 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 android.widget;
  
  import android.content.Context;
  import android.content.Intent;
  import android.content.res.TypedArray;
  import android.icu.text.MeasureFormat;
  import android.icu.text.MeasureFormat.FormatWidth;
  import android.icu.util.Measure;
  import android.icu.util.MeasureUnit;
  import android.net.Uri;
  import android.os.SystemClock;
  import android.text.format.DateUtils;
  import android.util.AttributeSet;
  import android.util.Log;
  import android.view.View;
  import android.view.inspector.InspectableProperty;
  import android.widget.RemoteViews.RemoteView;
  
  import com.android.internal.R;
  
  import java.util.ArrayList;
  import java.util.Formatter;
  import java.util.IllegalFormatException;
  import java.util.Locale;
  
  /**
   * Class that implements a simple timer.
   * <p>
   * You can give it a start time in the {@link SystemClock#elapsedRealtime} timebase,
   * and it counts up from that, or if you don't give it a base time, it will use the
   * time at which you call {@link #start}.
   *
   * <p>The timer can also count downward towards the base time by
   * setting {@link #setCountDown(boolean)} to true.
   *
   *  <p>By default it will display the current
   * timer value in the form "MM:SS" or "H:MM:SS", or you can use {@link #setFormat}
   * to format the timer value into an arbitrary string.
   *
   * @attr ref android.R.styleable#Chronometer_format
   * @attr ref android.R.styleable#Chronometer_countDown
   */
  @RemoteView
  public class Chronometer extends TextView {
      private static final String TAG = "Chronometer";
  
      /**
       * A callback that notifies when the chronometer has incremented on its own.
       */
      public interface OnChronometerTickListener {
  
          /**
           * Notification that the chronometer has changed.
           */
          void onChronometerTick(Chronometer chronometer);
  
      }
  
      private long mBase;
      private long mNow; // the currently displayed time
      private boolean mVisible;
      private boolean mStarted;
      private boolean mRunning;
      private boolean mLogged;
      private String mFormat;
      private Formatter mFormatter;
      private Locale mFormatterLocale;
      private Object[] mFormatterArgs = new Object[1];
      private StringBuilder mFormatBuilder;
      private OnChronometerTickListener mOnChronometerTickListener;
      private StringBuilder mRecycle = new StringBuilder(8);
      private boolean mCountDown;
  
      /**
       * Initialize this Chronometer object.
       * Sets the base to the current time.
       */
      public Chronometer(Context context) {
          this(context, null, 0);
      }
  
      /**
       * Initialize with standard view layout information.
       * Sets the base to the current time.
       */
      public Chronometer(Context context, AttributeSet attrs) {
          this(context, attrs, 0);
      }
  
      /**
       * Initialize with standard view layout information and style.
       * Sets the base to the current time.
       */
      public Chronometer(Context context, AttributeSet attrs, int defStyleAttr) {
          this(context, attrs, defStyleAttr, 0);
      }
  
      public Chronometer(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
          super(context, attrs, defStyleAttr, defStyleRes);
  
          final TypedArray a = context.obtainStyledAttributes(
                  attrs, com.android.internal.R.styleable.Chronometer, defStyleAttr, defStyleRes);
          saveAttributeDataForStyleable(context, com.android.internal.R.styleable.Chronometer,
                  attrs, a, defStyleAttr, defStyleRes);
          setFormat(a.getString(R.styleable.Chronometer_format));
          setCountDown(a.getBoolean(R.styleable.Chronometer_countDown, false));
          a.recycle();
  
          init();
      }
  
      private void init() {
          mBase = SystemClock.elapsedRealtime();
          updateText(mBase);
      }
  
      /**
       * Set this view to count down to the base instead of counting up from it.
       *
       * @param countDown whether this view should count down
       *
       * @see #setBase(long)
       */
      @android.view.RemotableViewMethod
      public void setCountDown(boolean countDown) {
          mCountDown = countDown;
          updateText(SystemClock.elapsedRealtime());
      }
  
      /**
       * @return whether this view counts down
       *
       * @see #setCountDown(boolean)
       */
      @InspectableProperty
      public boolean isCountDown() {
          return mCountDown;
      }
  
      /**
       * @return whether this is the final countdown
       */
      public boolean isTheFinalCountDown() {
          try {
              getContext().startActivity(
                      new Intent(Intent.ACTION_VIEW, Uri.parse("https://youtu.be/9jK-NcRmVcw"))
                              .addCategory(Intent.CATEGORY_BROWSABLE)
                              .addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT
                                      | Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT));
              return true;
          } catch (Exception e) {
              return false;
          }
      }
  
      /**
       * Set the time that the count-up timer is in reference to.
       *
       * @param base Use the {@link SystemClock#elapsedRealtime} time base.
       */
      @android.view.RemotableViewMethod
      public void setBase(long base) {
          mBase = base;
          dispatchChronometerTick();
          updateText(SystemClock.elapsedRealtime());
      }
  
      /**
       * Return the base time as set through {@link #setBase}.
       */
      public long getBase() {
          return mBase;
      }
  
      /**
       * Sets the format string used for display.  The Chronometer will display
       * this string, with the first "%s" replaced by the current timer value in
       * "MM:SS" or "H:MM:SS" form.
       *
       * If the format string is null, or if you never call setFormat(), the
       * Chronometer will simply display the timer value in "MM:SS" or "H:MM:SS"
       * form.
       *
       * @param format the format string.
       */
      @android.view.RemotableViewMethod
      public void setFormat(String format) {
          mFormat = format;
          if (format != null && mFormatBuilder == null) {
              mFormatBuilder = new StringBuilder(format.length() * 2);
          }
      }
  
      /**
       * Returns the current format string as set through {@link #setFormat}.
       */
      @InspectableProperty
      public String getFormat() {
          return mFormat;
      }
  
      /**
       * Sets the listener to be called when the chronometer changes.
       *
       * @param listener The listener.
       */
      public void setOnChronometerTickListener(OnChronometerTickListener listener) {
          mOnChronometerTickListener = listener;
      }
  
      /**
       * @return The listener (may be null) that is listening for chronometer change
       *         events.
       */
      public OnChronometerTickListener getOnChronometerTickListener() {
          return mOnChronometerTickListener;
      }
  
      /**
       * Start counting up.  This does not affect the base as set from {@link #setBase}, just
       * the view display.
       *
       * Chronometer works by regularly scheduling messages to the handler, even when the
       * Widget is not visible.  To make sure resource leaks do not occur, the user should
       * make sure that each start() call has a reciprocal call to {@link #stop}.
       */
      public void start() {
          mStarted = true;
          updateRunning();
      }
  
      /**
       * Stop counting up.  This does not affect the base as set from {@link #setBase}, just
       * the view display.
       *
       * This stops the messages to the handler, effectively releasing resources that would
       * be held as the chronometer is running, via {@link #start}.
       */
      public void stop() {
          mStarted = false;
          updateRunning();
      }
  
      /**
       * The same as calling {@link #start} or {@link #stop}.
       * @hide pending API council approval
       */
      @android.view.RemotableViewMethod
      public void setStarted(boolean started) {
          mStarted = started;
          updateRunning();
      }
  
      @Override
      protected void onDetachedFromWindow() {
          super.onDetachedFromWindow();
          mVisible = false;
          updateRunning();
      }
  
      @Override
      protected void onWindowVisibilityChanged(int visibility) {
          super.onWindowVisibilityChanged(visibility);
          mVisible = visibility == VISIBLE;
          updateRunning();
      }
  
      @Override
      protected void onVisibilityChanged(View changedView, int visibility) {
          super.onVisibilityChanged(changedView, visibility);
          updateRunning();
      }
  
      private synchronized void updateText(long now) {
          mNow = now;
          long seconds = mCountDown ? mBase - now : now - mBase;
          seconds /= 1000;
          boolean negative = false;
          if (seconds < 0) {
              seconds = -seconds;
              negative = true;
          }
          String text = DateUtils.formatElapsedTime(mRecycle, seconds);
          if (negative) {
              text = getResources().getString(R.string.negative_duration, text);
          }
  
          if (mFormat != null) {
              Locale loc = Locale.getDefault();
              if (mFormatter == null || !loc.equals(mFormatterLocale)) {
                  mFormatterLocale = loc;
                  mFormatter = new Formatter(mFormatBuilder, loc);
              }
              mFormatBuilder.setLength(0);
              mFormatterArgs[0] = text;
              try {
                  mFormatter.format(mFormat, mFormatterArgs);
                  text = mFormatBuilder.toString();
              } catch (IllegalFormatException ex) {
                  if (!mLogged) {
                      Log.w(TAG, "Illegal format string: " + mFormat);
                      mLogged = true;
                  }
              }
          }
          setText(text);
      }
  
      private void updateRunning() {
          boolean running = mVisible && mStarted && isShown();
          if (running != mRunning) {
              if (running) {
                  updateText(SystemClock.elapsedRealtime());
                  dispatchChronometerTick();
                  postDelayed(mTickRunnable, 1000);
              } else {
                  removeCallbacks(mTickRunnable);
              }
              mRunning = running;
          }
      }
  
      private final Runnable mTickRunnable = new Runnable() {
          @Override
          public void run() {
              if (mRunning) {
                  updateText(SystemClock.elapsedRealtime());
                  dispatchChronometerTick();
                  postDelayed(mTickRunnable, 1000);
              }
          }
      };
  
      void dispatchChronometerTick() {
          if (mOnChronometerTickListener != null) {
              mOnChronometerTickListener.onChronometerTick(this);
          }
      }
  
      private static final int MIN_IN_SEC = 60;
      private static final int HOUR_IN_SEC = MIN_IN_SEC*60;
      private static String formatDuration(long ms) {
          int duration = (int) (ms / DateUtils.SECOND_IN_MILLIS);
          if (duration < 0) {
              duration = -duration;
          }
  
          int h = 0;
          int m = 0;
  
          if (duration >= HOUR_IN_SEC) {
              h = duration / HOUR_IN_SEC;
              duration -= h * HOUR_IN_SEC;
          }
          if (duration >= MIN_IN_SEC) {
              m = duration / MIN_IN_SEC;
              duration -= m * MIN_IN_SEC;
          }
          final int s = duration;
  
          final ArrayList<Measure> measures = new ArrayList<Measure>();
          if (h > 0) {
              measures.add(new Measure(h, MeasureUnit.HOUR));
          }
          if (m > 0) {
              measures.add(new Measure(m, MeasureUnit.MINUTE));
          }
          measures.add(new Measure(s, MeasureUnit.SECOND));
  
          return MeasureFormat.getInstance(Locale.getDefault(), FormatWidth.WIDE)
                      .formatMeasures(measures.toArray(new Measure[measures.size()]));
      }
  
      @Override
      public CharSequence getContentDescription() {
          return formatDuration(mNow - mBase);
      }
  
      @Override
      public CharSequence getAccessibilityClassName() {
          return Chronometer.class.getName();
      }
  }
  