תזמון התראות

המאפיינים של שעונים מעוררים:

• הם מאפשרים להפעיל Intents בזמנים או במרווחי זמן מוגדרים.

• אפשר להשתמש בהם בשילוב עם מקלטי שידורים כדי לתזמן עבודות או בקשות עבודה לביצוע פעולות אחרות.

• הן פועלות מחוץ לאפליקציה, כך שאפשר להשתמש בהן כדי להפעיל אירועים או פעולות גם כשהאפליקציה לא פועלת, ואפילו אם המכשיר עצמו במצב שינה.

• הם עוזרים לכם לצמצם את דרישות המשאבים של האפליקציה. אפשר לתזמן פעולות בלי להסתמך על טיימרים או על שירותים שפועלים באופן רציף.

הגדרת שעון מעורר לא מדויק

כשבאפליקציה מוגדר שעון מעורר לא מדויק, המערכת מפעילה את השעון המעורר בשלב מסוים בעתיד. התראות לא מדויקות מספקות כמה הבטחות לגבי התזמון של שליחת ההתראה, תוך התחשבות בהגבלות של חיסכון בסוללה, כמו מצב שינה עמוקה.

מפתחים יכולים למנף את התחייבויות ה-API הבאות כדי להתאים אישית את התזמון של מסירת התראות לא מדויקות.

הפעלת התראה אחרי זמן מסוים

אם האפליקציה קוראת ל-set(), ל-setInexactRepeating(), או ל-setAndAllowWhileIdle(), ההתראה לא תופעל לפני שעת ההפעלה שצוינה.

ב-Android 12 (רמת API 31) ומעלה, המערכת מפעילה את ההתראה תוך שעה מזמן ההפעלה שצוין, אלא אם חלות הגבלות על חיסכון בסוללה, כמו חיסכון בסוללה או מצב שינה.

הפעלת שעון מעורר במהלך חלון זמן

אם האפליקציה קוראת ל-setWindow(), השעון המעורר לא יפעל לפני זמן ההפעלה שצוין. אלא אם יש הגבלות כלשהן לחיסכון בסוללה, האזעקה מופעלת בחלון הזמן שצוין, החל מזמן ההפעלה שצוין.

אם האפליקציה מכוונת ל-Android 12 או לגרסאות מתקדמות יותר, המערכת יכולה לעכב את ההפעלה של אזעקה לא מדויקת עם חלון זמן של לפחות 10 דקות. לכן, ערכי הפרמטר windowLengthMillis בקטע 600000 נחתכים ל-600000.

השמעת שעון מעורר חוזר במרווחי זמן קבועים בערך

אם האפליקציה קוראת ל-setInexactRepeating(), המערכת מפעילה כמה שעונים מעוררים:

1. ההתראה הראשונה תופעל בחלון הזמן שצוין, החל משעת ההפעלה שצוינה.
2. בדרך כלל, אזעקות חוזרות נשמעות אחרי שחלף חלון הזמן שצוין. הזמן בין שני הפעלות רצופות של ההתראה יכול להיות שונה.

הגדרת התראה מדויקת

המערכת מפעילה שעון מעורר מדויק ברגע מסוים בעתיד.

רוב האפליקציות יכולות לתזמן משימות ואירועים באמצעות שעונים מעוררים לא מדויקים כדי להשלים כמה תרחישי שימוש נפוצים. אם הפונקציונליות העיקרית של האפליקציה תלויה בהתראה מדויקת – למשל באפליקציית שעון מעורר או באפליקציית יומן – אפשר להשתמש בהתראה מדויקת במקום זאת.

תרחישי שימוש שאולי לא דורשים התראות מדויקות

ברשימה הבאה מפורטים תהליכי עבודה נפוצים שאולי לא מצריכים התראה מדויקת:

תזמון פעולות שקשורות לזמן במהלך מחזור החיים של האפליקציה

