新建一个Service来模拟后台执行的程序，PollingService.java:

package com.ryantang.rtpollingdemo;

import android.app.Notification;

import android.app.NotificationManager;

import android.app.PendingIntent;

import android.app.Service;

import android.content.Intent;

import android.os.IBinder;

/**

 * Polling service

 * @Author Ryan

 * @Create 2013-7-13 涓婂崍10:18:44

 */

public class PollingService extends Service {

    public static final String ACTION = "com.ryantang.service.PollingService";

    private Notification mNotification;

    private NotificationManager mManager;

    @Override

    public IBinder onBind(Intent intent) {

        return null;

    }

    @Override

    public void onCreate() {

        initNotifiManager();

    }

    @Override

    public void onStart(Intent intent, int startId) {

        new PollingThread().start();

    }

    //初始化通知栏配置

    private void initNotifiManager() {

        mManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

        int icon = R.drawable.ic_launcher;

        mNotification = new Notification();

        mNotification.icon = icon;

        mNotification.tickerText = "New Message";

        mNotification.defaults |= Notification.DEFAULT_SOUND;

        mNotification.flags = Notification.FLAG_AUTO_CANCEL;

    }

    //弹出Notification

    private void showNotification() {

        mNotification.when = System.currentTimeMillis();

        //Navigator to the new activity when click the notification title

        Intent i = new Intent(this, MessageActivity.class);

        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, i,

                Intent.FLAG_ACTIVITY_NEW_TASK);

        mNotification.setLatestEventInfo(this,

                getResources().getString(R.string.app_name), "You have new message!", pendingIntent);

        mManager.notify(0, mNotification);

    }

    /**

     * Polling thread

     * 模拟向Server轮询的异步线程

     * @Author Ryan

     * @Create 2013-7-13 涓婂崍10:18:34

     */

    int count = 0;

    class PollingThread extends Thread {

        @Override

        public void run() {

            System.out.println("Polling...");

            count ++;

            //当计数能被5整除时弹出通知

            if (count % 5 == 0) {

                showNotification();

                System.out.println("New message!");

            }

        }

    }

    @Override

    public void onDestroy() {

        super.onDestroy();

        System.out.println("Service:onDestroy");

    }

}

别望了在AndroidManifest.xml中注册Service：

<service android:name="com.ryantang.rtpollingdemo.PollingService">

            <intent-filter>

                <action android:name="com.ryantang.service.PollingService"/>

            </intent-filter>

        </service>

当计数能被5整除时弹出通知，点击通知后进入MessageActivity.java:

package com.ryantang.rtpollingdemo;

import android.app.Activity;

import android.app.NotificationManager;

import android.content.Context;

import android.os.Bundle;

public class MessageActivity extends Activity {

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_message);

        System.out.println("新的activity");

        NotificationManager manager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);

        manager.cancelAll();

    }

}

使用AlarmManager封装已给PollingUtils.java来执行Service的启动和停止，PollingUtils.java:

package com.ryantang.rtpollingdemo;

import android.app.AlarmManager;

import android.app.PendingIntent;

import android.content.Context;

import android.content.Intent;

import android.os.SystemClock;

/**

 * Polling Tools

 * @Author Ryan

 * @Create 2013-7-13 涓婂崍10:14:43

 */

public class PollingUtils {

    /**开启轮询服务

     * @param context

     * @param seconds  定期执行的时间间隔

     * @param cls

     * @param action

     */

    public static void startPollingService(Context context, int seconds, Class<?> cls,String action) {

        //获取AlarmManager系统服务

        AlarmManager manager = (AlarmManager) context

                .getSystemService(Context.ALARM_SERVICE);

        //包装需要执行Service的Intent

        Intent intent = new Intent(context, cls);

        intent.setAction(action);

        PendingIntent pendingIntent = PendingIntent.getService(context, 0,

                intent, PendingIntent.FLAG_UPDATE_CURRENT);

        //触发服务的起始时间

        long triggerAtTime = SystemClock.elapsedRealtime();

        //使用AlarmManager的setRepeating方法设置定期执行时间间隔（seconds秒）和需要执行的Service

        manager.setRepeating(AlarmManager.ELAPSED_REALTIME, triggerAtTime,

                seconds * 1000, pendingIntent);//第二个参数与第一个参数有对应的关系，ELAPSED_REALTIME对应的为SystemClock.elapsedRealTime，RTC对应的为System.currentTimeMills()

    }

    /**

     * 停止轮询服务

     * @param context

     * @param cls

     * @param action

     */

