下面列出了android.app.AlarmManager#setInexactRepeating ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public void scheduleAlarms(AlarmManager mgr, PendingIntent pendingIntent,
Context context) {
/* If notifications off, ensure alarms are cancelled and return */
SharedPreferences prefs =
PreferenceManager.getDefaultSharedPreferences(context);
boolean enableNotifications =
prefs.getBoolean(Constants.KEY_ENABLE_NOTIFICATIONS, false);
if (!enableNotifications) {
if (BuildConfig.DEBUG) Log.d(TAG, "Cancelling alarms");
AppService.cancelAlarms(context);
return;
}
mMinutes = getMinutes(context);
mgr.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
SystemClock.elapsedRealtime()+mMinutes*60*1000,
mMinutes*60*1000, pendingIntent);
if (BuildConfig.DEBUG) {
Log.d(TAG, String.format("Set alarms for %d minute intervals",
mMinutes));
}
}
public static void setDailyAlarm(Context context) {
Intent notifyIntent = new Intent(context, AlarmReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(
context, 0, notifyIntent, PendingIntent.FLAG_CANCEL_CURRENT);
// TODO(smcgruer): Allow user to configure the time.
final Calendar cal = Calendar.getInstance();
if (cal.get(Calendar.HOUR_OF_DAY) >= 20)
cal.add(Calendar.DATE, 1);
cal.set(Calendar.HOUR_OF_DAY, 20);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
alarmManager.setInexactRepeating(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(),
AlarmManager.INTERVAL_DAY, pendingIntent);
}
public void startSyncService(){
Intent intent = new Intent(context, RefreshBroadcastReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 11719, intent, 0);
String val = prefs.getString("refresh_preference", "60");
int syncRaw = Integer.valueOf(val);
long syncInterval = syncRaw*60000; // milliseconds
AlarmManager alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
alarmMgr.cancel(pendingIntent); // to ensure we don't have two sync daemons running
if(!prefs.getBoolean("automatically_refresh", true)){
sendDebugNotification("Sync service not enabled (would have been @ " + syncInterval + ")", context);
return;
// don't sync if they have disabled syncs!
}
alarmMgr.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
SystemClock.elapsedRealtime() + syncInterval,
syncInterval, pendingIntent);
sendDebugNotification("Sync service started at an interval of " + syncInterval, context);
}
@Override
public void onReceive(Context context, Intent intent) {
SharedPreferences prefs = PreferenceManager
.getDefaultSharedPreferences(context);
long interval = Long.parseLong(prefs.getString("interval",
Long.toString(DEFAULT_INTERVAL)));
PendingIntent operation = PendingIntent.getService(context, -1,
new Intent(context, RefreshService.class),
PendingIntent.FLAG_UPDATE_CURRENT);
AlarmManager alarmManager = (AlarmManager) context
.getSystemService(Context.ALARM_SERVICE);
if (interval == 0) {
alarmManager.cancel(operation);
Log.d(TAG, "cancelling repeat operation");
} else {
alarmManager.setInexactRepeating(AlarmManager.RTC,
System.currentTimeMillis(), interval, operation);
Log.d(TAG, "setting repeat operation for: " + interval);
}
Log.d(TAG, "onReceived");
}
private void setRepeatingAlarm(Context context, int dayOfWeek, Calendar nextAlarmTimestamp)
{
Timber.d("Set repeating alarm for %s", nextAlarmTimestamp.getTime());
PendingIntent alarmPendingIntent = getPendingAlarmIntent(context, dayOfWeek);
AlarmManager alarmMgr = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
alarmMgr.setInexactRepeating(AlarmManager.RTC_WAKEUP, nextAlarmTimestamp.getTimeInMillis(),
AlarmManager.INTERVAL_DAY * 7, alarmPendingIntent);
}
private static void scheduleUpdates (final Context context, final AlarmManager am) {
final PendingIntent i = PendingIntent.getBroadcast(context, NotificationIds.BASE_ALARM_ID + ACTION_UPDATE,
new Intent(context, AlarmReceiver.class).putExtra(KEY_ACTION, ACTION_UPDATE),
PendingIntent.FLAG_CANCEL_CURRENT);
am.cancel(i);
am.setInexactRepeating(
AlarmManager.ELAPSED_REALTIME_WAKEUP,
SystemClock.elapsedRealtime(),
AlarmManager.INTERVAL_FIFTEEN_MINUTES,
i);
}
public static void scheduleAlarm() {
Intent intent = new Intent(App.get().getApplicationContext(), BlockedDomainAlarmReceiver.class);
Log.d(TAG, "Alarm not set. Setting alarm");
final PendingIntent pIntent = PendingIntent.getBroadcast(App.get().getApplicationContext(), REQUEST_CODE,
intent, PendingIntent.FLAG_UPDATE_CURRENT);
long firstMillis = System.currentTimeMillis();
AlarmManager alarm = (AlarmManager) App.get().getApplicationContext().getSystemService(Context.ALARM_SERVICE);
alarm.setInexactRepeating(AlarmManager.RTC_WAKEUP, firstMillis,
AlarmManager.INTERVAL_HOUR, pIntent);
}
public static void setReminder(Context context,Class<?> cls,int hour, int min, long interval)
{
Calendar calendar = Calendar.getInstance();
Calendar setCalendar = Calendar.getInstance();
setCalendar.set(Calendar.HOUR_OF_DAY, hour);
setCalendar.set(Calendar.MINUTE, min);
setCalendar.set(Calendar.SECOND, 0);
// cancel already scheduled reminders
cancelReminder(context,cls);
if(setCalendar.before(calendar))
setCalendar.add(Calendar.MILLISECOND, (int) interval);
// Enable a receiver
ComponentName receiver = new ComponentName(context, cls);
PackageManager pm = context.getPackageManager();
pm.setComponentEnabledSetting(receiver,
PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
PackageManager.DONT_KILL_APP);
Intent intent1 = new Intent(context, cls);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, DAILY_REMINDER_REQUEST_CODE, intent1, PendingIntent.FLAG_UPDATE_CURRENT);
AlarmManager am = (AlarmManager) context.getSystemService(ALARM_SERVICE);
am.setInexactRepeating(AlarmManager.RTC_WAKEUP, setCalendar.getTimeInMillis(), interval, pendingIntent);
}
@Override
protected void onHandleWork(@NonNull Intent intent) {
CheckConnection checkNetwork = new CheckConnection(this);
if (!checkNetwork.isNetworkAvailable()) {
return;
}
Log.i("In" , "Notification Service Alarm");
intent = NotificationService.newIntent(this);
PendingIntent pendingIntent = PendingIntent.getService(this, 0, intent,
PendingIntent.FLAG_UPDATE_CURRENT);
AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
prefs = new Prefs(this);
long intervalMillis = Long.parseLong(prefs.getTime());
if (alarmManager != null)
if (new Prefs(this).getNotifs()) {
alarmManager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
SystemClock.elapsedRealtime(),
intervalMillis,
pendingIntent);
} else {
alarmManager.cancel(pendingIntent);
pendingIntent.cancel();
}
String city = prefs.getCity();
String units = PreferenceManager.getDefaultSharedPreferences(this).getString(Constants.PREF_TEMPERATURE_UNITS , Constants.METRIC);
try {
WeatherInfo weather;
weather = new Request(this).getItems(city, units);
if (new Prefs(this).getNotifs())
weatherNotification(weather);
} catch (IOException e) {
Log.e(TAG, "Error get weather", e);
}
}
/**
* Schedules an alarm.
*/
public void scheduleAlarms(AlarmManager manager, PendingIntent intent, Context context)
{
Log.d(TAG, "Scheduling a restart of the BackgroundService in roughly " + TimeUtils.getTimeMessage(BACKGROUND_SERVICE_NORMAL_START_INTERVAL));
// Create an intent that will be used to restart the BackgroundService
Intent baseIntent = new Intent(context, BackgroundService.class);
baseIntent.putExtra(BackgroundService.PERIODIC_BACKGROUND_PROCESSING_REQUEST, BackgroundService.BACKGROUND_PROCESSING_REQUEST);
PendingIntent pendingIntent = PendingIntent.getService(context, 0, baseIntent, PendingIntent.FLAG_CANCEL_CURRENT);
// Schedule a repeating alarm for restarting the BackgroundService
long restartIntervalMilliseconds = BACKGROUND_SERVICE_NORMAL_START_INTERVAL * 1000;
manager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + restartIntervalMilliseconds, restartIntervalMilliseconds, pendingIntent);
}
public void setAlarm(AlarmManager am, Context context, String action, long time) {
Intent intent = new Intent(context, PullingContentService.class);
intent.setAction(action);
PendingIntent pendingIntent =
PendingIntent.getService(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
am.setInexactRepeating(AlarmManager.ELAPSED_REALTIME, getElapsedRealtimeTrigger(time),
getElapsedRealtimeTrigger(time), pendingIntent);
}
private void scheduleStartBlockchainService(@Nonnull final Context context) {
BitherSetting.SyncInterval syncInterval = AppSharedPreference.getInstance().getSyncInterval();
if (syncInterval == BitherSetting.SyncInterval.OnlyOpenApp ||
AddressManager.getInstance().getAllAddresses().size() == 0) {
return;
}
long interval = AlarmManager.INTERVAL_HOUR;
if (syncInterval == BitherSetting.SyncInterval.Normal) {
final long lastUsedAgo = AppSharedPreference.getInstance().getLastUsedAgo();
if (lastUsedAgo < BitherSetting.LAST_USAGE_THRESHOLD_JUST_MS) {
interval = AlarmManager.INTERVAL_FIFTEEN_MINUTES;
log.info("start INTERVAL_FIFTEEN_MINUTES");
} else if (lastUsedAgo < BitherSetting.LAST_USAGE_THRESHOLD_RECENTLY_MS) {
interval = AlarmManager.INTERVAL_HALF_DAY;
log.info("start INTERVAL_HALF_DAY");
} else {
interval = AlarmManager.INTERVAL_DAY;
log.info("start INTERVAL_DAY");
}
}
final AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context
.ALARM_SERVICE);
final PendingIntent alarmIntent = PendingIntent.getService(context, 0,
new Intent(context, BlockchainService.class), 0);
alarmManager.cancel(alarmIntent);
final long now = System.currentTimeMillis();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT)
// as of KitKat, set() is inexact
{
alarmManager.set(AlarmManager.RTC_WAKEUP, now + interval, alarmIntent);
} else
// workaround for no inexact set() before KitKat
{
alarmManager.setInexactRepeating(AlarmManager.RTC_WAKEUP, now + interval,
AlarmManager.INTERVAL_HOUR, alarmIntent);
}
}
private void scheduleHeartbeat(int seconds){
logger.d("heartbeat#scheduleHeartbeat every %d seconds", seconds);
if (pendingIntent == null) {
logger.w("heartbeat#fill in pendingintent");
Intent intent = new Intent(ACTION_SENDING_HEARTBEAT);
pendingIntent = PendingIntent.getBroadcast(ctx, 0, intent, 0);
if (pendingIntent == null) {
logger.w("heartbeat#scheduleHeartbeat#pi is null");
return;
}
}
AlarmManager am = (AlarmManager) ctx.getSystemService(Context.ALARM_SERVICE);
am.setInexactRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + seconds, seconds, pendingIntent);
}
private void scheduleRecommendationUpdate(Context context) {
AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
Intent recommendationIntent = new Intent(context, RecommendationsService.class);
PendingIntent alarmIntent = PendingIntent.getService(context, 0, recommendationIntent, 0);
alarmManager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
INITIAL_DELAY,
AlarmManager.INTERVAL_HALF_HOUR,
alarmIntent);
}
private static void scheduleCleanups (final Context context, final AlarmManager am) {
final PendingIntent i = PendingIntent.getBroadcast(context, NotificationIds.BASE_ALARM_ID + ACTION_CLEANUP,
new Intent(context, AlarmReceiver.class).putExtra(KEY_ACTION, ACTION_CLEANUP),
PendingIntent.FLAG_CANCEL_CURRENT);
am.cancel(i);
am.setInexactRepeating(
AlarmManager.ELAPSED_REALTIME,
SystemClock.elapsedRealtime(),
AlarmManager.INTERVAL_DAY,
i);
}
@Override
public void onCreate() {
Log.i(TAG, "Create version=" + Util.getSelfVersionName(this) + "/" + Util.getSelfVersionCode(this));
startForeground(NOTIFY_WAITING, getWaitingNotification());
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
if (jni_context != 0) {
Log.w(TAG, "Create with context=" + jni_context);
jni_stop(jni_context);
synchronized (jni_lock) {
jni_done(jni_context);
jni_context = 0;
}
}
// Native init
jni_context = jni_init(Build.VERSION.SDK_INT);
Log.i(TAG, "Created context=" + jni_context);
boolean pcap = prefs.getBoolean("pcap", false);
setPcap(pcap, this);
prefs.registerOnSharedPreferenceChangeListener(this);
Util.setTheme(this);
super.onCreate();
HandlerThread commandThread = new HandlerThread(getString(R.string.app_name) + " command", Process.THREAD_PRIORITY_FOREGROUND);
HandlerThread logThread = new HandlerThread(getString(R.string.app_name) + " log", Process.THREAD_PRIORITY_BACKGROUND);
HandlerThread statsThread = new HandlerThread(getString(R.string.app_name) + " stats", Process.THREAD_PRIORITY_BACKGROUND);
commandThread.start();
logThread.start();
statsThread.start();
commandLooper = commandThread.getLooper();
logLooper = logThread.getLooper();
statsLooper = statsThread.getLooper();
commandHandler = new CommandHandler(commandLooper);
logHandler = new LogHandler(logLooper);
statsHandler = new StatsHandler(statsLooper);
// Listen for user switches
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
IntentFilter ifUser = new IntentFilter();
ifUser.addAction(Intent.ACTION_USER_BACKGROUND);
ifUser.addAction(Intent.ACTION_USER_FOREGROUND);
registerReceiver(userReceiver, ifUser);
registeredUser = true;
}
// Listen for idle mode state changes
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
IntentFilter ifIdle = new IntentFilter();
ifIdle.addAction(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED);
registerReceiver(idleStateReceiver, ifIdle);
registeredIdleState = true;
}
// Listen for added/removed applications
IntentFilter ifPackage = new IntentFilter();
ifPackage.addAction(Intent.ACTION_PACKAGE_ADDED);
ifPackage.addAction(Intent.ACTION_PACKAGE_REMOVED);
ifPackage.addDataScheme("package");
registerReceiver(packageChangedReceiver, ifPackage);
registeredPackageChanged = true;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
try {
listenNetworkChanges();
} catch (Throwable ex) {
Log.w(TAG, ex.toString() + "\n" + Log.getStackTraceString(ex));
listenConnectivityChanges();
}
else
listenConnectivityChanges();
// Monitor networks
ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
cm.registerNetworkCallback(
new NetworkRequest.Builder()
.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build(),
networkMonitorCallback);
// Setup house holding
Intent alarmIntent = new Intent(this, ServiceSinkhole.class);
alarmIntent.setAction(ACTION_HOUSE_HOLDING);
PendingIntent pi;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
pi = PendingIntent.getForegroundService(this, 0, alarmIntent, PendingIntent.FLAG_UPDATE_CURRENT);
else
pi = PendingIntent.getService(this, 0, alarmIntent, PendingIntent.FLAG_UPDATE_CURRENT);
AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
am.setInexactRepeating(AlarmManager.RTC, SystemClock.elapsedRealtime() + 60 * 1000, AlarmManager.INTERVAL_HALF_DAY, pi);
}
public static void updateAlarm(Context context)
{
Calendar cal = Calendar.getInstance();
java.text.DateFormat timeFmt = java.text.DateFormat.getTimeInstance(java.text.DateFormat.SHORT);
Boolean enabled = PreferenceManager.getDefaultSharedPreferences(context)
.getBoolean("notification-enabled", false);
String timeString = PreferenceManager.getDefaultSharedPreferences(context)
.getString("notification-time", "");
try {
cal.setTime(timeFmt.parse(timeString));
} catch (ParseException e) {
Log.w(TAG, "Error parsing time: " + timeString);
enabled = false;
}
Log.d(TAG, "Updating alarm; enabled=" + enabled.toString() + ", time=" + timeString);
AlarmManager am = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, TickmateNotificationBroadcastReceiver.class);
intent.putExtra("onetime", Boolean.FALSE);
intent.addFlags(FLAG_INCLUDE_STOPPED_PACKAGES);
PendingIntent pi = PendingIntent.getBroadcast(context, 0, intent, 0);
// cancel any previous alarms
am.cancel(pi);
if (enabled) {
Calendar alarmTime = Calendar.getInstance();
alarmTime.set(Calendar.HOUR_OF_DAY, cal.get(Calendar.HOUR_OF_DAY));
alarmTime.set(Calendar.MINUTE, cal.get(Calendar.MINUTE));
alarmTime.set(Calendar.SECOND, 0);
alarmTime.set(Calendar.MILLISECOND, 0);
if (alarmTime.before(Calendar.getInstance())) {
alarmTime.add(Calendar.DAY_OF_YEAR, 1);
}
java.text.DateFormat dateFmt = java.text.DateFormat.getDateTimeInstance(
java.text.DateFormat.MEDIUM, java.text.DateFormat.LONG);
Log.i(TAG, "Setting alarm at: " + dateFmt.format(alarmTime.getTime()));
am.setInexactRepeating(AlarmManager.RTC_WAKEUP, alarmTime.getTimeInMillis(),
AlarmManager.INTERVAL_DAY, pi);
}
}
/**
* Schedule this service to update the app index while canceling any previously
* scheduled updates, according to the current preferences. Should be called
* a) at boot, b) if the preference is changed, or c) on startup, in case we get
* upgraded. It works differently on {@code android-21} and newer, versus older,
* due to the {@link JobScheduler} API handling it very nicely for us.
*
* @see <a href="https://developer.android.com/about/versions/android-5.0.html#Power">Project Volta: Scheduling jobs</a>
*/
public static void schedule(Context context) {
Preferences prefs = Preferences.get();
long interval = prefs.getUpdateInterval();
int data = prefs.getOverData();
int wifi = prefs.getOverWifi();
boolean scheduleNewJob =
interval != Preferences.UPDATE_INTERVAL_DISABLED
&& !(data == Preferences.OVER_NETWORK_NEVER && wifi == Preferences.OVER_NETWORK_NEVER);
if (Build.VERSION.SDK_INT < 21) {
Intent intent = new Intent(context, UpdateService.class);
PendingIntent pending = PendingIntent.getService(context, 0, intent, 0);
AlarmManager alarm = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
alarm.cancel(pending);
if (scheduleNewJob) {
alarm.setInexactRepeating(AlarmManager.ELAPSED_REALTIME,
SystemClock.elapsedRealtime() + 5000, interval, pending);
Utils.debugLog(TAG, "Update scheduler alarm set");
} else {
Utils.debugLog(TAG, "Update scheduler alarm not set");
}
} else {
Utils.debugLog(TAG, "Using android-21 JobScheduler for updates");
JobScheduler jobScheduler = (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE);
ComponentName componentName = new ComponentName(context, UpdateJobService.class);
JobInfo.Builder builder = new JobInfo.Builder(JOB_ID, componentName)
.setRequiresDeviceIdle(true)
.setPeriodic(interval);
if (Build.VERSION.SDK_INT >= 26) {
builder.setRequiresBatteryNotLow(true)
.setRequiresStorageNotLow(true);
}
if (data == Preferences.OVER_NETWORK_ALWAYS && wifi == Preferences.OVER_NETWORK_ALWAYS) {
builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);
} else {
builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED);
}
jobScheduler.cancel(JOB_ID);
if (scheduleNewJob) {
jobScheduler.schedule(builder.build());
Utils.debugLog(TAG, "Update scheduler alarm set");
} else {
Utils.debugLog(TAG, "Update scheduler alarm not set");
}
}
}
public static void startServiceAlarm(Context context, Class<?> service, long interval) {
AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
Intent i = new Intent(context, service);
PendingIntent p = PendingIntent.getService(context, REQUEST_CODE, i, PendingIntent.FLAG_CANCEL_CURRENT);
am.setInexactRepeating(AlarmManager.ELAPSED_REALTIME, 0, interval, p);
}
public void scheduleAlarms(AlarmManager mgr, PendingIntent pi, Context ctxt)
{
mgr.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,SystemClock.elapsedRealtime() + 1000, DELAY, pi);
}