המחלקות Handler כוללות כמה שיטות טובות לטיפול בפעולות שקשורות לתזמון, כמו ביצוע עבודה כל n שניות, בזמן שהאפליקציה פועלת: postAtTime() ו- postDelayed(). הערה: ממשקי ה-API האלה מסתמכים על זמן הפעולה של המערכת ולא על זמן אמת.

עבודת רקע מתוזמנת, כמו עדכון האפליקציה והעלאת יומנים

‫

WorkManager מאפשרת לתזמן עבודה תקופתית שרגישה לזמן. אפשר לציין מרווח חזרה וflexInterval (15 דקות לפחות) כדי להגדיר זמן ריצה מפורט לעבודה.

פעולה שמוגדרת על ידי המשתמש וצריכה לקרות אחרי פרק זמן מסוים (גם אם המערכת במצב לא פעיל)

שימוש בהתראה לא מדויקת. במיוחד, התקשר אל setAndAllowWhileIdle().

פעולה שמוגדרת על ידי המשתמש וצריכה לקרות אחרי פרק זמן מסוים

שימוש בהתראה לא מדויקת. במיוחד, התקשר אל set().

פעולה שהמשתמש מגדיר שיכולה לקרות בחלון זמן מוגדר

שימוש בהתראה לא מדויקת. במיוחד, התקשר אל setWindow(). שימו לב: אם האפליקציה מטרגטת את Android מגרסה 12 ואילך, אורך החלון המינימלי המותר הוא 10 דקות.

דרכים להגדרת התראה מדויקת

אפשר להגדיר באפליקציה התראות מדויקות באחת מהדרכים הבאות. השיטות האלה מסודרות כך שהשיטות שקרובות יותר לתחתית הרשימה משרתות משימות שרגישות יותר לזמן, אבל דורשות יותר משאבי מערכת.

setExact()

הפעלת שעון מעורר בזמן מדויק בעתיד, כל עוד לא מופעלים אמצעים אחרים לחיסכון בסוללה.

משתמשים בשיטה הזו כדי להגדיר התראות מדויקות, אלא אם העבודה של האפליקציה היא קריטית למשתמשים מבחינת הזמן.

setExactAndAllowWhileIdle()

הפעלת שעון מעורר בשעה מדויקת בעתיד, גם אם מופעלים אמצעים לחיסכון בסוללה.

setAlarmClock()

הפעלת שעון מעורר בשעה מדויקת בעתיד. המשתמשים רואים את ההתראות האלה בבירור, ולכן המערכת אף פעם לא משנה את זמן המסירה שלהן. המערכת מזהה את ההתראות האלה כהתראות הכי קריטיות, ויוצאת ממצבי חיסכון בסוללה אם צריך כדי להציג אותן.

צריכת משאבי המערכת

כשהמערכת מפעילה אזעקות מדויקות שהאפליקציה מגדירה, המכשיר צורך הרבה משאבים, כמו חיי סוללה, במיוחד אם הוא במצב חיסכון באנרגיה. בנוסף, המערכת לא יכולה בקלות לאגד את הבקשות האלה כדי להשתמש במשאבים בצורה יעילה יותר.

מומלץ מאוד ליצור אזעקה לא מדויקת בכל הזדמנות אפשרית. כדי לבצע עבודה ארוכה יותר, אפשר לתזמן אותה באמצעות WorkManager או JobScheduler מתוך השעון המעורר BroadcastReceiver. כדי לבצע עבודה בזמן שהמכשיר במצב שינה, צריך ליצור התראה לא מדויקת באמצעות setAndAllowWhileIdle() ולהתחיל עבודה מההתראה.

הצהרה על ההרשאה המתאימה להתראה מדויקת

אם האפליקציה שלכם מטרגטת ל-Android מגרסה 12 ואילך, אתם צריכים לקבל הרשאת גישה מיוחדת ל'התראות ותזכורות'. כדי לעשות זאת, צריך להצהיר על ההרשאה SCHEDULE_EXACT_ALARM בקובץ המניפסט של האפליקציה, כמו שמוצג בקטע הקוד הבא:

<manifest ...>
    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM"/>
    <application ...>
        ...
    </application>
</manifest>

אם האפליקציה שלכם מטרגטת את Android 13 (רמת API 33) או גרסאות מתקדמות יותר, אתם יכולים להצהיר על ההרשאה SCHEDULE_EXACT_ALARM או על ההרשאה USE_EXACT_ALARM.

<manifest ...>
    <uses-permission android:name="android.permission.USE_EXACT_ALARM"/>
    <application ...>
        ...
    </application>
</manifest>

למרות ששתי ההרשאות, SCHEDULE_EXACT_ALARM ו-USE_EXACT_ALARM, מציינות את אותן יכולות, הן ניתנות בצורה שונה ותומכות בתרחישי שימוש שונים. האפליקציה שלך צריכה להשתמש בהתראות מדויקות ולהצהיר על ההרשאה SCHEDULE_EXACT_ALARM או USE_EXACT_ALARM רק אם פונקציה שגלויה למשתמשים באפליקציה מחייבת פעולות עם תזמון מדויק.

USE_EXACT_ALARM

• הוענקה אוטומטית
• המשתמש לא יכול לבטל את הגישה
• בכפוף למדיניות חדשה של Google Play
• תרחישים מוגבלים לדוגמה

SCHEDULE_EXACT_ALARM

• ניתנה על ידי המשתמש
• מגוון רחב יותר של תרחישים לדוגמה
• האפליקציות צריכות לוודא שההרשאה לא בוטלה

ההרשאה SCHEDULE_EXACT_ALARM לא ניתנת מראש להתקנות חדשות של אפליקציות שמטרגטות את Android 13 (רמת API‏ 33) ומעלה. אם משתמש מעביר נתוני אפליקציות למכשיר עם Android 14 באמצעות פעולת גיבוי ושחזור, ההרשאה SCHEDULE_EXACT_ALARM תידחה במכשיר החדש. עם זאת, אם לאפליקציה קיימת כבר יש את ההרשאה הזו, היא תינתן מראש כשהמכשיר ישודרג ל-Android 14.

הערה: אם ההתראה המדויקת מוגדרת באמצעות אובייקט OnAlarmListener, כמו באמצעות API‏ setExact, לא נדרשת ההרשאה SCHEDULE_EXACT_ALARM.

שימוש בהרשאה SCHEDULE_EXACT_ALARM

בניגוד להרשאה USE_EXACT_ALARM, המשתמש צריך להעניק את ההרשאה SCHEDULE_EXACT_ALARM. גם המשתמש וגם המערכת יכולים לבטל את ההרשאה SCHEDULE_EXACT_ALARM.

כדי לבדוק אם ההרשאה ניתנה לאפליקציה, צריך להתקשר אל canScheduleExactAlarms() לפני שמנסים להגדיר התראה מדויקת. כשמבטלים את ההרשאה SCHEDULE_EXACT_ALARM לאפליקציה, האפליקציה מפסיקה לפעול וכל ההתראות המדויקות העתידיות מבוטלות. זה גם אומר שהערך שמוחזר על ידי הפונקציה canScheduleExactAlarms() נשאר תקף למשך כל מחזור החיים של האפליקציה.

כשההרשאה SCHEDULE_EXACT_ALARMS ניתנת לאפליקציה, המערכת שולחת לה את השידור ACTION_SCHEDULE_EXACT_ALARM_PERMISSION_STATE_CHANGED. האפליקציה צריכה להטמיע מקלט שידור שמבצע את הפעולות הבאות:

1. מאשרים שלאפליקציה עדיין יש גישה מיוחדת. כדי לעשות את זה, מתקשרים למספר canScheduleExactAlarms(). הבדיקה הזו מגנה על האפליקציה במקרה שבו המשתמש מעניק לאפליקציה הרשאה, ואז מבטל אותה כמעט מיד לאחר מכן.
2. הפונקציה מתזמנת מחדש את כל ההתראות המדויקות שהאפליקציה צריכה, על סמך המצב הנוכחי שלה. הלוגיקה הזו צריכה להיות דומה למה שהאפליקציה עושה כשהיא מקבלת את השידור ACTION_BOOT_COMPLETED.