    public static void stopPollingService(Context context, Class<?> cls,String action) {

        //获取AlarmManager系统服务

        AlarmManager manager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);

        Intent intent = new Intent(context, cls);

        intent.setAction(action);//需要与启动的action一致，负责无法取消定时任务

        PendingIntent pendingIntent = PendingIntent.getService(context, 0,

                intent, PendingIntent.FLAG_UPDATE_CURRENT);

        //取消正在执行的服务

        manager.cancel(pendingIntent);

    }

}

最后在主程序中执行，MainActivity.java:

package com.ryantang.rtpollingdemo;

import android.app.Activity;

import android.os.Bundle;

public class MainActivity extends Activity {

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        // Start polling service

        System.out.println("Start polling service...");

        PollingUtils.startPollingService(this, 30, PollingService.class,PollingService.ACTION);// PollingService.ACTION与AndroidManifest.xml一一对应

    }

    @Override

    protected void onDestroy() {

        super.onDestroy();

        // Stop polling service

        System.out.println("Stop polling service...");

        PollingUtils.stopPollingService(this, PollingService.class,PollingService.ACTION);

    }

}

Android之AlarmManager(全局定时器/闹钟）指定时长或以周期形式执行某项操作

（1）在指定时长后执行某项操作

//操作：发送一个广播，广播接收后Toast提示定时操作完成

Intent intent =new Intent(Main.this, alarmreceiver.class);

intent.setAction("short");

PendingIntent sender=

PendingIntent.getBroadcast(Main.this, 0, intent, 0);

//设定一个五秒后的时间

Calendar calendar=Calendar.getInstance();

calendar.setTimeInMillis(System.currentTimeMillis());

calendar.add(Calendar.SECOND, 5);

AlarmManager alarm=(AlarmManager)getSystemService(ALARM_SERVICE);

alarm.set(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), sender);

//或者以下面方式简化

//alarm.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()+5*1000, sender);

//注意：receiver记得在manifest.xml注册，使用的是静态的广播消息机制

public static class alarmreceiver extends BroadcastReceiver{

@Override

public void onReceive(Context context, Intent intent) {

// TODO Auto-generated method stub

if(intent.getAction().equals("short")){

      Toast.makeText(context, "short alarm", Toast.LENGTH_LONG).show();

}else{

       Toast.makeText(context, "repeating alarm",Toast.LENGTH_LONG).show();

    }

  }

}

//AndroidManifest.xml中需要注册广播接收器
<receiver android:name="" >

        <intent-filter >

            <action android:name="short"><action />

        </intent-filter>

</receiver>

AlarmManager类型如下：

AlarmManager.RTC，硬件闹钟，不唤醒手机（也可能是其它设备）休眠；当手机休眠时不发射闹钟。

AlarmManager.RTC_WAKEUP，硬件闹钟，当闹钟发射时唤醒手机休眠；

AlarmManager.ELAPSED_REALTIME，真实时间流逝闹钟，不唤醒手机休眠；在指定的延时过后，发送广播，但不唤醒设备。

AlarmManager.ELAPSED_REALTIME_WAKEUP，真实时间流逝闹钟，当闹钟发射时唤醒手机休眠；

RTC闹钟和ELAPSED_REALTIME最大的差别就是前者可以通过修改手机时间触发闹钟事件，后者要通过真实时间的流逝，即使在休眠状态，时间也会被计算。

（2）周期性的执行某项操作

Intent intent =new Intent(Main.this, alarmreceiver.class);

intent.setAction("repeating");

PendingIntent sender=PendingIntent

.getBroadcast(Main.this, 0, intent, 0);

//开始时间

long firstime=SystemClock.elapsedRealtime();

AlarmManager am=(AlarmManager)getSystemService(ALARM_SERVICE);

　//5秒一个周期，不停的发送广播

am.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, firstime, 5*1000, sender);

AlarmManager的setRepeating()相当于Timer的Schedule(task,delay,peroid);有点差异的地方时Timer这个方法是指定延迟多长时间以后开始周期性的执行task;

AlarmManager的取消：（其中需要注意的是取消的Intent必须与启动Intent保持绝对一致才能支持取消

Intent intent =new Intent(Main.this, alarmreceiver.class);

intent.setAction("repeating");

PendingIntent sender=PendingIntent

.getBroadcast(Main.this, 0, intent, 0);

AlarmManager alarm=(AlarmManager)getSystemService(ALARM_SERVICE);

alarm.cancel(sender);

