androidservice定時
⑴ Android開發，在service里遍歷所有的定時，service啟動瞬間，所有鬧鍾都響了，怎麼
使用AlramManager設置鬧鍾的時候，需要設置PendingIntent，構造的時候如下：
java">PendingIntent.getBroadcast(context,id*100+pos,
intent,PendingIntent.FLAG_UPDATE_CURRENT);
看下你PendingIntent的ID是不是相同的，如果相同的話，會認為是同一個事件。
⑵ android 怎麼實現後台注冊一個service，定時定位的功能
public class ServiceLocationGPS extends Service implements AMapLocationListener {
private GlobalApp app;
private LocationManagerProxy aMapLocManager = null;
private AMapLocation aMapLocation;// 用於判斷定位超時
public Timer timer;
TimerTask task;
public Integer period = 10;
public Integer count = 0;
@Override
public IBinder onBind(Intent arg0) {
// TODO Auto-generated method stub
return null;
}
@Override
public void onCreate() {
app = (GlobalApp) getApplication();
start();
super.onCreate();
}
@Override
public void onDestroy() {
stoptime();
super.onDestroy();
}
@Override
@Deprecated
public void onStart(Intent intent, int startId) {
// TODO Auto-generated method stub
super.onStart(intent, startId);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// TODO Auto-generated method stub
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onLocationChanged(Location arg0) {
// TODO Auto-generated method stub
}
@Override
public void onProviderDisabled(String arg0) {
// TODO Auto-generated method stub
}
@Override
public void onProviderEnabled(String arg0) {
// TODO Auto-generated method stub
}
@Override
public void onStatusChanged(String arg0, int arg1, Bundle arg2) {
// TODO Auto-generated method stub
}
public void startLocation() {
if (aMapLocManager == null) {
aMapLocManager = LocationManagerProxy
.getInstance(ServiceLocationGPS.this);
System.out.println("startLocation");
aMapLocManager.requestLocationUpdates(
LocationProviderProxy.AMapNetwork, -1, 10, this);
} else {
aMapLocManager.requestLocationUpdates(
LocationProviderProxy.AMapNetwork, -1, 10, this);
}
public void start() {
initSchele();
// 10秒以後啟動任務;
startSchele(10);
}
@Override
public void onLocationChanged(AMapLocation location) {
if (location != null) {
this.aMapLocation = location;// 判斷超時機制
Double geoLat = location.getLatitude();
Double geoLng = location.getLongitude();
String cityCode = "";
String desc = "";
Bundle locBundle = location.getExtras();
if (locBundle != null) {
cityCode = locBundle.getString("citycode");
desc = locBundle.getString("desc");
}
System.out.println("onLocationChanged," + geoLat + "," + geoLng);
// aMapLocManager.removeUpdates(this);
//stopLocation();
}
}
/**
* 銷毀定位
*/
public void stopLocation() {
if (aMapLocManager != null) {
aMapLocManager.removeUpdates(this);
aMapLocManager.destory();
}
aMapLocManager = null;
}
/**
* 開啟定時任務;
*/
public void startSchele(int delay) {
if (timer != null && task != null)
// 10秒以後執行任務；
timer.schele(task, delay * 1000, period * 1000);
}
public void initSchele() {
if (timer == null)
timer = new Timer();
if (task == null)
task = new TimerTask() {
@Override
public void run() {
startLocation();
}
};
}
private void stoptime() {
if (timer != null) {
timer.cancel();
timer = null;
}
if (task != null) {
task.cancel();
task = null;
}
}
}
⑶ android 後台運行 並定時觸發任務
Android中的定時任務一般有兩種實現方式，一種是使用Java
API里的Timer類，另一種是使用Android的Alarm機制。
這兩種方式在多數情況下都能實現類似的效果，但Timer有一個明顯的短板，它並不太適用與那些需要長期在後台運行的定時任務。As we
know，為了能讓電池更加耐用，每種手機都會有自己的休眠策略：比如手機不用的時候智能的斷開wifi連接，根據光線強弱自動調節屏幕亮度，根據手機長時間無操作時自動的讓CPU進入到休眠狀態等，當進入休眠狀態時，這就有可能導致Timer中的定時任務無法正常運行。而Alarn機制則不存在這種情況，它具有喚醒CPU的功能，即可以保證每次需要執行定時任務的時候CPU都能正常工作。需要注意的是，這里的喚醒CPU和喚醒屏幕不是同一個概念，不能混淆。
這里我們只說Alarm機制的方式，代碼如下：
public class AutoUpdateService extends Service {
@Override
public IBinder onBind(Intent intent) {
return null;
}
// 每次服務啟動的時候調用
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
new Thread(new Runnable() {
@Override
public void run() {
doSomething();//這是定時所執行的任務
}
}).start();
AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
int anHour =8 * 60 * 60 * 1000;// 這是8小時的毫秒數 為了少消耗流量和電量，8小時自動更新一次
long triggerAtTime = SystemClock.elapsedRealtime() + anHour;
Intent intent2 = new Intent(this, AutoUpdateReceiver.class);
PendingIntent pi = PendingIntent.getBroadcast(this, 0, intent2, 0);
manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);</span>
return super.onStartCommand(intent, flags, startId);
}
注意這里的AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);此處實現了定時任務。
首先我們通過調用Context的getSystemService()方法來獲取AlarmManager的實例，這里需要傳入的參數是ALARM_SERVICE.
接下來調用AlarmManager的set()方法就可以設置一個定時任務了，比如設定一個任務在5秒鍾後執行，就可以寫成 long
triggerAtTime = SystemClock.elapsedRealtime() + 5*1000;
manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime,
pi);
其中第一個參數是一個整形參數，用於指定AlarmManager的工作類型，有四種值可以選，分別是
ELAPSED_REALTIME、ELAPSED_REALTIME_WAKEUP、RTC和RTC_WAKEUP。其中ELAPSED_REALTIME表示讓定時任務的觸發時間從系統開機開始算起，但不會喚醒CPU。ELAPSED_REALTIME_WAKEUP同樣表示讓定時任務的觸發時間從系統開機開始算起，但會喚醒CPU。RTC表示讓定時任務的觸發時間從1970年1月1日0點開始算起，但不會喚醒CPU。RTC_WAKEUP同樣表示讓定時任務的觸發時間從1970年1月1日0點開始算起，但會喚醒CPU。使用SystemClock.elapsedRealtime()方法可以獲取到系統開機至今所經歷時間的毫秒數，使用System.currentTimeMillis()方法可以獲取到1970年1月1日0點至今所經歷時間的毫秒數。
然後看一下第二個參數，這個參數就好理解多了，就是定時任務觸發的時間，以毫秒為單位。如果第一個參數使用的是ELAPSED_REALTIME或ELAPSED_REALTIME_WAKEUP，則這里傳入開機至今的時間再加上延遲執行的時間。如果第一個參數使用的是RTC或RTC_WAKEUP，則這里傳入1970年1月1日0點至今的時間再加上延遲執行的時間。
第三個參數是一個PendingIntent，這里我們一般會調用getBroadcast()方法來獲取一個能夠執行廣播的PendingIntent。這樣當定時任務被觸發的時候，廣播接收器的onReceive()方法就可以得到執行。
當然設定一個任務在10秒鍾後執行還可以寫成：
longtriggerAtTime =
System.currentTimeMillis() + 10 * 1000;
manager.set(AlarmManager.RTC_WAKEUP,triggerAtTime,
pendingIntent);
然後創建PendingIntent指定處理定時任務的廣播接收器AutoUpdateReceiver。
import service.AutoUpdateService;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
public class AutoUpdateReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Intent i = new Intent(context, AutoUpdateService.class);
context.startService(i);
}
}
當啟動AutoUpdateService後，就會在onStartCommand()方法里設定一個定時任務，這樣每8個小時AutoUpdateReceiver的onReceive()方法就會得到執行，這樣就又會啟動AutoUpdateService服務，形成了永久的循環，保證服務每隔一段時間就會啟動一次，這樣就完成了一個長期在後台運行的服務。
我們在哪裡啟動服務呢，這要看具體的情況了，一般的話，當我們打開程序的時候啟動一次就好了
比如寫在Activity的onCrete()方法里
Intent
intent =new Intent(this,AutoUpdateService.class);
startService(intent);
最後，既然我們用到了服務和廣播接收器，那麼就得在AndroidManifest.xml中注冊才行。
<service android:name="service.AutoUpdateService" ></service>
<receiver android:name="receiver.AutoUpdateReceiver"
></receiver>
本文參考資料：《第一行代碼》
⑷ android 關於定時執行問題
Handler.postDelayed的Integer參數代表是毫秒，你給的1000意思是一秒鍾，如果你是重復執行某一任務，延遲時間是上一次任務執行完畢，再等待十秒，你雖然延遲的是一秒，但可能gps（），代碼執行需要9秒。
⑸ android service 做個定時器 時間到了無論在那個程序都會顯示對話框
只需要在service里彈出一個全局對話框即可，以下是示例代碼：
1.創建對象框
AlertDialog.Builder builder = new Builder(context);
builder.setTitle("請輸入"); //設置對話框標題
builder.setIcon(android.R.drawable.btn_star); //設置對話框標題前的圖標
2.創建EditText輸入框
final EditText edit = new EditText(context);
3.將輸入框賦值給Dialog,並增加確定取消按鍵
builder.setView(edit);
builder.setPositiveButton("確認", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(context, "你輸入的是: " + edit.getText().toString(), Toast.LENGTH_SHORT).show();
}
});
builder.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(context, "你點了取消", Toast.LENGTH_SHORT).show();
}
});
4.設置常用api，並show彈出
builder.setCancelable(true); //設置按鈕是否可以按返回鍵取消,false則不可以取消
AlertDialog dialog = builder.create(); //創建對話框
dialog.setCanceledOnTouchOutside(true); //設置彈出框失去焦點是否隱藏,即點擊屏蔽其它地方是否隱藏
dialog.show();
⑹ android中如何實現定時提醒
android中可以使用鬧鍾進行提醒，你只需要告知系統你想在什麼時候被提醒，然後需要一個鬧鍾的廣播接收器，當到你設置的時間時，系統會給你發送一條廣播，當你接收到廣播後你就可以做一些操作，比如啟動你的app,或者跳轉到你app中的任何一個界面。代碼如下：
//發送鬧鍾請求
Intent intent = new Intent(mContext, AlarmReceiver.class);
intent.setAction("something");
intent.setType("something");
intent.setData(Uri.EMPTY);
intent.addCategory(「something」);
intent.setClass(context, AlarmReceiver.class);
// 以上給intent設置的四個屬性是用來區分你發給系統的鬧鍾請求的，當你想取消掉之前發的鬧鍾請求，這四個屬性，必須嚴格相等，所以你需要一些比較獨特的屬性，比如伺服器返回給你的json中某些特定欄位。
//當然intent中也可以放一些你要傳遞的消息。
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, alarmCount, intent, 0);
//alarmCount是你需要記錄的鬧鍾數量，必須保證你所發的alarmCount不能相同，最後一個參數填0就可以。
AlarmManager am = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
am.set(AlarmManager.RTC_WAKEUP, time, pendingIntent);
//這樣鬧鍾的請求就發送出去了。time是你要被提醒的時間，單位毫秒，注意不是時間差。第一個參數提醒的需求用我給出的就可以，感興趣的朋友，可以去google一下，這方面的資料非常多，一共有種，看一下就知道區別了。
//取消鬧鍾請求
Intent intent = new Intent(mContext, AlarmReceiver.class);
intent.setAction("something");
intent.setType(something);
intent.setData(Uri.EMPTY);
intent.addCategory(something);
intent.setClass(context, AlarmReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, alarmCount, intent, 0);
//alarmCount對應到你設定時的alarmCount,
AlarmManager am = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
am.cancel(pendingIntent);
//接著，你需要一個廣播接收的類：
public class AlarmReceiver extends BroadcastReceiver{
private NotificationManager manager;
@Override
public void onReceive(Context context, Intent intent) {
manager = (NotificationManager)context.getSystemService(android.content.Context.NOTIFICATION_SERVICE);
//例如這個id就是你傳過來的
String id = intent.getStringExtra("id");
//MainActivity是你點擊通知時想要跳轉的Activity
Intent playIntent = new Intent(context, MainActivity.class);
playIntent.putExtra("id", id);
PendingIntent pendingIntent = PendingIntent.getActivity(context, 1, playIntent, PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
builder.setContentTitle("title").setContentText("提醒內容").setSmallIcon(R.drawable.app_icon).setDefaults(Notification.DEFAULT_ALL).setContentIntent(pendingIntent).setAutoCancel(true).setSubText("二級text");
manager.notify(1, builder.build());
}
}
⑺ Android 實現定時任務的五種方式
1、普通線程sleep的方式，可用於一般的輪詢Polling
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
//todo
try {
Thread.sleep(iDelay);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
優點：非常簡單的實現，邏輯清晰明了，也是最常見的寫法
缺點：在sleep結束後，並不能保證競爭到cpu資源，這也就導致了下次執行時間必定>=iDelay，存在時間精度問題
2、Timer定時器
//Timer + TimerTask結合的方法
private final Timer timer = new Timer();
private TimerTask timerTask = new TimerTask() {
@Override
public void run() {
//todo
}
};
啟動定時器方法：
timer.schele(TimerTask task, long delay, long period)
立即執行
timer.schele(timerTask, 0, 1000); //立刻執行，間隔1秒循環執行
延時執行
timer.schele(timerTask, 2000, 1000); //等待2秒後再執行，間隔1秒循環執行
關閉定時器方法：timer.cancel();
優點：純正的定時任務，純java SDK，單獨線程執行，比較安全，而且還可以在運行過程中取消執行
缺點：基於單線程執行，多個任務之間會相互影響，多個任務的執行是串列的，性能較低，而且timer也無法保證時間精確度，是因為手機休眠的時候，無法喚醒cpu，不適合後台任務的定時
3、ScheledExecutorService
private Runnable runnable2 = new Runnable() {
@Override
public void run() {
//todo
}
};
ScheledExecutorService executor = Executors.newScheledThreadPool(1);
executor.scheleAtFixedRate(runnable2, 0, 1, TimeUnit.SECONDS);
關於scheleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 方法說明：
command：需要執行的線程
initialDelay：第一次執行需要延時的時間，如若立即執行，則initialDelay = 0
period：固定頻率，周期性執行的時間
unit：時間單位，常用的有MILLISECONDS、SECONDS和MINUTES等，需要注意的是，這個單位會影響initialDelay和period，如果unit = MILLISECONDS，則initialDelay和period傳入的是毫秒，如果unit = SECONDS，則initialDelay和period傳入的是秒
補充一下： 還有一個方法跟上面的很相似：scheleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)，這個也是帶延遲時間的調度，並且也是循環執行，唯一的不同就是固定延遲時間循環執行，上面的是固定頻率的循環執行。那這兩者的區別？
舉例子：
使用scheleAtFixedRate，任務初始延遲3秒，任務執行3秒，任務執行間隔為5秒：
ScheledExecutorService executor = Executors.newScheledThreadPool(1);
Log.e(TAG, "schele just start! time =" + simpleDateFormat.format(System.currentTimeMillis()));
executor.scheleAtFixedRate(new Runnable() {
@Override
public void run() {
SystemClock.sleep(3000L);
Log.e(TAG, "runnable just do it! time =" + simpleDateFormat.format(System.currentTimeMillis()));
}
}, 3, 5, TimeUnit.SECONDS);
執行結果截圖：
使用scheleWithFixedDelay，任務初始延遲3秒，任務執行3秒，任務執行延遲為5秒：
ScheledExecutorService executor = Executors.newScheledThreadPool(1);
Log.e(TAG, "schele just start! time =" + simpleDateFormat.format(System.currentTimeMillis()));
executor.scheleWithFixedDelay(new Runnable() {
@Override
public void run() {
SystemClock.sleep(3000L);
Log.e(TAG, "runnable just do it! time =" + simpleDateFormat.format(System.currentTimeMillis()));
}
}, 3, 5, TimeUnit.SECONDS);
執行結果截圖：
從這兩者的運行結果就可以看到區別了：scheleAtFixedRate是相對於任務執行的開始時間，而scheleWithFixedDelay是相對於任務執行的結束時間。
優點：ScheledExecutorService是一個線程池，其內部使用的延遲隊列，本身就是基於等待/喚醒機制實現的，所以CPU並不會一直繁忙。解決了Timer&TimerTask存在的問題，多任務處理時效率高
缺點：取消時需要打斷線程池的運行，而且和外界的通信不太好處理
4、使用Handler中的postDelayed方法
private Handler mHandler = new Handler();
private Runnable runnable = new Runnable() {
@Override
public void run() {
//todo
mHandler.postDelayed(this, iDelay);
}
};
mHandler.post(runnable); //立即執行
mHandler.postDelayed(runnable, iDelay); //延時執行
mHandler.removeCallbacks(runnable); //取消執行
優點：比較簡單的android實現，適用UI線程
缺點：沒想到，手動捂臉。。。。我估計是使用不當會造成內存泄露吧
5、Service + AlarmManger + BroadcastReceiver
⑻ android 怎麼實現後台注冊一個service，定時定位的功能
public class ServiceLocationGPS extends Service implements AMapLocationListener {
private GlobalApp app;
private LocationManagerProxy aMapLocManager = null;
private AMapLocation aMapLocation;// 用於判斷定位超時
public Timer timer;
TimerTask task;
public Integer period = 10;
public Integer count = 0;
@Override
public IBinder onBind(Intent arg0) {
// TODO Auto-generated method stub
return null;
}
@Override
public void onCreate() {
app = (GlobalApp) getApplication();
start();
super.onCreate();
}
@Override
public void onDestroy() {
stoptime();
super.onDestroy();
}
@Override
@Deprecated
public void onStart(Intent intent, int startId) {
// TODO Auto-generated method stub
super.onStart(intent, startId);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// TODO Auto-generated method stub
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onLocationChanged(Location arg0) {
// TODO Auto-generated method stub
}
@Override
public void onProviderDisabled(String arg0) {
// TODO Auto-generated method stub
}
@Override
public void onProviderEnabled(String arg0) {
// TODO Auto-generated method stub
}
@Override
public void onStatusChanged(String arg0, int arg1, Bundle arg2) {
// TODO Auto-generated method stub
}
public void startLocation() {
if (aMapLocManager == null) {
aMapLocManager = LocationManagerProxy
.getInstance(ServiceLocationGPS.this);
System.out.println("startLocation");
aMapLocManager.requestLocationUpdates(
LocationProviderProxy.AMapNetwork, -1, 10, this);
} else {
aMapLocManager.requestLocationUpdates(
LocationProviderProxy.AMapNetwork, -1, 10, this);
}
public void start() {
initSchele();
// 10秒以後啟動任務;
startSchele(10);
}
@Override
public void onLocationChanged(AMapLocation location) {
if (location != null) {
this.aMapLocation = location;// 判斷超時機制
Double geoLat = location.getLatitude();
Double geoLng = location.getLongitude();
String cityCode = "";
String desc = "";
Bundle locBundle = location.getExtras();
if (locBundle != null) {
cityCode = locBundle.getString("citycode");
desc = locBundle.getString("desc");
}
System.out.println("onLocationChanged," + geoLat + "," + geoLng);
// aMapLocManager.removeUpdates(this);
//stopLocation();
}
}
/**
* 銷毀定位
*/
public void stopLocation() {
if (aMapLocManager != null) {
aMapLocManager.removeUpdates(this);
aMapLocManager.destory();
}
aMapLocManager = null;
}
/**
* 開啟定時任務;
*/
public void startSchele(int delay) {
if (timer != null && task != null)
// 10秒以後執行任務；
timer.schele(task, delay * 1000, period * 1000);
}
public void initSchele() {
if (timer == null)
timer = new Timer();
if (task == null)
task = new TimerTask() {
@Override
public void run() {
startLocation();
}
};
}
private void stoptime() {
if (timer != null) {
timer.cancel();
timer = null;
}
if (task != null) {
task.cancel();
task = null;
}
}
}
⑼ android 當關閉程序時，service 每天定時更新數據
這種需求可以用AlarmManager實現，在AlarmManager里設置初次執行時間和循環間隔，到設置時間了觸發Service更新數據