בקשה מהמשתמשים להעניק הרשאה ל-SCHEDULE_EXACT_ALARM

במקרה הצורך, אפשר להפנות את המשתמשים למסך התראות ותזכורות בהגדרות המערכת, כמו שמוצג באיור 1. כדי לעשות זאת, פועלים לפי השלבים הבאים:

1. בממשק המשתמש של האפליקציה, צריך להסביר למשתמש למה האפליקציה צריכה לתזמן אזעקות מדויקות.
2. מפעילים Intent שכולל את פעולת ה-Intent‏ ACTION_REQUEST_SCHEDULE_EXACT_ALARM.

הגדרת התראה חוזרת

התראות חוזרות מאפשרות למערכת להודיע לאפליקציה שלכם על בסיס לוח זמנים חוזר.

התראה שתוכננה בצורה לא טובה עלולה לגרום להתרוקנות הסוללה ולהעמיס עומס משמעותי על השרתים. לכן, ב-Android מגרסה 4.4 (רמת API‏ 19) ואילך, כל האזעקות החוזרות הן אזעקות לא מדויקות.

מאפיינים של שעון מעורר חוזר:

• סוג ההתראה. מידע נוסף זמין במאמר בחירת סוג ההתראה.

• שעת הפעלה. אם שעת ההפעלה שציינתם היא בעבר, ההתראה תופעל מיד.

• המרווח של השעון המעורר. לדוגמה, פעם ביום, כל שעה או כל 5 דקות.

• כוונה בהמתנה שמופעלת כשההתראה מופעלת. כשמגדירים שעון מעורר שני שמשתמש באותו pending intent, הוא מחליף את השעון המעורר המקורי.

כדי לבטל PendingIntent(), מעבירים את הכרטיס FLAG_NO_CREATE אל PendingIntent.getService() כדי לקבל מופע של הכוונה (אם הוא קיים), ואז מעבירים את הכוונה אל AlarmManager.cancel().

val alarmManager =
    context.getSystemService(Context.ALARM_SERVICE) as? AlarmManager
val pendingIntent =
    PendingIntent.getService(context, requestId, intent,
                                PendingIntent.FLAG_NO_CREATE)
if (pendingIntent != null && alarmManager != null) {
  alarmManager.cancel(pendingIntent)
}

