PracticU

Receive App Broadcast

בלי כתוביותעם כתוביות
PracticU › קורס פיתוח אפליקציות - לאנדרואיד - Android - ב-JAVA › Receive App Broadcast
מילון מושגים:
חבילה - אוסף ארוז של קוד, ספריות או קבצים המופץ כיחידה אחת ומותקן בעזרת מנהל חבילות.
רכיב - יחידת בניין עצמאית וניתנת לשימוש חוזר בתוך מערכת או ממשק משתמש, שאחראית על חלק מוגדר מהתפקוד.
ממשק - נקודת מגע בין רכיבים: ממשק משתמש שבו אדם מפעיל תוכנה, או ממשק תכנותי שמגדיר אילו פעולות רכיב אחד חושף לאחר.
אירוע - התרחשות שהמערכת מזהה ויכולה להגיב לה, כמו לחיצת עכבר, הקשה או סיום פעולה.
מחלקה - תבנית בתכנות מונחה עצמים שמגדירה אילו נתונים ופעולות יהיו לאובייקטים שנוצרים ממנה.
Intent - ב-Android, אובייקט הודעה שמבקש פעולה, למשל מעבר בין מסכים או הפעלת רכיב אחר.
ArrayList - מבנה נתונים של רשימה דינמית שגודלה משתנה, הנפוץ בשפות כמו Java ו-C#.

Receive App Broadcast
הצד המקבל: אפליקציה נפרדת לגמרי נרשמת לשידורי המטלות מהשיעור הקודם ומציגה אותם ב-ListView. בדרך מוצגים כמה עקרונות נוספים.
השלבים העיקריים
1. אפליקציה נפרדת: פרויקט חדש עם package שונה מהקודם. אם ה-package זהה, ההתקנה השנייה דורסת את הראשונה. באפליקציה כותרת Tasks ו-ListView בלבד, בלי אפשרות להוסיף מטלה, כי המטלות יגיעו בשידור.
2. מחלקת TasksReceiver: יורשת מ-BroadcastReceiver וממשת את onReceive.
3. דיווח ל-UI בעזרת Listener: ל-Receiver אין גישה ל-ListView, והיא לא אמורה, כי היא אינה רכיב UI. לכן מגדירים ממשק OnTaskListener עם onTaskAdded ו-onTaskRemoved, שדה listener ופונקציה setOnTaskListener.
4. הבחנה בין אירועים: מחלקה אחת יכולה להיות רשומה לכמה אירועים. ב-onReceive קוראים ל-intent.getAction(). אם הוא שווה ל-Action של ההוספה, שולפים את ה-extra עם getStringExtra וקוראים ל-onTaskAdded. אחרת, אם שווה ל-Action של ההסרה, שולפים את ה-extra המתאים וקוראים ל-onTaskRemoved.
5. רישום דינמי ב-onCreate: יוצרים TasksReceiver, קוראים ל-setOnTaskListener ומגדירים ל-MainActivity לממש את הממשק (Alt-Enter). בונים IntentFilter ומוסיפים שני Actions (הוספה והסרה), ואז registerReceiver(receiver, filter). הרישום בקוד נוח כאן כי צריך את ה-Listener.
6. מימוש הממשק: ב-onTaskAdded מוסיפים את המטלה ל-ArrayList וקוראים ל-notifyDataSetChanged. ב-onTaskRemoved מסירים אותה ומרעננים.
7. בדיקה: מריצים את אפליקציית השידור ומוסיפים מטלות, והן מופיעות באפליקציה המקבלת. מחיקה של מטלה באפליקציה המשדרת מסירה אותה גם מהרשימה השנייה.
שימו לב
הרישום נעשה לפי ה-Action שמורכב מה-package של האפליקציה המשדרת. קבלת שידורים מאפליקציה אחרת דומה לקבלת שידורים ממערכת אנדרואיד.
אחרי השיעור אפשר לשדר הודעות מאפליקציה אחת ולקבל אותן באפליקציה אחרת, כולל טיפול בכמה אירועים באותה מחלקה.

