Android App自动检测更新--时间随机

AbsAlarmChecker

public abstract class AbsAlarmChecker {
    /** 一小时 ms */
	public static final long HOUR = 3600000l;
    public static final long DEFAULT_REPEAT_INTERVAL = 1000l;

	private Context mContext;
	private PendingIntent mPendingIntent;
	private AlarmManager mAlarmManager;
    private long mRepeatInerval = DEFAULT_REPEAT_INTERVAL;

    private boolean mIsStarted = false;

	public AbsAlarmChecker(Context context) {
		// TODO Auto-generated constructor stub
		mContext = context.getApplicationContext();
		init();
	}

    public Context getContext(){
        return mContext;
    }

    /**
     * 初始化
     */
	protected void init(){
        mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
		mPendingIntent = getPendingIntent();
	}

    /**
     * 获取延迟操作命令
     * @return
     */
    protected abstract PendingIntent getPendingIntent();

    /**
     * 设置重复时间, 设置 -1 则一次性操作
     * @param repeat
     */
    public void setRepeatInterval(long repeat){
        mRepeatInerval = repeat;
    }

    /**
     * 是否已经启动
     * @return
     */
    public boolean isStarted(){
        return mIsStarted;
    }

    /**
     * 开始
     */
	public void start(){
		cancel();
		//long repeat = onStartGetRepeatInterval();
		long repeat = getRepeatInterval();
		long trigger;
        trigger = onStartGetTrigger();
        if (repeat > 0l){
            mAlarmManager.setRepeating(AlarmManager.RTC_WAKEUP, trigger, repeat, mPendingIntent);
        }else {
            // 一次性的
            mAlarmManager.set(AlarmManager.RTC_WAKEUP, trigger, mPendingIntent);
        }
        mIsStarted = true;
	}

    /**
     * 重复间隔
     * @return 大于0则重复，小于0则只触发一次
     */
	protected long getRepeatInterval(){
		return 0l;
	}

    /**
     * 获取开始重置间隔
     * @return
     */
//    protected long onStartGetRepeatInterval(){
//        return mRepeatInerval;
//    }

    /**
     * 获取第一次触发的时间.<br>
     * 默认是当前时间延迟10秒
     * @return
     */
    protected long onStartGetTrigger(){
        return System.currentTimeMillis() + 10000l;
    }

    /**
     * 取消
     */
	public void cancel(){
        mIsStarted = false;
		mAlarmManager.cancel(mPendingIntent);
	}
}

AlarmUpdateChecker

public class AlarmUpdateChecker extends AbsAlarmChecker {

    /** 触发的小时 时间点 */
    final int mTriggerHour = 9;

    public static final long CHECK_INTERVAL = 12l * SettingManager.Time.HOUR;

    private Context mContext;
    private PendingIntent mPendingIntent;

    public AlarmUpdateChecker(Context context) {
        super(context);
        init();
    }

    @Override
    protected PendingIntent getPendingIntent() {
        Intent scan = new Intent(getContext(), FlushService.class);
        scan.setAction(NotifyUpdateChecker.ACTION_CHECK_UPDATE);
        return PendingIntent.getService(getContext(), 9527, scan, PendingIntent.FLAG_UPDATE_CURRENT);
    }


    private long getDelay(){

        Date now = new Date();
        Calendar trigger = Calendar.getInstance(Locale.getDefault());
        trigger.set(Calendar.HOUR_OF_DAY,getRandomHour(12,1));
        trigger.set(Calendar.MINUTE, getRandomHour(59,1));
        trigger.set(Calendar.SECOND, getRandomHour(59,1));
        trigger.set(Calendar.MILLISECOND, 0);
        if (trigger.getTime().before(now)) {
            trigger.add(Calendar.HOUR_OF_DAY, 12);
        }
        return trigger.getTimeInMillis();
    }

    /**
     * 取随机数
     * m - n之间的整数
     * @return
     */
    private int getRandomHour(int n,int m){
        int d = (int)(Math.random()*(n-m)+m);
        //Logger.d("update checker alarm :"+d);
        return  d;
    }

    @Override
    protected long onStartGetTrigger() {
        return getDelay();
    }


    @Override
    protected long getRepeatInterval() {
        return CHECK_INTERVAL;
    }
}

SettingManager

 public class SettingManager {
        
    public static interface Time {
        public static final long SECOND = 1000l;
        public static final long MINUTES = 60 * SECOND;
        public static final long HOUR = 60 * MINUTES;
        public static final long DAY = 24 * HOUR;    } 
 }