AlarmManager alarmManager =
    (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
PendingIntent pendingIntent =
    PendingIntent.getService(context, requestId, intent,
                                PendingIntent.FLAG_NO_CREATE);
if (pendingIntent != null && alarmManager != null) {
  alarmManager.cancel(pendingIntent);
}

בחירת סוג השעון המעורר

אחד הדברים הראשונים שצריך לקחת בחשבון כשמשתמשים בהתראה חוזרת הוא מה צריך להיות הסוג שלה.

יש שני סוגים כלליים של שעונים להתראות: 'זמן שחלף בזמן אמת' ו'שעון זמן אמת' (RTC). הזמן שחלף בזמן אמת מתבסס על 'הזמן מאז הפעלת המערכת' כנקודת התייחסות, והשעון בזמן אמת מתבסס על זמן UTC (שעון קיר). כלומר, הזמן שחלף בזמן אמת מתאים להגדרת שעון מעורר על סמך הזמן שחלף (לדוגמה, שעון מעורר שמופעל כל 30 שניות), כי הוא לא מושפע מאזור זמן או ממיקום. סוג השעון בזמן אמת מתאים יותר לשעונים מעוררים שתלויים בשילוב של שפה ואזור הנוכחי.

לשני הסוגים יש גרסה של 'הוצאה ממצב שינה', שאומרת למעבד (CPU) של המכשיר להוציא ממצב שינה אם המסך כבוי. כך מוודאים שהשעון המעורר יופעל בזמן המתוזמן. האפשרות הזו שימושית אם האפליקציה תלויה בזמן. לדוגמה, אם יש לו חלון זמן מוגבל לביצוע פעולה מסוימת. אם לא משתמשים בגרסת ההוצאה ממצב שינה של השעון המעורר, כל ההתראות החוזרות יופעלו בפעם הבאה שהמכשיר יתעורר.

אם אתם רק צריכים שההתראה תופעל במרווח זמן מסוים (למשל, כל חצי שעה), השתמשו באחד מהסוגים של זמן אמיתי שחלף. בדרך כלל, זו הבחירה הטובה יותר.

אם אתם צריכים שההתראה תופעל בשעה מסוימת ביום, אתם צריכים לבחור באחד מסוגי השעון שמבוססים על שעון זמן אמת. עם זאת, חשוב לזכור שלגישה הזו יש כמה חסרונות. יכול להיות שהאפליקציה לא תתורגם טוב ללוקאלים אחרים, ואם המשתמש ישנה את הגדרת השעה במכשיר, יכול להיות שיופיעו באפליקציה התנהגויות לא צפויות. כמו כן, כפי שצוין למעלה, שימוש בסוג שעון מעורר של שעון זמן אמת לא מתאים לשינוי גודל. מומלץ להשתמש בהתראה מסוג 'זמן שעבר בזמן אמת' אם אפשר.

זו רשימת הסוגים:

• ‫ELAPSED_REALTIME: מפעיל את ה-pending intent על סמך משך הזמן שעבר מאז הפעלת המכשיר, אבל לא מוציא את המכשיר ממצב שינה. הזמן שחלף כולל את כל הזמן שבו המכשיר היה במצב שינה.

• ‫ELAPSED_REALTIME_WAKEUP: המכשיר מתעורר ומפעיל את הכוונה בהמתנה אחרי שחלף משך הזמן שצוין מאז הפעלת המכשיר.

• ‫RTC: מפעיל את הכוונה בהמתנה בזמן שצוין, אבל לא מוציא את המכשיר ממצב שינה.

• ‫RTC_WAKEUP: מעיר את המכשיר כדי להפעיל את הכוונה בהמתנה בזמן שצוין.

דוגמאות להתראות על זמן שחלף

הנה כמה דוגמאות לשימוש ב-ELAPSED_REALTIME_WAKEUP

תעיר את המכשיר כדי שההתראה תופעל בעוד 30 דקות, ואחרי זה כל 30 דקות:

// Hopefully your alarm will have a lower frequency than this!
alarmMgr?.setInexactRepeating(
        AlarmManager.ELAPSED_REALTIME_WAKEUP,
        SystemClock.elapsedRealtime() + AlarmManager.INTERVAL_HALF_HOUR,
        AlarmManager.INTERVAL_HALF_HOUR,
        alarmIntent
)

// Hopefully your alarm will have a lower frequency than this!
alarmMgr.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
        SystemClock.elapsedRealtime() + AlarmManager.INTERVAL_HALF_HOUR,
        AlarmManager.INTERVAL_HALF_HOUR, alarmIntent);

כדי להפעיל התראה חד-פעמית (לא חוזרת) בעוד דקה, מעירים את המכשיר:

private var alarmMgr: AlarmManager? = null
private lateinit var alarmIntent: PendingIntent
...
alarmMgr = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
alarmIntent = Intent(context, AlarmReceiver::class.java).let { intent ->
    PendingIntent.getBroadcast(context, 0, intent, 0)
}

alarmMgr?.set(
        AlarmManager.ELAPSED_REALTIME_WAKEUP,
        SystemClock.elapsedRealtime() + 60 * 1000,
        alarmIntent
)

private AlarmManager alarmMgr;
private PendingIntent alarmIntent;
...
alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, AlarmReceiver.class);
alarmIntent = PendingIntent.getBroadcast(context, 0, intent, 0);

alarmMgr.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
        SystemClock.elapsedRealtime() +
        60 * 1000, alarmIntent);

