Android编程中chronometer在后台怎么才能定时暂停
发布网友
发布时间：2022-04-22 06:47
共1个回答
热心网友
时间：2022-06-16 20:08
我看了下Chronometer这个类的源码，他内部就是用一个handler延迟一秒给自己发送一次消息，然后修改时间。按Home键，会触发Chronometer的onWindowVisibilityChanged()方法
主要方法有下面几个方法：
public void start() {
mStarted = true;
updateRunning();
}
上面方法是启动计时器，将mStarted变量设置为true,并执行一次updateRunning()方法，updateRunning()会在下面讲到
public void stop() {
mStarted = false;
updateRunning();
}
stop()方法是停止计时,将mStarted变量设置为false,并执行一次updateRunning()方法
protected void onWindowVisibilityChanged(int visibility) {
super.onWindowVisibilityChanged(visibility);
mVisible = visibility == VISIBLE;
updateRunning();
}
上面的onWindowVisibilityChanged方法，是View里面的方法，只要View的可见状态发生改变了都会触发这个方法，很显然你说按Home键时间没停止，就是因为这个方法里面的代码，实际上是因为按Home键触发这个方法以后，就不再回调你设置的*的回调方法。按Home键后，View变为不可见状态，变量mVisible变成了false
private void updateRunning() {
boolean running = mVisible && mStarted;
if (running != mRunning) {
if (running) {
updateText(SystemClock.elapsedRealtime());
dispatchChronometerTick();
mHandler.sendMessageDelayed(Message.obtain(mHandler, TICK_WHAT), 1000);
} else {
mHandler.removeMessages(TICK_WHAT);
}
mRunning = running;
}
}
上面的updateRunning() 方法主要是工具mVisible和mStarted这2个boolean变量来控制是否向handler发送消息。
private Handler mHandler = new Handler() {
public void handleMessage(Message m) {
if (mRunning) {
updateText(SystemClock.elapsedRealtime());
dispatchChronometerTick();
sendMessageDelayed(Message.obtain(this, TICK_WHAT), 1000);
}
}
};
这个Handler主要是执行dispatchChronometerTick()方法 再向它自己发送一条延时消息
void dispatchChronometerTick() {
if (mOnChronometerTickListener != null) {
mOnChronometerTickListener.onChronometerTick(this);
}
}
dispatchChronometerTick()方法 就是回调你设置的*的onChronometerTick方法
根据以上分析，按Home键之后，Chronometer就不会回调你的*方法，这个是受Chronometer的onWindowVisibilityChanged(）方法控制的，所以你的问题不好解决！！
我能想到的解决方式就是把Chronometer的代码拿过来，自己写一个类，粘贴上Chronometer里面的代码，然后再修改它的onWindowVisibilityChanged(）方法，然后就可以用自己的这个计时器了。我测试过了，实现了
最后附上我自己的MyChronometer类代码，你可以复制一下。。在布局文件里直接用这个控件
package com.lily.demo_listview;
/*
* 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.
*/
import java.util.Formatter;
import java.util.IllegalFormatException;
import java.util.Locale;
import android.annotation.SuppressLint;
import android.content.Context;
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.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityNodeInfo;
import android.widget.RemoteViews.RemoteView;
import android.widget.TextView;
/**
* 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}. 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
*/
@RemoteView
public class MyChronometer 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(MyChronometer chronometer);
}
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 MyChronometer(Context context) {
this(context, null, 0);
}
/**
* Initialize with standard view layout information.
* Sets the base to the current time.
*/
public MyChronometer(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
/**
* Initialize with standard view layout information and style.
* Sets the base to the current time.
*/
public MyChronometer(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
// TypedArray a = context.obtainStyledAttributes(
// attrs,
// com.android.internal.R.styleable.Chronometer, defStyle, 0);
// setFormat(a.getString(com.android.internal.R.styleable.Chronometer_format));
// a.recycle();
init();
}
private void init() {
mBase = SystemClock.elapsedRealtime();
updateText(mBase);
}
/**
* Set the time that the count-up timer is in reference to.
*
* @param base Use the {@link SystemClock#elapsedRealtime} time base.
*/
public void setBase(long base) {
mBase = base;
dispatchChronometerTick();
Log.d("MyChronometer", "dispatchChronometerTick 333");
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.
*/
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}.
*/
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 scheling 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
*/
public void setStarted(boolean started) {
mStarted = started;
updateRunning();
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
mVisible = false;
updateRunning();
Log.d("MyChronmeter", "onDetachedFromWindow()"+mVisible);
}
@Override
protected void onWindowVisibilityChanged(int visibility) {
super.onWindowVisibilityChanged(visibility);
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 = mStarted;
if (running != mRunning) {
if (running) {
updateText(SystemClock.elapsedRealtime());
dispatchChronometerTick();
Log.d("MyChronometer", "dispatchChronometerTick 222");
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(SystemClock.elapsedRealtime());
dispatchChronometerTick();
Log.d("MyChronometer", "dispatchChronometerTick 111");
sendMessageDelayed(Message.obtain(this, TICK_WHAT), 1000);
}
}
};
void dispatchChronometerTick() {
if (mOnChronometerTickListener != null) {
mOnChronometerTickListener.onChronometerTick(this);
// Log.d("MyChronometer", "回调方法");
}
}
@SuppressLint("NewApi") @Override
public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
super.onInitializeAccessibilityEvent(event);
event.setClassName(MyChronometer.class.getName());
}
@SuppressLint("NewApi") @Override
public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
super.onInitializeAccessibilityNodeInfo(info);
info.setClassName(MyChronometer.class.getName());
}
}
