안드로이드에서 타이머를 설정하는 방법

안드로이드에서 타이머를 설정하는 방법

---

작업을 시작하기 위해 안드로이드에서 타이머를 설정하는 올바른 방법은 무엇입니까 (UI를 변경하지 않는 만든 기능)? 이것을 Java 방식으로 사용하십시오 : http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Timer.html

아니면 안드로이드 (안드로이드의 핸들러)에 더 좋은 방법이 있습니까?

---

java.util.Timer 및 java.util.TimerTask 를 통해 타이머를 사용하는 표준 Java 방법 은 Android에서 제대로 작동하지만이 메소드는 새 스레드를 작성합니다.

당신은 매우 편리한 사용을 고려할 수 처리기 클래스 (android.os.Handler)를 거쳐서 핸들러에 메시지를 보내 sendMessageAtTime(android.os.Message, long)거나 sendMessageDelayed(android.os.Message, long). 메시지를 받으면 원하는 작업을 실행할 수 있습니다. 두 번째 옵션은 생성하는 것입니다 의 Runnable 객체를 그리고 처리기의 기능을 통해 예약 postAtTime(java.lang.Runnable, long)또는 postDelayed(java.lang.Runnable, long).

---

예 java의 타이머를 사용할 수 있지만 질문에 따라 더 나은 방법을 요청합니다 (모바일). 여기 에 설명되어 있습니다.

---

StackOverflow를 위해 :

Timer 는 새 스레드를 생성 하므로 무거운 것으로 간주 될 수 있습니다.

액티비티가 실행되는 동안 콜백 만하면 됩니다. 핸들러 와 함께 핸들러를 사용할 수 있습니다.

실행 가능 :

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);

참고로 다른 스레드에서 UI 스레드로 코드 조각을 실행하려는 경우이 방법을 사용할 수 있습니다.

활동이 실행 중이 아니더라도 전화를 다시 받아야하는 경우 AlarmManager를 사용할 수 있습니다.

---

내가 본 것처럼 java.util.Timer 는 타이머 구현에 가장 많이 사용됩니다.

반복되는 작업의 경우 :

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

한 번의 작업 실행 :

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

태스크 는 초기 실행 시간
이후 에 실행될 방법입니다
( 실행 반복 시간 간격 ).

---

이 기능이 도움이 되었기를 바랍니다 . Android CountDownTimer 클래스

예 :

 new CountDownTimer(30000, 1000) {
      public void onTick(long millisUntilFinished) {
          mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
      }

      public void onFinish() {
          mTextField.setText("done!");
      }  
}.start();

---

아마 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;
    }

});

---

상황에 따라 다릅니다.

Android 설명서에서는 AlarmManager 를 사용 하여 응용 프로그램이 실행되고 있지 않을 경우 지정된 시간에 시작되는 인 텐트를 등록 해야한다고 제안합니다 .

그렇지 않으면 Handler를 사용해야합니다.

참고 : 알람 관리자는 현재 응용 프로그램이 실행되고 있지 않더라도 특정 시간에 응용 프로그램 코드를 실행하려는 경우를위한 것입니다. 일반적인 타이밍 작업 (틱, 시간 초과 등)의 경우 처리기를 사용하는 것이 더 쉽고 훨씬 효율적입니다.

---

우리는 간다. 우리는 두 개의 수업이 필요하다. 5 초 (5000 밀리 초)마다 모바일 오디오 프로파일을 변경하는 코드를 게시하고 있습니다 ...

우리의 1 등석

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);
    }

}

우리의 2 등석

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();

    }

}

---

나는 안드로이드 초보자이지만 위의 답변을 기반으로 만든 타이머 클래스가 있습니다. 내 앱에서 작동하지만 제안을 환영합니다.

사용 예 :

...{
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);
        }
    }; 
}

---

처리기를 사용하고 타이머를 만들 수 있습니다. 나는 이것을 추상 클래스로 포장했다. 그냥 파생시키고 구현하면 좋습니다.

 public static abstract class SimpleTimer {
    abstract void onTimer();

    private Runnable runnableCode = null;
    private Handler handler = new Handler();

    void startDelayed(final int intervalMS, int delayMS) {
        runnableCode = new Runnable() {
            @Override
            public void run() {
                handler.postDelayed(runnableCode, intervalMS);
                onTimer();
            }
        };
        handler.postDelayed(runnableCode, delayMS);
    }

    void start(final int intervalMS) {
        startDelayed(intervalMS, 0);
    }

    void stop() {
        handler.removeCallbacks(runnableCode);
    }
}

handler.postDelayed코드가 실행되기 전에가 호출 된다는 점에 유의하십시오. 이렇게하면 타이머가 "예상 된"시간보다 더 닫힙니다. 그러나 타이머가 자주 실행되고 작업 ( onTimer())이 긴 경우 겹치는 부분이있을 수 있습니다. intervalMS작업이 완료된 후 계산을 시작 하려면 onTimer()전화를 한 줄 위로 이동하십시오 .

---

I believe the way to do this on the android is that you need a background service to be running. In that background application, create the timer. When the timer "ticks" (set the interval for how long you want to wait), launch your activity which you want to start.

http://developer.android.com/guide/topics/fundamentals.html (<-- this article explains the relationship between activities, services, intents and other core fundamentals of Android development)

---

I used to use (Timer, TimerTask) as well as Handler to kick off (time-consuming) tasks periodically. Now I've switched the whole to RxJava. RxJava provides Observable.timer which is simpler, less error-prone, hassle-free to use.

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();
  }
}

---

For timing operation you should use Handler.

If you need to run a background service the AlarmManager is the way to go.

참고URL : https://stackoverflow.com/questions/1877417/how-to-set-a-timer-in-android