מצלמה - חלק 4 - צילום מתוך האפליקציה - המשך

בלי כתוביותעם כתוביות

מילון מושגים:

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

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

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

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

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

תגית - סימון בקוד, למשל ב-HTML, שתוחם רכיב ומגדיר את תפקידו או תכונותיו. גם תווית לסימון וקיטלוג פריטים.

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

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

מצלמה - חלק 4 - צילום מתוך האפליקציה - המשך

כדי ש-MainActivity לא תסחב קוד של מצלמה, מוציאים את כל לוגיקת ה-SurfaceView למחלקה משלה, שמתנהגת כרכיב ויזואלי חדש ומוצבת ישירות ב-Layout.

השלבים העיקריים

1. מחלקה CameraSurfaceView: יורשת מ-SurfaceView. מעבירים אליה מ-MainActivity את השדות SurfaceHolder ו-Camera (כשדות פרטיים) ואת פעולות האתחול, שנכנסות לקונסטרקטור. במקום אובייקט SurfaceView קוראים ל-getHolder() של המחלקה עצמה.

2. הקונסטרקטור של רכיב ויזואלי: כדי להציב את המחלקה על Layout, הקונסטרקטור צריך לקבל Context ו-AttributeSet, כלומר את האטריבוטים שהוגדרו ב-XML (רוחב, גובה, ID ועוד), ולהעביר אותם ל-super.

3. מימוש ה-Callback: המחלקה עצמה מממשת את SurfaceHolder.Callback, והקוד של surfaceCreated (פתיחת המצלמה ותצוגה מקדימה) ושל surfaceDestroyed (שחרור המצלמה) עובר אליה. MainActivity נשארת כמעט ריקה.

4. דיווח שגיאות עם Listener: רכיב חיצוני לא אמור להציג Toast, ולכן מגדירים ממשק OnErrorListener עם onError(IOException), שדה פרטי ופונקציה setOnErrorListener. בתוך ה-catch קוראים ל-onError רק אם ה-Listener אינו null.

5. שילוב ב-Layout: מחליפים את ה-SurfaceView בתגית עם השם המלא של המחלקה (כולל החבילה) ובאותו ID. ב-MainActivity מאתרים את הרכיב, קוראים ל-setOnErrorListener ו-MainActivity מממשת את הממשק ומציגה Toast.

שימו לב

surfaceCreated עלול לרוץ מיד כשהאפליקציה עולה, לפני ש-setOnErrorListener נקרא. אם אז תהיה שגיאה, ה-Listener יהיה null והדיווח לא יגיע. אפשר גם לכתוב ללוג או להציג הודעה בתוך ה-catch.

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

השיעור הבא בקורס: מצלמה - חלק 5 - הוספת כפתורים

פרקי ההרצאה: מצלמה - חלק 4 - צילום מתוך האפליקציה - המשך

תמלול ההרצאה: מצלמה - חלק 4 - צילום מתוך האפליקציה - המשך

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