דוגמאות להתראות של שעון בזמן אמת

הנה כמה דוגמאות לשימוש ב-RTC_WAKEUP.

מעירים את המכשיר כדי שהשעון המעורר יצלצל בערך בשעה 14:00, וחוזרים על הפעולה פעם ביום באותה שעה:

// Set the alarm to start at approximately 2:00 p.m.
val calendar: Calendar = Calendar.getInstance().apply {
    timeInMillis = System.currentTimeMillis()
    set(Calendar.HOUR_OF_DAY, 14)
}

// With setInexactRepeating(), you have to use one of the AlarmManager interval
// constants--in this case, AlarmManager.INTERVAL_DAY.
alarmMgr?.setInexactRepeating(
        AlarmManager.RTC_WAKEUP,
        calendar.timeInMillis,
        AlarmManager.INTERVAL_DAY,
        alarmIntent
)

// Set the alarm to start at approximately 2:00 p.m.
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 14);

// With setInexactRepeating(), you have to use one of the AlarmManager interval
// constants--in this case, AlarmManager.INTERVAL_DAY.
alarmMgr.setInexactRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
        AlarmManager.INTERVAL_DAY, alarmIntent);

מוציאים את המכשיר ממצב שינה כדי שההתראה תופעל בדיוק בשעה 8:30 בבוקר, ואחרי כן כל 20 דקות:

private var alarmMgr: AlarmManager? = null
private lateinit var alarmIntent: PendingIntent
...
alarmMgr = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
alarmIntent = Intent(context, AlarmReceiver::class.java).let { intent ->
    PendingIntent.getBroadcast(context, 0, intent, 0)
}

// Set the alarm to start at 8:30 a.m.
val calendar: Calendar = Calendar.getInstance().apply {
    timeInMillis = System.currentTimeMillis()
    set(Calendar.HOUR_OF_DAY, 8)
    set(Calendar.MINUTE, 30)
}

// setRepeating() lets you specify a precise custom interval--in this case,
// 20 minutes.
alarmMgr?.setRepeating(
        AlarmManager.RTC_WAKEUP,
        calendar.timeInMillis,
        1000 * 60 * 20,
        alarmIntent
)

private AlarmManager alarmMgr;
private PendingIntent alarmIntent;
...
alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, AlarmReceiver.class);
alarmIntent = PendingIntent.getBroadcast(context, 0, intent, 0);

// Set the alarm to start at 8:30 a.m.
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 8);
calendar.set(Calendar.MINUTE, 30);

// setRepeating() lets you specify a precise custom interval--in this case,
// 20 minutes.
alarmMgr.setRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
        1000 * 60 * 20, alarmIntent);

החליטו מה רמת הדיוק של השעון המעורר

כמו שצוין קודם, בחירת סוג ההתראה היא לרוב השלב הראשון ביצירת התראה. ההבדל הנוסף הוא רמת הדיוק שאתם רוצים שההתראה תהיה. ברוב האפליקציות, setInexactRepeating() היא הבחירה הנכונה. כשמשתמשים בשיטה הזו, מערכת Android מסנכרנת כמה אזעקות חוזרות לא מדויקות ומפעילה אותן בו-זמנית. כך קצב התרוקנות הסוללה יקטן.

אם אפשר, מומלץ להימנע משימוש בהתראות מדויקות. עם זאת, באפליקציות נדירות שיש להן דרישות זמן קשיחות, אפשר להגדיר שעון מעורר מדויק על ידי קריאה ל-setRepeating().

ב-setInexactRepeating() אי אפשר לציין מרווח זמן מותאם אישית כמו ב-setRepeating(). צריך להשתמש באחד הקבועים של המרווחים, כמו INTERVAL_FIFTEEN_MINUTES, INTERVAL_DAY, וכן הלאה. AlarmManager הרשימה המלאה

ביטול שעון מעורר

