PracticU

שליחת מידע ל-Fragment

בלי כתוביותעם כתוביות
PracticU › קורס פיתוח אפליקציות - לאנדרואיד - Android - ב-JAVA › שליחת מידע ל-Fragment
מילון מושגים:
Fragment - ב-Android, רכיב ממשק הניתן לשימוש חוזר בתוך Activity, שמייצג חלק ממסך או התנהגות.
פרמטר - ערך שמועבר לפונקציה או לפקודה כקלט, ומשפיע על אופן פעולתן ועל התוצאה שהן מחזירות.
לייאאוט - ארגון וסידור הרכיבים החזותיים על המסך או בדף, כמו מיקום כפתורים, טקסט ותמונות.
תמונה - קובץ גרפי המוצג על המסך. בהקשר של וירטואליזציה או Docker, תבנית מוכנה שממנה יוצרים מכונה או קונטיינר.
root - משתמש העל במערכות Linux, בעל הרשאות מלאות לכל פעולה. גם הרמה העליונה בעץ של תיקיות או נתונים.
משתנה - שם שמפנה למקום בזיכרון שבו נשמר ערך שיכול להשתנות במהלך ריצת התוכנית, כמו מספר, טקסט או אובייקט.
Activity - ב-Android, רכיב שמייצג מסך יחיד של האפליקציה שאיתו המשתמש מתקשר.
מחרוזת - סוג נתונים שמייצג רצף של תווים, כלומר טקסט, ומשמש לאחסון מילים, משפטים או כל רצף סימנים.

שליחת מידע ל-Fragment
כדי שפרגמנט אחת תציג מידע על חיה כלשהי, והמידע יגיע מבחוץ, צריך להעביר לה פרמטרים. ההרצאה מראה שתי דרכים: Bundle בזמן היצירה, ופונקציה ציבורית לעדכון אחרי שהפרגמנט כבר קיימת.
השלבים העיקריים
1. פרגמנט כללית: מוחקים את פרגמנט הפאפי ומשאירים אחת בשם AnimalFragment. ב-layout נותנים ל-ImageView ול-TextView ID כלליים (imageViewAnimal, textViewAnimal), בלי תמונה וטקסט קבועים.
2. קבלת ה-Bundle: ב-onCreateView קוראים ל-getArguments(). הוא עלול להיות null אם לא נשלח כלום, ולכן בודקים לפני שמושכים נתונים.
3. שליפת הנתונים: מה-Bundle קוראים getInt עבור imageId ו-getString עבור description. את ה-ImageView ואת ה-TextView משיגים דרך findViewById על ה-layout root ושומרים במשתנים גלובליים.
4. פונקציה ציבורית: displayAnimal(imageId, description) קוראת ל-setImageResource ול-setText. היא משמשת גם בתוך onCreateView, וגם מבחוץ כדי להחליף מידע בפרגמנט קיימת.
5. שליחה מהמיין אקטיביטי: ביצירה בפעם הראשונה: יוצרים AnimalFragment, Bundle, putInt עם R.drawable.bunny, putString עם getResources().getString(R.string.bunny), ומעבירים עם setArguments.
6. שינוי בזמן ריצה: לחצן "change data" קורא ישירות ל-animalFragment.displayAnimal עם נתוני הפאפי, והתצוגה מתחלפת.
7. דיזיין פאטרן newInstance: פונקציה סטטית ציבורית במחלקת הפרגמנט, שמקבלת imageId ו-description, בונה את הפרגמנט ואת ה-Bundle, מעבירה אותו ומחזירה את הפרגמנט. במיין אקטיביטי קוראים רק AnimalFragment.newInstance(R.drawable.bunny, ...).
שימו לב
בלי newInstance צריך ארבעה צעדים: ליצור פרגמנט, ליצור Bundle, למלא אותו ולהעביר עם setArguments. השיטה הזו מצמצמת הכול לשורה אחת.
כעת אפשר להעביר פרמטרים לפרגמנט גם בזמן יצירתה וגם אחרי שהיא כבר מוצגת.
השיעור הבא בקורס: קבלת מידע בחזרה מ-Fragment