00:02
אחרי שראינו איך ה-surface view פועל יהיה נכון להוציא את כל הקוד שכתבנו למחלקה נפרדת שתטפל בכל הנושא של ה-surface view. כאילו שאנחנו הולכים לבנות רכיב ויזואלי חדש ולהציב את הרכיב הזה על ה-layout.
00:20
זה יהיה בעצם דיזיין יותר נכון כי אז אנחנו מפרידים את כל הפונקציונליות הזאת של הקאמרה לרכיב חיצוני ומשחררים את ה-main activity לבצע את הקוד שלה שלא קשור ל-surface view שאנחנו בונים.
00:36
אז בואו נצרף מחלקה חדשה ובואו נקרא לה camera surface view ואנחנו רוצים to extend את ה-surface view כי אנחנו בעצם רוצים להגדיר שאנחנו רכיב ה-surface view ואנחנו מתפקדים בדיוק באותו אופן שמקודם תפקדנו רק שהקוד מקודם היה בתוך המיין אקטיביטי.
01:04
אז בואו ניגש למיין אקטיביטי ונתחיל להעתיק את המידע למחלקה שאנחנו בונים. אז אנחנו א', לא צריכים surface view, בואו פשוט נמחק את זה ואנחנו רוצים שיהיה בתוך המחלקה שאנחנו בונים את ה-surface holder ואת הקאמרה.
01:23
אז נעתיק אותם כאן כ-data members, בצורת פרייבט כאלה בואו ניפטר מהקוד הזה אוקיי אנחנו רואים שיש לנו פה איזה שהם שתי פעולות חול אז בואו נעתיק את הפעולות האלה ונדביק אותם בקונסטרקטור שאנחנו צריכים לבנות כאן בואו נבנה כאן public camera surface view קונסטרקטור ופשוט נדביק את שני החבר'ה האלה כאן אבל בגלל שאנחנו בעצמנו Surface View אז אנחנו יכולים
02:02
למחוק את האובייקט הזה ופשוט לקרוא לפונקציה Get Holder שהיא שלנו. עכשיו נקודה מאוד חשובה ומאוד מעניינת. אם אנחנו בונים רכיב ויזואלי שאנחנו רוצים להציב אותו על Layout במקום ה-Surface View שמקודם הצבנו כאן, אם אנחנו עושים דבר כזה אז אנחנו צריכים לבנות קונסטרקטור שמקבל שני משתנים,
02:30
קונטקסט, איזה קונטקסט הלייאוט שייך לו, ואטריביוט סט. זה בעצם אובייקט שמתאר את האטריביוטס השונים שאנחנו רואים כאן.
02:45
אנחנו רואים פה כל מיני אטריביוטס שמועברים לרכיב הוויזואלי. ומה שקורה זה שברגע ששמים רכיב ויזואלי, או אדי טקסט או טקסט ויו או סרפייס ויו או כל רכיב ויזואלי ששמים אותו על גבי ליהאוט אז אנחנו יודעים כמובן שמוגדרים לרכיב הזה כל מיני אטריביוטס הגדרנו וויד הגדרנו הייט הגדרנו איידי הגדרנו
03:12
טקסט מלא אטריביוטס שונים כל האטריביוטס האלה נשלחים לקונסטרקטור של הרכיב שמקבל קונטקסט ואת האטריביוטס ואנחנו צריכים להעביר את זה למחלקת הבסיס שלנו לסופר אז בואו ניגש לסופר נעביר את הקונטקסט את האטריביוט סט ועכשיו גם אנחנו יכולים להיות רכיב ויזואלי ולהציב את עצמנו על גבי הלאוט.
03:38
אוקיי הדבר הבא שאנחנו רואים כאן זה שיש לנו את הדיס הזה שאומר שאנחנו בתור רכיב ממשים את האינטרפייס שמקודם מימשנו במיין אקטיביטי אז בואו נלחץ כאן על אלט אנטר ונגדיר make camera surface view אימפלמנט את הקולבאק הזה, נוריד את הדירקטיב, נגדיר לו אוקיי,
04:03
והנה אנחנו רואים שאנחנו מממשים את ה-surface view, את ה-surface holder, סליחה, נקודה, קולבאק, והנה שלושת הפונקציות שמקודם מימשנו במיין אקטיביטי, אז בואו נחזור למיין אקטיביטי, ואפשר להיפטר עכשיו מההורשה הזאת, מה-implementation הזה, ואפשר להיפטר מכל הקוד הזה,
04:28
כל הקוד הזה פשוט נוציא ונשים את זה כאן בתוך הסרפייס קריאטד ויש לנו פה את הקאמרה ריליס נעתיק נדביק אותו לפה אנחנו יכולים לחזור למיין אקטיביטי ולהיפטר משלושת הרכיבים האלה שלושת הפונקציות האלה למעשה שימו לב שהמיין אקטיביטי כרגע היא מאוד ריקה כי אנחנו הוצאנו פשוט את כל מה שלא קשור ישירות למיין אקטיביטי
04:59
אלא לרכיב ויזואלי הוצאנו את זה למחלקה חיצונית, לא עשינו מעבר לזה שום דבר מיוחד אחר. עכשיו יש לנו פה בעיה עם הטוסט, ובאמת אנחנו לא אמורים להציג טוסטים אם אנחנו ברכיב ויזואלי חיצוני.
05:13
אז בואו נעשה מה שתמיד עשינו כשיש את הבעיה הזאת, וזה היה לדווח אירוע על ידי ליסנר מתאים. אז בואו נבנה פה אינטרפייס ונקרא לו onErrorListener ונגדיר פה איזושהי פונקציה, נקרא לה on-error והפונקציה הזאת היא תקבל איזשהו exception למעשה ה-exception היחידי זה ה-ioexception שאנחנו רואים כאן אז בואו פשוט נגדיר ioexception היא x וכעת אנחנו
05:47
רוצים לבנות את המנגנון של הליסנר בואו כבר נזכר איך עושים את זה מעבר לאינטרפייס אנחנו רוצים לבנות כאן אובייקט פרייבט מסוג on-error listener בואו נקרא לו פשוט listener, בואו נבנה פונקציה public void set on error listener שמקבלת listener כזה ופשוט שמה אותו
06:19
בתוך אובייקט ה-listener הגלובלי ואז אנחנו יכולים כאן לא להציג את ההודעה בתוך רכיב נפרד אלא פשוט לדווח במידה וה-listener שונה מנ"ל זאת אומרת אם מישהו אכן רוצה לקבל את הדיווח הזה אז אנחנו קוראים לליסנר נקודה on-error ופשוט שולחים לו את האקספצ'ן ומי שרוצה שיציג את זה
06:46
מבחוץ אנחנו לא מציגים הודעות שגיאה בתוך. עכשיו שימו לב רק לנקודה אחת שחשוב לציין שיכול להיות שה-surface created תתבצע לפני שנספיק להכניס איזשהו ליסנר לתוך הפונקציה.
07:05
למה? כי אנחנו הולכים לשים את הרכיב שלנו על ה-Layout, אז יכול להיות שאיך שהאפליקציה תתבצע, או ליתר דיוק תרוץ, אוטומטית ייווצר רכיב ה-Camera Surface View על גבי ה-Layout, אוטומטית יתבצע הקונסטרקטור שלו וכל ה-Surface Holder יירשם לאירוע.
07:30
שלושת הפונקציות האלה, Surface Created, Surface Change ו-Surface Destroyed יהיו קיימות. מיידית תתבצע בקיצור כאשר האפליקציה עולה בלי שאף אחד שלח listener לתוך הפונקציה set on error listener כלומר לא הספיקו לעשות את זה ואז בוא נניח שתתבצע איזושהי שגיאה המערכת לא תצליח לעשות preview במכשיר
07:58
או לא תצליח למצוא קאמרה או משהו כזה אוטומטית תתבצע שגיאה אבל ה-listener יהיה נעל אז יש צורך אולי גם לרשום פה איזושהי פקודה לתוך הלוג אז רק