किसी कार्य को करने के लिए एंड्रॉइड में टाइमर सेट करने का एक उचित तरीका क्या है (एक ऐसा फ़ंक्शन जो मैं बनाता हूं जो UI नहीं बदलता है)? इसका जावा तरीके से उपयोग करें: http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Timer.html
या android (android के हैंडलर) में बेहतर तरीका है?
जवाबों:
Java.util.Timer और java.util.TimerTask के माध्यम से टाइमर का उपयोग करने के लिए मानक जावा तरीका 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)।
हाँ जावा के टाइमर का उपयोग किया जा सकता है , लेकिन जैसा कि प्रश्न बेहतर तरीके से (मोबाइल के लिए) पूछता है । जो यहाँ समझाया गया है ।
StackOverflow के लिए:
चूंकि टाइमर एक नया धागा बनाता है, इसलिए इसे भारी माना जा सकता है,
यदि आप सभी की जरूरत है एक कॉल बैक है, जबकि गतिविधि चल रही है एक हैंडलर एक के साथ संयोजन के रूप में इस्तेमाल किया जा सकता है
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);एक साइड नोट पर इस दृष्टिकोण का उपयोग किया जा सकता है, यदि आप यूआई थ्रेड में कोड का एक टुकड़ा दूसरे धागे से चलाना चाहते हैं।
अगर आपको कॉल बैक करने की आवश्यकता है, भले ही आपकी गतिविधि नहीं चल रही हो, तो आप एक अलार्म मैनजर का उपयोग कर सकते हैं
जैसा कि मैंने इसे देखा है, java.util.Timer टाइमर को लागू करने के लिए सबसे अधिक उपयोग किया जाता है।
एक दोहराए जाने वाले कार्य के लिए:
new Timer().scheduleAtFixedRate(task, after, interval);किसी कार्य के एकल रन के लिए:
new Timer().schedule(task, after);
प्रारंभिक निष्पादन के समय के
बाद निष्पादित की जाने वाली विधि कार्य
( निष्पादन को दोहराने के लिए समय अंतराल )
taskआपकी श्रेणी का एक उदाहरण हो सकता है जो java.util.TimerTask और ओवरराइड से विरासत में मिला है void run()।
मुझे आशा है कि यह एक सहायक है और इसे लागू करने के लिए कम प्रयास किए जा सकते हैं, 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 ::
टाइमर कार्यक्रम
इंट नाम समय का एक नया चर जोड़ें। इसे 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);रन विधि में जाएं और निम्न कोड जोड़ें।
//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;
}
});यह स्थितिजन्य है।
एंड्रॉइड डॉक्यूमेंटेशन यह बताता है कि आपको एक ऐसे इरादे को पंजीकृत करने के लिए अलार्म मैनजर का उपयोग करना चाहिए जो निर्दिष्ट समय पर आग लगाएगा यदि आपका एप्लिकेशन नहीं चल रहा हो।
अन्यथा, आपको हैंडलर का उपयोग करना चाहिए।
नोट: अलार्म प्रबंधक उन मामलों के लिए अभिप्रेत है, जहाँ आप अपना एप्लिकेशन कोड एक विशेष समय पर चलाना चाहते हैं, भले ही आपका एप्लिकेशन वर्तमान में नहीं चल रहा हो। सामान्य समय के संचालन (टिक, टाइमआउट, आदि) के लिए हैंडलर का उपयोग करना आसान और अधिक कुशल है।
यहां हम जाते हैं .. हमें दो वर्गों की आवश्यकता होगी। मैं एक कोड पोस्ट कर रहा हूं जो प्रत्येक 5 सेकंड (5000 मिली सेकंड) के बाद मोबाइल ऑडियो प्रोफाइल बदलता है ...
हमारी पहली कक्षा
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();
}
}मैं एक एंड्रॉइड नौसिखिया हूं, लेकिन यहां टाइमर क्लास है जिसे मैंने ऊपर दिए गए उत्तरों के आधार पर बनाया है। यह मेरे ऐप के लिए काम करता है लेकिन मैं किसी भी सुझाव का स्वागत करता हूं।
उपयोग उदाहरण:
...{
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()कॉल को एक पंक्ति ऊपर ले जाएं।
मेरा मानना है कि एंड्रॉइड पर ऐसा करने का तरीका यह है कि आपको चलने के लिए पृष्ठभूमि सेवा की आवश्यकता है। उस बैकग्राउंड एप्लिकेशन में, टाइमर बनाएं। जब टाइमर "टिक" (आप कितनी देर तक इंतजार करना चाहते हैं, इसके लिए अंतराल सेट करें), अपनी गतिविधि लॉन्च करें जिसे आप शुरू करना चाहते हैं।
http://developer.android.com/guide/topics/fundamentals.html (<- यह लेख गतिविधियों, सेवाओं, इरादों और Android विकास के अन्य मूल सिद्धांतों के बीच संबंध को स्पष्ट करता है)
मैं समय-समय पर कार्यों (समय लेने वाली) को किक करने के लिए ( Timerऔर TimerTask) का उपयोग करता Handlerथा। अब मैंने पूरा RxJava में स्विच कर दिया है। RxJava प्रदान करता है Observable.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();
}
}इस उदाहरण को कोटलिन में नष्ट टाइमर यूनिट शुरू करते हैं
private lateinit var timerTask: TimerTask
timerTask = object : TimerTask() {
override fun run() {
Log.d("KTZ", "$minutes:$seconds");
timeRecordingLiveData.postValue("$minutes:$seconds")
seconds += 1;
if (seconds == 60) {
Log.d("KTZ", "$minutes:$seconds");
timeRecordingLiveData.postValue("$minutes:$seconds")
seconds = 0;
minutes += 1;
}
}
}OnDestroy () में समय सारणी रद्द करें
timerTask.cancel()