פרקי ההרצאה: שליחת מידע ל-Fragment

  1. 00:00

    העברת פרמטרים ל-Fragment

  2. 00:58

    Fragment כללי אחד לכל חיה

  3. 02:44

    קבלת Bundle עם getArguments

  4. 04:18

    איתור ImageView ו-TextView בקוד

  5. 06:12

    שליפת image ID ותיאור מה-Bundle

  6. 07:28

    פונקציה ציבורית displayAnimal

תמלול ההרצאה: שליחת מידע ל-Fragment

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

  1. 00:00

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

  2. 00:17

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

  3. 00:33

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

  4. 00:54

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

  5. 01:23

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

  6. 01:52

    הדבר הבא שאנחנו רוצים זה אנחנו לא רוצים את התמונה של הבני, ואנחנו לא רוצים את הטקסט של הבני, מפני שאנחנו רוצים להגדיר את זה בקוד. את ה-100DP אנחנו יכולים לשנות ל-RapContent, והכנו את ה-Layout של ה-Framework, של סליחה, של ה-Fragment של Bani.

  7. 02:19

    אבל אנחנו רוצים לשנות גם את השמות האלה, בואו נעשה את זה לידי Shift-6 ל-AnimalFragment. שינינו כאן את ה-Code של ה-Java, בואו Shift-6 על ה-Layout של ה-Fragment, נקרא לזה Fragment Animal, בצורה כזאת.

  8. 02:44

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

  9. 03:00

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

  10. 03:16

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

  11. 03:30

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

  12. 03:45

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

  13. 03:57

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

  14. 04:21

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

  15. 04:42

    הנה ה-image-view, נקרא לו image-view-animal, והנה private-text-view, נקרא לו text-view-animal. והשאלה היא, איך אנחנו משיגים את האובייקטים עצמם?

  16. 04:59

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

  17. 05:11

    אם יש לנו את אובייקט הלאאוט של הפרגמנט, אנחנו דרכו, לינאר לאוט רוט, יכולים to find view by id, לתת לו r.id. הנה ה-image-view-animal, ולהכניס אותו לתוך ה-image-view-animal.

  18. 05:31

    בואו ניצור כאן אובייקט. נבצע קאסטינג מתאים, בצורה כזאת, ואנחנו רוצים את אותו הדבר לבצע ל-TextViewAnimal. יש לנו פה TextView, הנה אובייקט ה-LinearLayout, דרכו אנחנו מבצעים FindViewById, R.ID, TextViewAnimal.

  19. 05:53

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

  20. 06:16

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

  21. 06:33

    מה בעצם אמורים להביא לנו? אמורים להביא לנו את הקוד של התמונה ואת הדסקריפשן, את התיאור. אז בואו ניגש לבנדל ונצפה לקבל אינטג'ר שה-ID שלו זה image ID.

  22. 06:51

    הכי שלו זה image ID. בואו ניקח כאן זה שהוא int, image ID. והנה קיבלנו מהבנדל את הקוד של התמונה ששלחו לנו מבחוץ. עכשיו בואו נקבל את הדסקריפשן.

  23. 07:08

    הנה יש לנו פה object description, ניגש שוב פעם לבנדל, get string, ונצפה שהkey יהיה description בצורה כזאת. כעת יש לנו גם את הimage id וגם את הדסקריפשן.

  24. 07:28

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

  25. 07:51

    ופשוט ניגש ל-imageViewAnimal, setImageResource, הנה ה-imageId שקיבלנו, ניגש ל-textViewAnimal, נגדיר setTextDescription, והנה שמנו את הדסקריפשן, והפונקציה display animal אנחנו יכולים לקרוא לה מפה ולשלוח את ה-image ID ואת הדסקריפשן.

  26. 08:22

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

  27. 08:55

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

  28. 09:15

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

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

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

ההרצאה הבאה: קבלת מידע בחזרה מ-Fragment

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

  • שליחת מידע לשרת בריאקט - React Forms
  • שליחת email
  • אבטחת מידע
  • שליחת מייל פישינג - GoPhish

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

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