9

我确实有一项服务在后台运行。每当它启动时，我都会在内存中存储启动时间（以毫秒为单位）： 

startingTime = new Date().getTime();

我想显示一个计时器，它在服务启动时开始计数，并且在用户按下按钮之前永远不会停止。我想让用户离开渲染计时器的活动，做一些事情然后返回。但想法是，当用户返回时，我不希望计时器再次进入 0:00。Insted 我希望它显示自服务启动以来经过的确切时间。

每次用户返回计时器活动时，我都可以计算 elapsedTime：

elapsedTime =  new Date().getTime() - startingTime;

问题是我不知道如何告诉计时器从那个时候开始计数！

将其设置为天文台底座不起作用。有人可以解释一下“基础”的确切含义或如何实现这一点吗？

多谢！再见

4

7 回答 7

21

您可以使用Chronometer。

您还应该检查这个线程。

编辑：解决方案：

public class ChronoExample extends Activity {
 Chronometer mChronometer;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);

     LinearLayout layout = new LinearLayout(this);
     layout.setOrientation(LinearLayout.VERTICAL);

     mChronometer = new Chronometer(this);

     // Set the initial value
     mChronometer.setText("00:10");
     layout.addView(mChronometer);

     Button startButton = new Button(this);
     startButton.setText("Start");
     startButton.setOnClickListener(mStartListener);
     layout.addView(startButton);

     Button stopButton = new Button(this);
     stopButton.setText("Stop");
     stopButton.setOnClickListener(mStopListener);
     layout.addView(stopButton);

     Button resetButton = new Button(this);
     resetButton.setText("Reset");
     resetButton.setOnClickListener(mResetListener);
     layout.addView(resetButton);        

     setContentView(layout);
 }

 private void showElapsedTime() {
     long elapsedMillis = SystemClock.elapsedRealtime() - mChronometer.getBase();            
     Toast.makeText(ChronoExample.this, "Elapsed milliseconds: " + elapsedMillis, 
             Toast.LENGTH_SHORT).show();
 }

 View.OnClickListener mStartListener = new OnClickListener() {
     public void onClick(View v) {
      int stoppedMilliseconds = 0;

         String chronoText = mChronometer.getText().toString();
         String array[] = chronoText.split(":");
         if (array.length == 2) {
           stoppedMilliseconds = Integer.parseInt(array[0]) * 60 * 1000
               + Integer.parseInt(array[1]) * 1000;
         } else if (array.length == 3) {
           stoppedMilliseconds = Integer.parseInt(array[0]) * 60 * 60 * 1000 
               + Integer.parseInt(array[1]) * 60 * 1000
               + Integer.parseInt(array[2]) * 1000;
         }

         mChronometer.setBase(SystemClock.elapsedRealtime() - stoppedMilliseconds);
         mChronometer.start();
     }
 };

 View.OnClickListener mStopListener = new OnClickListener() {
     public void onClick(View v) {
         mChronometer.stop();
         showElapsedTime();
     }
 };

 View.OnClickListener mResetListener = new OnClickListener() {
     public void onClick(View v) {
         mChronometer.setBase(SystemClock.elapsedRealtime());
         showElapsedTime();
     }
 };
}
于 2010-02-25T11:25:13.213 回答
9

要启动计时器，您应该使用计时器的setBase()方法SystemClock.elapsedRealTime()。像这样：

mChronometer.setBase(SystemClock.elapsedRealTime())

但是如果你想在另一个时间开始，你必须减去你想要的时间，以毫秒为单位。例如，您想在 10 秒时启动 Chronometer：

mChronometer.setBase(SystemClock.elapsedRealTime() - 10*1000);

2分钟：

mChronometer.setBase(SystemClock.elapsedRealTime() - 2*60*1000);

但这里的问题是 Chronometer 在开始计数之前会显示“00:00”时间，要将其更改为您必须这样做的时间：

mChronometer.setText("02:00");
于 2014-04-03T12:38:46.263 回答
5