בהתאם לאפליקציה, יכול להיות שתרצו לכלול אפשרות לביטול האזעקה. כדי לבטל התראה, מתקשרים אל cancel() ב-Alarm Manager ומעבירים את PendingIntent שלא רוצים יותר להפעיל. לדוגמה:

// If the alarm has been set, cancel it.
alarmMgr?.cancel(alarmIntent)

// If the alarm has been set, cancel it.
if (alarmMgr!= null) {
    alarmMgr.cancel(alarmIntent);
}

הפעלת שעון מעורר כשהמכשיר מופעל מחדש

כברירת מחדל, כל האזעקות מבוטלות כשמכבים את המכשיר. כדי למנוע את המצב הזה, אפשר לתכנן את האפליקציה כך שהיא תפעיל מחדש באופן אוטומטי אזעקה חוזרת אם המשתמש יפעיל מחדש את המכשיר. כך מוודאים שAlarmManager ימשיך לבצע את המשימה בלי שהמשתמש יצטרך להפעיל מחדש את ההתראה באופן ידני.

אלה השלבים:

1. מגדירים את ההרשאה RECEIVE_BOOT_COMPLETED במניפסט של האפליקציה. ההרשאה הזו מאפשרת לאפליקציה לקבל את ACTION_BOOT_COMPLETED שמשודר אחרי שהמערכת מסיימת את האתחול (ההרשאה הזו פועלת רק אם המשתמש כבר הפעיל את האפליקציה לפחות פעם אחת):

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

2. הטמעה של BroadcastReceiver כדי לצפות בשידור:

   Kotlin

   class SampleBootReceiver : BroadcastReceiver() {
   
       override fun onReceive(context: Context, intent: Intent) {
           if (intent.action == "android.intent.action.BOOT_COMPLETED") {
               // Set the alarm here.
           }
       }
   }

   Java

   public class SampleBootReceiver extends BroadcastReceiver {
   
       @Override
       public void onReceive(Context context, Intent intent) {
           if (intent.getAction().equals("android.intent.action.BOOT_COMPLETED")) {
               // Set the alarm here.
           }
       }
   }

3. מוסיפים את ה-receiver לקובץ המניפסט של האפליקציה עם מסנן Intent שמסנן את הפעולה ACTION_BOOT_COMPLETED:

   <receiver android:name=".SampleBootReceiver"
           android:enabled="false">
       <intent-filter>
           <action android:name="android.intent.action.BOOT_COMPLETED"></action>
       </intent-filter>
   </receiver>

   שימו לב שבמניפסט, מקלט האתחול מוגדר ל-android:enabled="false". כלומר, לא תהיה קריאה למקבל אלא אם האפליקציה תפעיל אותו במפורש. כך נמנעת קריאה מיותרת של מקלט האתחול. כך מפעילים מקלט (לדוגמה, אם המשתמש מגדיר שעון מעורר):

   Kotlin

   val receiver = ComponentName(context, SampleBootReceiver::class.java)
   
   context.packageManager.setComponentEnabledSetting(
           receiver,
           PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
           PackageManager.DONT_KILL_APP
   )

   Java

   ComponentName receiver = new ComponentName(context, SampleBootReceiver.class);
   PackageManager pm = context.getPackageManager();
   
   pm.setComponentEnabledSetting(receiver,
           PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
           PackageManager.DONT_KILL_APP);

   אחרי שמפעילים את המקלט בדרך הזו, הוא יישאר מופעל גם אם המשתמש יפעיל מחדש את המכשיר. במילים אחרות, הפעלה פרוגרמטית של המקלט מבטלת את הגדרת המניפסט, גם אחרי הפעלה מחדש. מקלט הנתונים יישאר מופעל עד שהאפליקציה תשבית אותו. כדי להשבית מקלט (לדוגמה, אם המשתמש מבטל את האזעקה):

   Kotlin

   val receiver = ComponentName(context, SampleBootReceiver::class.java)
   
   context.packageManager.setComponentEnabledSetting(
           receiver,
           PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
           PackageManager.DONT_KILL_APP
   )

   Java

   ComponentName receiver = new ComponentName(context, SampleBootReceiver.class);
   PackageManager pm = context.getPackageManager();
   
   pm.setComponentEnabledSetting(receiver,
           PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
           PackageManager.DONT_KILL_APP);

