如何在android中设置计时器

在android中设置计时器以启动任务（我创建的一个不会改变UI的函数）的正确方法是什么？ 以Java方式使用此选项：

---

或者在android（android的处理程序）中有更好的方法吗？

我相信在android上实现这一点的方法是，您需要一个后台服务才能运行。在该后台应用程序中，创建计时器。当计时器“滴答”一声（设置等待时间间隔）时，启动要启动的活动

---

（标准的Java方式通过使用计时器，在Android中运行良好，但您应该注意，这种方法会创建一个新线程

您可以考虑使用非常方便的类（Android .OS.汉德勒），并通过<代码> SeDeMaseAdTimeType（ANDROID.OS.消息，long）或<代码> sEndoMasGeDelEdEd（ANDROID.OS.消息，long）向处理程序发送消息。。一旦收到消息，您就可以运行所需的任务。第二个选项是创建一个对象，并通过处理程序的函数对其进行调度

posttime（java.lang.Runnable，long）

或

postDelayed（java.lang.Runnable，long）

，正如我所见，它是实现计时器最常用的方法

对于重复任务：

new Timer().scheduleAtFixedRate(task, after, interval);

new Timer().schedule(task, after);

对于单个任务运行：

new Timer().scheduleAtFixedRate(task, after, interval);

new Timer().schedule(task, after);

任务是要执行的方法
初始执行时间之后
（间隔重复执行的时间）

这是一种情景

Android文档建议，如果应用程序可能未运行，则应使用注册在指定时间触发的意图

否则，您应该使用处理程序

注意：报警管理器是专门设计的 适用于您希望 应用程序代码以特定的速度运行 时间，即使您的应用程序不可用 当前正在运行。用于正常计时 操作（滴答声、超时等） 这样做更容易，也更有效 使用处理器

是的，可以使用java的定时器，但正如问题所要求的那样，更好的方式（对于移动设备）。这一点已经解释清楚了

---

为了避免堆栈溢出：

new Timer().scheduleAtFixedRate(task, after, interval);

new Timer().schedule(task, after);

因为创建了一个新线程，所以可能会认为它很重

如果您只需要在活动运行时获得回拨，则可以将与结合使用

：

private final int interval = 1000; // 1 Second
private Handler handler = new Handler();
private Runnable runnable = new Runnable(){
    public void run() {
        Toast.makeText(MyActivity.this, "C'Mom no hands!", Toast.LENGTH_SHORT).show();
    }
};
...
handler.postAtTime(runnable, System.currentTimeMillis()+interval);
handler.postDelayed(runnable, interval);

或

private final int EVENT1 = 1; 
private Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {         
        case Event1:
            Toast.makeText(MyActivity.this, "Event 1", Toast.LENGTH_SHORT).show();
            break;

        default:
            Toast.makeText(MyActivity.this, "Unhandled", Toast.LENGTH_SHORT).show();
            break;
        }
    }
};

...

Message msg = handler.obtainMessage(EVENT1);
handler.sendMessageAtTime(msg, System.currentTimeMillis()+interval);
handler.sendMessageDelayed(msg, interval);

public class ChangeProfileActivityMain extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);

        Timer timer = new Timer();
        TimerTask updateProfile = new CustomTimerTask(ChangeProfileActivityMain.this);
        timer.scheduleAtFixedRate(updateProfile, 0, 5000);
    }

}

public class CustomTimerTask extends TimerTask {

    private AudioManager audioManager;
    private Context context;
    private Handler mHandler = new Handler();

    // Write Custom Constructor to pass Context
    public CustomTimerTask(Context con) {
        this.context = con;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub

        // your code starts here.
        // I have used Thread and Handler as we can not show Toast without starting new thread when we are inside a thread.
        // As TimePicker has run() thread running., So We must show Toast through Handler.post in a new Thread. Thats how it works in Android..
        new Thread(new Runnable() {
            @Override
            public void run() {
                audioManager = (AudioManager) context.getApplicationContext().getSystemService(Context.AUDIO_SERVICE);
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        if(audioManager.getRingerMode() == AudioManager.RINGER_MODE_SILENT) {
                            audioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
                            Toast.makeText(context, "Ringer Mode set to Normal", Toast.LENGTH_SHORT).show();
                        } else {
                            audioManager.setRingerMode(AudioManager.RINGER_MODE_SILENT);
                            Toast.makeText(context, "Ringer Mode set to Silent", Toast.LENGTH_SHORT).show();
                        }
                    }
                });
            }
        }).start();

    }

}

另一方面，如果您想从另一个线程运行UI线程中的一段代码，可以使用这种方法

---

如果即使您的活动未运行也需要回拨电话，则可以使用

进行您应该使用的计时操作

---

如果你需要运行后台服务，AlarmManager是一个不错的选择。

我是一个Android新手，但这是我根据上述答案创建的计时器类。它适用于我的应用程序，但我欢迎任何建议

用法示例：

...{
public Handler uiHandler = new Handler();

  private Runnable runMethod = new Runnable()
    {
        public void run()
        {
              // do something
        }
    };

    timer = new UITimer(handler, runMethod, timeoutSeconds*1000);       
        timer.start();
}...

public class UITimer
{
    private Handler handler;
    private Runnable runMethod;
    private int intervalMs;
    private boolean enabled = false;
    private boolean oneTime = false;

    public UITimer(Handler handler, Runnable runMethod, int intervalMs)
    {
        this.handler = handler;
        this.runMethod = runMethod;
        this.intervalMs = intervalMs;
    }

    public UITimer(Handler handler, Runnable runMethod, int intervalMs, boolean oneTime)
    {
        this(handler, runMethod, intervalMs);
        this.oneTime = oneTime;
    }