基准时间是Chronometer开始滴答作响的时间。您可以使用Chronometer.setBase(). 您应该使用SystemClock.getElapsedTime(). setBase()每次启动时使用开始时间调用Chronometer。如果Activity在计时器仍处于活动状态时 有可能被销毁和重新创建，那么您将需要在Activity拥有Chronometer.

于 2010-02-26T14:29:05.310 回答
2

这对我有用：

Date now = new Date();
long elapsedTime = now.getTime() - startTime.getTime(); //startTime is whatever time you want to start the chronometer from. you might have stored it somwehere
myChronometer.setBase(SystemClock.elapsedRealtime() - elapsedTime);
myChronometer.start();
于 2014-09-25T04:32:01.090 回答
1

SystemClock.getElapsedTime() 有些奇怪，我对正常使用开始日期做了一些更改，比如

myChron.setBase(startDate.getTime());

下面是 Chronometer 的子项，TimeView

import android.R;
import android.content.Context;
import android.content.res.TypedArray;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.text.format.DateUtils;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.Chronometer;
import android.widget.RemoteViews;

import java.util.Formatter;
import java.util.IllegalFormatException;
import java.util.Locale;

@RemoteViews.RemoteView
public class TimeView extends Chronometer {
    private static final String TAG = "TimeView";

    private long mBase;
    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 static final int TICK_WHAT = 2;

    /**
     * Initialize this Chronometer object.
     * Sets the base to the current time.
     */
    public TimeView(Context context) {
        this(context, null, 0);
    }

    /**
     * Initialize with standard view layout information.
     * Sets the base to the current time.
     */
    public TimeView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    /**
     * Initialize with standard view layout information and style.
     * Sets the base to the current time.
     */
    public TimeView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    private void init() {
        mBase = System.currentTimeMillis();
        updateText(mBase);
    }

    public void setBase(long base) {
        mBase = base;
        dispatchChronometerTick();
        updateText(System.currentTimeMillis());
    }

    /**
     * Return the base time as set through {@link #setBase}.
     */
    public long getBase() {
        return mBase;
    }

    public void start() {
        mStarted = true;
        updateRunning();
    }

    /**
     * Stop counting up.  This does not affect the base as set from {@link #setBase}, just
     * the view display.
     * <p/>
     * 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
     */
    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();
    }

    private synchronized void updateText(long now) {
        long seconds = now - mBase;
        seconds /= 1000;
        String text = DateUtils.formatElapsedTime(mRecycle, seconds);

        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;
        if (running != mRunning) {
            if (running) {
                updateText(System.currentTimeMillis());
                dispatchChronometerTick();
                mHandler.sendMessageDelayed(Message.obtain(mHandler, TICK_WHAT), 1000);
            } else {
                mHandler.removeMessages(TICK_WHAT);
            }
            mRunning = running;
        }
    }

    private Handler mHandler = new Handler() {
        public void handleMessage(Message m) {
            if (mRunning) {
                updateText(System.currentTimeMillis());
                dispatchChronometerTick();
                sendMessageDelayed(Message.obtain(this, TICK_WHAT), 1000);
            }
        }
    };

    void dispatchChronometerTick() {
        if (mOnChronometerTickListener != null) {
            mOnChronometerTickListener.onChronometerTick(this);
        }
    }
}

只需复制和使用，它对我有用

于 2013-09-26T22:22:50.860 回答
1

当您使用 .setBase(SystemClock.elapsedRealTime()) 设置基准时间时，计时器从 00.00 开始计数，但它存储的时间是从启动开始的毫秒数。当您使用 .stop 时，内部计数不会停止，只是您在时钟上看到的时间。因此，如果您再次使用 .start，时钟计数会跳到实际计数。如果要存储从一开始就经过的时间，则必须再次获取系统经过时间并与 .setTime 有所不同

于 2014-11-15T21:49:30.810 回答
0

如何设置开始时间？什么是天文台“底座”？

用于SystemClock.elapsedRealtime()此目的：

   myChronometer.setBase(SystemClock.elapsedRealtime());
于 2017-03-29T19:29:17.177 回答