הפעלת אזעקות כשהמכשיר במצב נמנום

מכשירים עם Android 6.0 (רמת API ‏23) תומכים במצב שינה עמוקה, שעוזר להאריך את חיי הסוללה של המכשיר. השעון המעורר לא יצלצל כשהמכשיר נמצא במצב שינה. כל השעונים המעוררים שתוזמנו יופעלו רק כשהמכשיר יצא ממצב שינה. אם אתם צריכים להשלים עבודה גם כשהמכשיר בלי פעילות, יש כמה אפשרויות:

• הגדרת שעון מעורר מדויק.

• משתמשים ב-WorkManager API, שנועד לבצע עבודה ברקע. אתם יכולים לציין שהמערכת צריכה לזרז את העבודה כדי שהיא תסתיים בהקדם האפשרי. מידע נוסף זמין במאמר בנושא תזמון משימות באמצעות WorkManager

שיטות מומלצות

לכל בחירה שתעשו בתכנון של אזעקה חוזרת יכולות להיות השלכות על האופן שבו האפליקציה משתמשת במשאבי המערכת (או עושה בהם שימוש לרעה). לדוגמה, נניח שיש אפליקציה פופולרית שמסתנכרנת עם שרת. אם פעולת הסנכרון מבוססת על שעת שעון וכל מופע של האפליקציה מסתנכרן בשעה 23:00, העומס על השרת עלול לגרום לזמן אחזור ארוך או אפילו ל'התקפת מניעת שירות (DoS)'. כדאי לפעול לפי השיטות המומלצות הבאות לשימוש בהתראות:

• הוספת אקראיות (jitter) לכל בקשות הרשת שמופעלות כתוצאה מהתראה חוזרת:

  • לבצע עבודה מקומית כשההתראה מופעלת. 'עבודה מקומית' היא כל פעולה שלא מגיעה לשרת או שלא דורשת את הנתונים מהשרת.

  • במקביל, מתזמנים את האזעקה שמכילה את בקשות הרשת כך שתופעל בתקופה אקראית כלשהי.

• כדאי להגדיר את השעון המעורר לתדירות מינימלית.

• אין להוציא את המכשיר ממצב שינה שלא לצורך (התנהגות זו נקבעת לפי סוג השעון המעורר, כפי שמתואר במאמר בחירת סוג התראה).

• אל תגדירו את זמן ההפעלה של השעון המעורר בצורה מדויקת יותר ממה שצריך.

  במקום setRepeating(), צריך להשתמש ב-setInexactRepeating(). כשמשתמשים בsetInexactRepeating(), מערכת Android מסנכרנת התרעות חוזרות מכמה אפליקציות ומפעילה אותן בו-זמנית. כך מצמצמים את מספר הפעמים הכולל שבהן המערכת צריכה להוציא את המכשיר ממצב שינה, וכך מפחיתים את התרוקנות הסוללה. החל מ-Android 4.4‏ (API ברמה 19), כל האזעקות החוזרות הן אזעקות לא מדויקות. הערה: למרות ש-setInexactRepeating() הוא שיפור לעומת setRepeating(), הוא עדיין עלול לגרום לעומס יתר על השרת אם כל מופע של אפליקציה יפנה לשרת בערך באותו הזמן. לכן, כשמדובר בבקשות לרשת, כדאי להוסיף קצת אקראיות לאזעקות, כמו שצוין קודם.

• אם אפשר, כדאי להימנע מהגדרת השעון המעורר לפי השעה.

  שעונים מעוררים חוזרים שמבוססים על זמן טריגר מדויק לא מתאימים לשימוש נרחב. אם אפשר, משתמשים ב-ELAPSED_REALTIME. בקטע הבא מפורטים סוגי ההתראות השונים.