    public void start()
    {
        if (enabled)
            return;

        if (intervalMs < 1)
        {
            Log.e("timer start", "Invalid interval:" + intervalMs);
            return;
        }

        enabled = true;
        handler.postDelayed(timer_tick, intervalMs);        
    }

    public void stop()
    {
        if (!enabled)
            return;

        enabled = false;
        handler.removeCallbacks(runMethod);
        handler.removeCallbacks(timer_tick);
    }

    public boolean isEnabled()
    {
        return enabled;
    }

    private Runnable timer_tick = new Runnable()
    {
        public void run()
        {
            if (!enabled)
                return;

            handler.post(runMethod);

            if (oneTime)
            {
                enabled = false;
                return;
            }

            handler.postDelayed(timer_tick, intervalMs);
        }
    }; 
}

{
公共处理程序uiHandler=新处理程序（）；
private Runnable runMethod=new Runnable（）
{
公开募捐
{
//做点什么
}
};
计时器=新的UITimer（处理程序、runMethod、timeoutSeconds*1000）；
timer.start（）；
}...
公共类UITimer
{
私人经办人；
私有可运行方法；
私人int间隔；
启用私有布尔值=false；
private boolean oneTime=false；
公共UITimer（处理程序、可运行的runMethod、int intervalMs）
{
this.handler=handler；
this.runMethod=runMethod；
this.intervalMs=intervalMs；
}
公共UITimer（处理程序、可运行的runMethod、int间隔、布尔一次性）
{
这（处理程序、运行方法、间隔）；
this.oneTime=oneTime；
}
公开作废开始（）
{
如果（已启用）
返回；
如果（间隔<1）
{
Log.e（“计时器启动”，“无效间隔：”+间隔）；
返回；
}
启用=真；
处理器。延迟后（计时器滴答声，间隔）；
}
公共停车场（）
{
如果（！已启用）
返回；
启用=错误；
removeCallbacks（runMethod）；
handler.removeCallbacks（计时器刻度）；
}
公共布尔值isEnabled（）
{
返回启用；
}
私有可运行计时器\u tick=new Runnable（）
{
公开募捐
{
如果（！已启用）
返回；
handler.post（runMethod）；
如果（一次性）
{
启用=错误；
返回；
}
处理器。延迟后（计时器滴答声，间隔）；
}
}; 
}

我们开始了。我们需要两个课程。我正在发布一个代码，每5秒（5000毫秒）更改一次移动音频配置文件

我们的头等舱

我们的二等舱

---

可能

Timerconcept

new CountDownTimer(40000, 1000) { //40000 milli seconds is total time, 1000 milli seconds is time interval

 public void onTick(long millisUntilFinished) {
  }
  public void onFinish() {
 }
}.start();

或

方法2：

对计时器进行编程

添加名为time的int新变量。将其设置为0。 将以下代码添加到MainActivity.java中的onCreate函数中

//Declare the timer
Timer t = new Timer();
//Set the schedule function and rate
t.scheduleAtFixedRate(new TimerTask() {

    @Override
    public void run() {
        //Called each time when 1000 milliseconds (1 second) (the period parameter)
    }

},
//Set how long before to start calling the TimerTask (in milliseconds)
0,
//Set the amount of time between each execution (in milliseconds)
1000);

进入run方法并添加以下代码

//We must use this function in order to change the text view text
runOnUiThread(new Runnable() {

    @Override
    public void run() {
        TextView tv = (TextView) findViewById(R.id.main_timer_text);
        tv.setText(String.valueOf(time));
        time += 1;
    }

});

---

我希望这一点是有帮助的，可能需要较少的努力来实施，

e、 g

我曾经使用（

Timer

，

TimerTask

）以及

Handler

定期启动（耗时的）任务。现在我将整个任务切换到了RxJava。RxJava提供了

可观察的。Timer

更简单，更不容易出错，使用起来更方便

public class BetterTimerFragment extends Fragment {
  public static final String TAG = "BetterTimer";
  private TextView timeView;
  private Subscription timerSubscription;

  @Override
  public View onCreateView(LayoutInflater inflater,
                           @Nullable ViewGroup container,
                           @Nullable Bundle savedInstanceState) {
    return inflater.inflate(R.layout.fragment_timer, container, false);
  }

  @Override
  public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    timeView = (TextView) view.findViewById(R.id.timeView);
  }

  @Override
  public void onResume() {
    super.onResume();

    // Right after the app is visible to users, delay 2 seconds
    // then kick off a (heavy) task every 10 seconds.
    timerSubscription = Observable.timer(2, 10, TimeUnit.SECONDS)
        .map(new Func1<Long, String>() {
          @Override
          public String call(Long unused) {
            // TODO: Probably do time-consuming work here.
            // This runs on a different thread than the main thread.
            return "Time: " + System.currentTimeMillis();
          }
        })
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Action1<String>() {
          @Override
          public void call(String timeText) {
            // The result will then be propagated back to the main thread.
            timeView.setText(timeText);
          }
        }, new Action1<Throwable>() {
          @Override
          public void call(Throwable throwable) {
            Log.e(TAG, throwable.getMessage(), throwable);
          }
        });
  }

  @Override
  public void onPause() {
    super.onPause();

    // Don't kick off tasks when the app gets invisible.
    timerSubscription.unsubscribe();
  }
}

公共类BetterimerFragment扩展了片段{
公共静态最终字符串TAG=“betterimer”；
私有文本视图时间视图；
私人订阅时间订阅；
@凌驾
创建视图上的公共视图（更平坦的充气机，
@可为空的视图组容器，
@可空Bu