当然还需要写一个静态的广播接收器。

*****************************************2015-09-07 08:21:18***************************************************

周期性执行选用的闹钟类型推荐AlarmManager.RTC_WAKEUP,经测试还是定时时间还是比较准确的，SystemClock.elapsedRealTime()指的的从计算机起始时间1970-1-1算1起，而System.currentTimeMills()指的是系统开机时间算起。

***********************************更新：2015-09-06 08:53:15*******************************************

Android的碎片化严重，定制的ROM被国内厂商修改了很多，对于定时任务MIUI作为代表，开发者遇到到很多这样的情况，定时任务偏离，多半的原因是考虑到了系统休眠、降低CUP运行效率等等以达到省电的效果，这里就介绍另一种方法解决：PowerManager.WakeLock来实现要求的功能。

PowerManager:给予控制设备电量状态的权限

PowerManager.WakeLock：让系统知道你需要设置在工作状态上

Android中通过各种Lock锁对电源进行控制，需要注意的是加锁和解锁必须成对出现

首先获取权限：

<uses-permission android:name="android.permission.WAKE_LOCK"/>

<uses-permission android:name="android.permission.DEVICE_POWER"/>

有时候Eclipse会提示系统应用才能需要这个权限，解决的办法是将项目Clean下即可。WakeLock的设置是Activity级别的，不是针对整个Application应用的。

package com.eyu.wake_lock;  

import android.app.Activity;

import android.os.Bundle;

import android.os.PowerManager;

import android.os.PowerManager.WakeLock;  

public class Wake_lockActivity extends Activity {  

    private boolean iswakeLock = true;// 是否常亮

    private WakeLock wakeLock;  

    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);  

    }  

    @Override

    protected void onResume() {

        // TODO Auto-generated method stub

        PowerManager pm = (PowerManager) getSystemService(POWER_SERVICE);

        wakeLock = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK

                | PowerManager.ON_AFTER_RELEASE, "DPA");  

        if (iswakeLock) {

            wakeLock.acquire();

        }

        super.onResume();  

    }  

    @Override

    protected void onPause() {

        // TODO Auto-generated method stub

        super.onDestroy();

        if (wakeLock != null) {

            wakeLock.release();

        }

        android.os.Process.killProcess(android.os.Process.myPid());

    }  

}

通常在onRusume方法中将获得到的锁使用acquire()方法来保持唤醒，在onPause方法中使用release()方法来释放掉该锁，利用Activity的生命周期来巧妙的使这两种方法成对的出现。

PowerManager和WakeLock的操作步骤

PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);通过 Context.getSystemService().方法获取PowerManager实例。
然后通过PowerManager的newWakeLock((int flags, String tag)来生成WakeLock实例。int Flags指示要获取哪种WakeLock，不同的Lock对cpu 、屏幕、键盘灯有不同影响。
获取WakeLock实例后通过acquire()获取相应的锁，然后进行其他业务逻辑的操作，最后使用release()释放（释放是必须的）。

关于int flags

　　各种锁的类型对CPU 、屏幕、键盘的影响：

　　PARTIAL_WAKE_LOCK:保持CPU 运转，屏幕和键盘灯有可能是关闭的。

　　SCREEN_DIM_WAKE_LOCK：保持CPU 运转，允许保持屏幕显示但有可能是灰的，允许关闭键盘灯

　　SCREEN_BRIGHT_WAKE_LOCK：保持CPU 运转，允许保持屏幕高亮显示，允许关闭键盘灯

　　FULL_WAKE_LOCK：保持CPU 运转，保持屏幕高亮显示，键盘灯也保持亮度

　　ACQUIRE_CAUSES_WAKEUP：正常唤醒锁实际上并不打开屏幕，但是，一旦打开就会一直保持。当获得wakelock，这个标志会使屏幕或/和键盘立即打开。一个典型的使用就是可以立即看到那些对用户重要的通知。

　　ON_AFTER_RELEASE：设置了这个标志，当wakelock释放时用户activity计时器会被重置，导致照明持续一段时间。

***********************************更新：2015-09-15 20:24:29*******************************************

使用AlarmManager就不需要设备锁了，测试过有时候还会导致程序报错，测试手机小米2S，先后试过MIUI、Lewa等第三方Rom，后来刷入Android4.0.3启动定时任务，毫秒不差。

巴特西

使用AlarmManager定期执行工作

Android之AlarmManager(全局定时器/闹钟）指定时长或以周期形式执行某项操作

关于int flags

最新文章

热门文章