פרקי ההרצאה: Receive App Broadcast

  1. 00:00

    אפליקציה נפרדת שמקבלת Broadcast

  2. 00:42

    Package שונה לכל אפליקציה

  3. 01:21

    מסך מטלות בלי אפשרות הוספה

  4. 02:19

    מחלקת TasksReceiver

  5. 03:21

    דיווח ל-UI עם Listener

  6. 05:31

    זיהוי האירוע לפי getAction

  7. 06:29

    שליפת המטלה והעברתה לממשק

  8. 07:55

    רישום דינמי ב-onCreate

תמלול ההרצאה: Receive App Broadcast

הטקסט המלא של הדקות הראשונות בהרצאה «Receive App Broadcast» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

  1. 00:02

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

  2. 00:22

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

  3. 00:38

    הפאקג' הקודם היה com.practic.u במילה אחת. הפאקג' הזה קראתי לו com.practic.u בכדי שיהיה איזשהו שינוי בפאקג'. אם אין שום שינוי בפאקג', אז אי אפשר להתקין את שתי האפליקציות האלה לאותו מכשיר.

  4. 00:53

    ההתקנה השנייה תדרוס את הראשונה. אז קודם כל יש לנו כאן שני פאקג'ים שונים, ולכן שתי אפליקציות שונות לגמרי. עכשיו, מה יש לנו באפליקציה הזאת? יש לנו כאן איזושהי כותרת tasks ויש לנו כאן list view בכדי להציג את כל הtasks, אבל אין לנו שום אפשרות באפליקציה הזאת להוסיף task.

  5. 01:18

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

  6. 01:31

    מה יש לנו ב-Java Code? יש לנו קודם כל את ה-List View כאן, אנחנו רואים אותו שאמור להציג את כל המטלות. יש לנו כאן את ה-Array Adapter ויש לנו כאן את ה-Array List שמחזיק את המטלות.

  7. 01:49

    בואו את זה נעביר למעלה. אוקיי, עכשיו ב-OnCreate מה שעשינו זה התרנו את ה-List View. יש לנו כאן את האדפטר שמציג את ה-ArrayList שכמובן הוא כרגע ריק לגמרי, עדיין כשאנחנו מריצים את האפליקציה אין לנו מטלות וחיברנו את האדפטר ל-ListView כך שנוכל להציג את התוכן של ה-ArrayList.

  8. 02:19

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

  9. 02:34

    בואו נקרא לה tasks receiver, נבצע אוקיי, נירש את בודקאסט רסיבר בצורה כזאת, נבצע implement methods, יש לנו פה את המתודה האחת והיחידה on receive, ואנחנו יודעים שברגע שהאירוע ידווח, כלומר מטלה תתווסף באפליקציה האחרת שבנינו, הקודמת, והיא תדווח את זה למערכת הברודקאסט, אנחנו נקבל את זה וה-on-receive הזה יתבצע.

  10. 03:10

    מה אנחנו רוצים לעשות? אנחנו רוצים להוסיף את זה ל-list view של המיין אקטיביטי. אוקיי, אז איך יש לנו גישה ל-list view של המיין אקטיביטי?

  11. 03:24

    אז התשובה היא שאין לנו גישה ל-list view של המיין אקטיביטי, ולא אמורה להיות לנו גישה ל-list view של המיין אקטיביטי, כי אנחנו לא רכיב UI, רכיב האזנה לאירועים של המערכת אבל מה שאנחנו כן יכולים לעשות זה לדווח ל-UI על ידי כל הקונספט של ה-Listener Design Pattern וכך אם ה-UI

  12. 03:51

    יוצר אובייקט שלנו אז הוא יוכל לקבל את הדיווחים אז בואו נעשה את זה ותוך כדי ניזכר מה זה היה ה-Listener Design Pattern אז הפאטרן הזה אומר שיש לנו איזשהו אינטרפייס, נקרא לו onTaskListener ויש לו שתי פונקציות onTaskAdded שמדווחת את ה-added task ו-onTaskRemoved שמדווחת את ה-removed task.

  13. 04:35

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

  14. 05:06

    הגלובלי. this.listener שווה listener בצורה כזאת. אוקיי, כל מה שנשארנו לעשות זה לממש את פונקציית ה-OwnReceive ואנחנו רוצים לקבל קודם כל את ה-Task ולדווח את זה ל-UI.

  15. 05:27

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

  16. 05:46

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

  17. 05:54

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

  18. 06:04

    מה שאנחנו צריכים לעשות זה לקחת את האקשן על ידי האינטנט get action וזה מאפשר לנו לדעת בול איזה אירוע הפעיל אותנו. ולעת כל מה שאנחנו צריכים לעשות זה לבדוק האם האקשן equals לאירוע added task או task added איך שקראנו לו.

  19. 06:30

    אז זה היה com.practicu במילה אחת .task underline added אם זה המצב והוא שווה לו אז אנחנו רוצים לשלוף את הטאסק שדווחה אלינו את המטלה שדווחה בואו ניקח כאן AddedTask וניגש ל-intent.getStringExtra AddedTask בצורה כזאת.

  20. 07:03

    אחרי שיש לנו את ה-Task אנחנו רוצים לדווח אותו. אז אנחנו רוצים לעשות קריאה, לקרוא לפונקציה onTaskAdded ולשלוח את ה-AddedTask.

  21. 07:21

    במידה והאקשן שווה ל-com.practicue.task_removed אנחנו רוצים להוציא את ה-removedTask. אנחנו רוצים לשלוף אותה על ידי intent.getStringExtra.removedTask בצורה כזאת ולדווח על ידי listener onTaskRemoved וסיימנו לבנות את המחלקה שמקבלת את הדיווחים.

  22. 08:02

    כל מה שאנחנו רוצים לעשות עכשיו זה להירשם אליה, ובגלל שאנחנו רוצים לקבל דיווחים מהמחלקה הזאת על ידי ה-Listener Design Pattern, אז הדבר הכי נוח לבצע זה להירשם דרך Java Code.

  23. 08:18

    אז בואו נחזור ל-Code ב-Java, וכאן אנחנו רוצים ב-OnCreate לבצע את הרישום הדינמי ל-Broadcast Receiver. אנחנו רוצים לבנות אובייקט מטיפוס, tasks receiver בואו נעשה new tasks receiver הנה האובייקט שלנו לאחר מכן אנחנו רוצים להירשם לאירועים שהוא מדווח אלינו על ידי ה-listener שלו אז יש לנו פה את ה-tasks receiver.set on task listener ולהגיד לו תקשיב

  24. 08:57

    המחלקה שלנו המיין אקטיביטי מממשת את האינטרפייס הזה מה שעדיין לא נכון אז הוא אומר לנו תקשיבו יש לכם פה שגיאה ועדיין לא נכון אז אנחנו יכולים ללחוץ על Alt Enter ולהגיד לו Make Main Activity Implement את ה-Interface on Task Listener אז הוא אומר לנו יש לכם שתי פונקציות שאתם צריכים

  25. 09:21

    לממש אין שום בעיה בואו נממש אותם והנה אנחנו רואים שה-Main Activity בעצם מממשת את ה-Interface on Task ליסנר שמקבלת את הדיווחים מהטאסקס רסיבר והוא יקבל את הדיווחים כמובן מהאפליקציה השנייה ויגיד לנו שאנחנו UI, אנחנו היוזר אינטרפייס.

  26. 09:45

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

לקורס המלא: קורס פיתוח אפליקציות לאנדרואיד

ההרצאה הקודמת: Broadcast

ההרצאה הבאה: Show Notification

הרצאות קשורות מקורסים אחרים

  • הסבר על App Secrets
  • App Engine - Serverless - חלק 1
  • הסבר על Azure App Service
  • Build .NET app on Docker

קורסים נוספים במסלול

  • קורס יסודות התכנות - שפת JAVA - קורס ג'אווה למתחילים
  • קורס פיתוח אפליקציות - לאייפון iPhone iOS - ב-Swift-Xcode
  • קורס פלאטר - Flutter - שפת DART של גוגל למובייל - פיתוח אפליקציות לאנדרואיד ואייפון
  • קורס PhoneGap - פיתוח אפליקציות לאנדרואיד ואייפון