תוֹכֶן

• באילו חיישני אנדרואיד אוכל להשתמש?
• חיישנים סביבתיים: מדידת אור הסביבה
• הצגת נתוני החיישן שלך
• מתקשרים עם חיישן: SensorManager, SensorEvents ומאזינים
• 1. השג מופע של SensorManager
• 2. קבל התייחסות ל- lightTextView
• 3. בדוק אם החיישן קיים במכשיר הנוכחי
• 4. רשמו את מאזיני החיישנים שלכם
• 5. הטמיע את התקשרויות ה- SensorEventListener
• onSensorChanged ()
• onAccuracyChanged ()
• 6. אחזר את ערך החיישן
• 7. התנתק מהמאזינים שלך
• שימוש בחיישני האור של אנדרואיד: קוד שהושלם
• בדוק את אפליקציית חיישני האנדרואיד שלך
• מדידת מרחק, עם חיישני הקרבה של אנדרואיד
• יצירת ממשק המשתמש
• קבלת נתונים מחיישן הקרבה
• בדיקה: כמה קרוב המשתמש למכשיר שלו?
• חיישני תנועה: עיבוד מערכים רב ממדיים
• הצגת נתוני pitch & roll בזמן אמת
• באמצעות חיישן וקטור הסיבוב באפליקציה שלך
• 1. השתמש ב TYPE_ROTATION_VECTOR
• 2. תרגם את נתוני החיישן
• 3. עדכן את מיתרי מציין המיקום
• הצגת נתוני חיישן מרובים: קוד שהושלם
• בוחן את אפליקציית חיישני ה- Android הסופית שלנו
• מסיימים

כיום, מרבית מכשירי האנדרואיד המודרניים מצוידים בחבורת חיישנים.

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

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

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

באילו חיישני אנדרואיד אוכל להשתמש?

ניתן לחלק חיישני אנדרואיד לקטגוריות הבאות:

• חיישנים סביבתיים. אלה מודדים תנאים סביבתיים, כגון טמפרטורת אוויר, לחץ, לחות ורמות אור הסביבה.

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

בנוסף, חיישנים יכולים להיות:

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

חיישנים סביבתיים: מדידת אור הסביבה

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

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

צרו פרויקט Android חדש עם ההגדרות שבחרתם, ונתחיל!

הצגת נתוני החיישן שלך

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

פתח את קובץ Activity_main.xml של הפרויקט שלך והוסף את הדברים הבאים:

בשלב הבא עלינו ליצור את משאב המחרוזות "light_sensor" שמוזכר במערך שלנו. פתח את קובץ ה- string.xml של הפרויקט שלך והוסף את הדברים הבאים:

חיישן אור:% 1 $ .2f

"% 1 $ .2f" הוא מציין מקום המציין את המידע שברצוננו להציג וכיצד יש לעצב אותו:

• %1. אתה יכול להכניס מספר מצייני מיקום לאותו משאב מחרוזות; "% 1" מציין שאנחנו משתמשים במציין מיקום יחיד.
• $.2. זה מציין כיצד היישום שלנו צריך לעצב כל ערך נקודה צפה נכנסת. "$ .2" מציין כי יש לעגל את הערך לשני מקומות עשרוניים.
• פ. פרמט את הערך כמספר בנקודה צפה.

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

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

בעוד שקובץ ה- string.xml שלנו פתוח, בואו ליצור מחרוזת "no_sensor" שנציג אם חיישן האור אינו זמין:

אין חיישן אור זמין

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

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

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

מתקשרים עם חיישן: SensorManager, SensorEvents ומאזינים

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

1. השג מופע של SensorManager

SensorManager מספק את כל השיטות הדרושות לגישה למגוון החיישנים המלא של המכשיר.

כדי להתחיל, צור משתנה שיחזיק מופע של SensorManager:

חיישן פרטי SensorManager lightSensorManager;

לאחר מכן עליך להשיג מופע של SensorManager, על ידי התקשרות לשיטת Context.getSystemService והעברת הארגומנט Context.SENSOR_SERVICE:

lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE);

2. קבל התייחסות ל- lightTextView

בשלב הבא עלינו ליצור משתנה חבר פרטי שיחזיק את האובייקטים שלנו ב- TextView ולהקצות אותו ל- TextView שלנו:

טקסט פרטי תצוגה lightTextView; ... ... ... lightTextView = (TextView) findViewById (R.id.lightTextView);

3. בדוק אם החיישן קיים במכשיר הנוכחי

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

lightSensor = lightSensorManager.getDefaultSensor (חיישן. TYPE_LIGHT);

אם החיישן לא קיים במכשיר זה, שיטת getDefaultSensor () תחזיר את האפשרות null ונציג את מחרוזת "no_sensor":

מחרוזת sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }}

4. רשמו את מאזיני החיישנים שלכם

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

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

כדי להבטיח שהיישום שלנו יקבל הודעה על אובייקטים אלה של SensorEvent, עלינו לרשום מאזין לאירוע החיישן הספציפי הזה, באמצעות RegisterListener של SensorManager ().

שיטת registerListener () נוקטת בטיעונים הבאים:

• אפליקציה או הקשר לפעילות.
• סוג החיישן שברצונך לפקח.
• הקצב שאליו החיישן צריך לשלוח נתונים חדשים. שיעור גבוה יותר יספק לאפליקציה שלך יותר נתונים, אך הוא גם ישתמש במשאבי מערכת רבים יותר, במיוחד חיי סוללה. כדי לסייע בשימור סוללת המכשיר, עליך לבקש את כמות הנתונים המינימלית שהיישום שלך דורש. אני מתכוון להשתמש ב- SensorManager.SENSOR_DELAY_NORMAL, ששולח נתונים חדשים אחת ל -200,000 מיקרו שניות (0.2 שניות).

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

במקום זאת, עליך לרשום את החיישנים שלך בשיטת מחזור החיים של היישום ():

@Orride חלל מוגן onStart () {super.onStart (); // אם החיישן זמין במכשיר הנוכחי ... // if (lightSensor! = Null) {//…. אז התחל להאזין // lightSensorManager.registerListener (זה, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. הטמיע את התקשרויות ה- SensorEventListener

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

השלב הראשון הוא שינוי חתימת הכיתה שלנו ליישום ממשק SensorEventListener:

MainActivity בכיתה ציבורית מרחיב את AppCompatActivity מיישם את SensorEventListener {

לאחר מכן עלינו ליישם את שיטות ההתקשרות הבאות:

onSensorChanged ()

שיטה זו נקראת בתגובה לכל SensorEvent חדש.

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

@ Override חלל ציבורי ב- SensorChanged (SensorEvent sensorEvent) {// To do //}

onAccuracyChanged ()

אם דיוק החיישן משפר או יורד, אנדרואיד תתקשר לשיטת onAccuracyChanged () ותעביר לו אובייקט חיישן המכיל את ערך הדיוק החדש, כגון SENSOR_STATUS_UNRELIABLE או SENSOR_STATUS_ACCURACY_HIGH.

חיישן האור אינו מדווח על שינויים ברמת הדיוק, לכן אני משאיר את ההתקשרות onAccuracyChanged () ריקה:

@ העבר על חלל ציבורי ב-AccuracyChanged (חיישן חיישן, int i) {// To do //}}

6. אחזר את ערך החיישן

בכל פעם שיש לנו ערך חדש, עלינו להתקשר לשיטת onSensorChanged (), ולאחזר את מחרוזת "light_sensor". לאחר מכן נוכל לעקוף את טקסט מציין המיקום של המחרוזת (% 1 $ .2f) ולהציג את המחרוזת המעודכנת כחלק מתצוגת Text:

@Orride חלל ציבורי onSensorChanged (SensorEvent sensorEvent) {// הערך הנוכחי של החיישן // float currentValue = sensorEvent.values; // אחזר את מחרוזת "light_sensor", הכנס את הערך החדש והצג אותו למשתמש // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. התנתק מהמאזינים שלך

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

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

@Orride מוגן חלל OnStop () {super.onStop (); lightSensorManager.unregisterListener (זה); }

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

שימוש בחיישני האור של אנדרואיד: קוד שהושלם

לאחר השלמת כל השלבים שלעיל, MainActivity של הפרויקט אמור להיראות כך:

יבוא android.support.v7.app.AppCompatActivity; יבוא android.os.Bundle; יבוא android.content.Context; יבוא android.hardware.Sensor; יבוא android.hardware.SensorEvent; יבוא android.hardware.SensorEventListener; יבוא android.hardware.SensorManager; יבוא android.widget.TextView; המעמד הציבורי MainActivity מרחיב את AppCompatActivity // הטמיע את ממשק SensorEventListener // מיישם את SensorEventListener {// צור את המשתנים שלך // חיישן פרטי חיישן חיישן; חיישן פרטי SensorManager lightSensorManager; טקסט פרטי תצוגה lightTextView; @Orride חלל מוגן onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // קבל מופע של SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // בדוק אם חיישן אור // lightSensor = lightSensorManager.getDefaultSensor (חיישן.TYPE_LIGHT); // אם חיישן האור אינו קיים, צפה שגיאה // String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }} @ החלף חלל מוגן על OnStart () {super.onStart (); // אם החיישן זמין במכשיר הנוכחי ... // if (lightSensor! = Null) {//…. ואז רשמו מאזין // lightSensorManager.registerListener (זה, lightSensor, // ציין באיזו תדירות תרצה קבל נתונים חדשים // SensorManager.SENSOR_DELAY_NORMAL); }} @ החלף חלל מוגן ב- OnStop () {super.onStop (); // בטל את הרישום של המאזין שלך // lightSensorManager.unregisterListener (זה); } @ הדחה על חלל ציבורי ב- SensorChanged (SensorEvent sensorEvent) {// הערך הנוכחי של החיישן // float currentValue = sensorEvent.values; // אחזר את מחרוזת "light_sensor", הכנס את הערך החדש ועדכן את TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @ Override // אם דיוק החיישן ישתנה ... ./19 חלל ציבורי ב- AccuracyChanged (חיישן חיישן, int i) {// TO // //}}

בדוק את אפליקציית חיישני האנדרואיד שלך

כדי לבדוק יישום זה בסמארטפון או טאבלט אנדרואיד פיזי:

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

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

• התקן את היישום ב- AVD שלך.
• לצד ה- AVD תראה פס כפתורים. מצא את הלחצן "עוד" עם שלוש הנקודות (היכן שהסמן ממוקם בתמונה הבאה) ולחץ עליו. זה משיק את החלון "בקרות מורחבות".

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

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

אתה יכול להוריד את הפרויקט שהושלם מ- GitHub.

מדידת מרחק, עם חיישני הקרבה של אנדרואיד

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

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

יצירת ממשק המשתמש

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

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

חיישן קרבה חיישן קירבה:% 1 $ .2f אין חיישן קרבה זמין

קבלת נתונים מחיישן הקרבה

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

• צור מופע של SensorManager, שהפעם אני מתכוון לכנות "proximitySensorManager."
• השג מופע של "proximitySensorManager."
• צור הפניה ל" proximityTextView. "
• התקשר לשיטת getDefaultSensor () והעבר אותה לחיישן TYPE_PROXIMITY.
• רשום ובטל את הרישום של מאזינים לחיישן הקרבה.

לאחר ביצוע ההתאמות הללו, עליך לסיים את הדברים הבאים:

יבוא android.support.v7.app.AppCompatActivity; יבוא android.os.Bundle; יבוא android.content.Context; יבוא android.hardware.Sensor; יבוא android.hardware.SensorEvent; יבוא android.hardware.SensorManager; יבוא android.hardware.SensorEventListener; יבוא android.widget.TextView; המעמד הציבורי MainActivity מרחיב את AppCompatActivity // הטמיע את ממשק SensorEventListener // מיישם את SensorEventListener {// צור את המשתנים שלך // חיישן פרטי חיישן קרבה Sensor; SensorManager פרטי קרבה SensorManager; TextView פרטיות proximityTextView; @Orride חלל מוגן onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); proximityTextView = (TextView) findViewById (R.id.proximityTextView); // קבל מופע של SensorManager // proximitySensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // בדוק אם יש חיישן קרבה // proximitySensor = proximitySensorManager.getDefaultSensor (חיישן.TYPE_PROXIMITY); // אם חיישן הקרבה לא קיים, צג שגיאה // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximitySensor == null) {proximityTextView.setText (sensor_error); }} @ החלף חלל מוגן על OnStart () {super.onStart (); // אם החיישן זמין במכשיר הנוכחי ... // if (proximitySensor! = Null) {//… ואז רשמו מאזין // proximitySensorManager.registerListener (זה, proximitySensor, // ציין באיזו תדירות תרצה קבל נתונים חדשים // SensorManager.SENSOR_DELAY_NORMAL); }} @ החלף חלל מוגן ב- OnStop () {super.onStop (); // בטל את הרישום של המאזין שלך לשמירת משאבי מערכת // proximitySensorManager.unregisterListener (זה); } @ הדחה על חלל ציבורי ב- SensorChanged (SensorEvent sensorEvent) {// הערך הנוכחי של החיישן // float currentValue = sensorEvent.values; // אחזר את מחרוזת "proximity_sensor", הכנס את הערך החדש ועדכן את TextView // proximityTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @ Override // אם רמת הדיוק של החיישן משתנה ... ./19 חלל ציבורי ב- AccuracyChanged (חיישן חיישן, int i) {//...TO DO //}}

בדיקה: כמה קרוב המשתמש למכשיר שלו?

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

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

כדי לבדוק יישום זה על אמולטור:

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

אתה יכול להוריד את הפרויקט שהושלם מ- GitHub.

חיישני תנועה: עיבוד מערכים רב ממדיים

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

חיישני תנועה יכולים לעזור לך:

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

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

אנו ניצור יישום המשתמש בחיישן וקטור הסיבוב כדי למדוד:

• גובה הצליל. זהו ההטיה מלמטה למטה של ​​המכשיר.
• גלגל. זהו ההטיה משמאל לימין של המכשיר.

הצגת נתוני pitch & roll בזמן אמת

מכיוון שאנו מודדים שני ערכים, עלינו ליצור שני תצוגות טקסט ושני מקורות מחרוזת תואמים:

פתח את הקובץ strings.xml והוסף את הדברים הבאים:

חיישני תנועה חיישן המגרש:% 1 $ .2f חיישן גלילה:% 1 $ .2f אין חיישן תנועה זמין

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

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

1. השתמש ב TYPE_ROTATION_VECTOR

מכיוון שאנו עובדים עם חיישן וקטור הסיבוב, עלינו להתקשר לשיטת getDefaultSensor () ואז להעביר לו את הקבוע TYPE_ROTATION_VECTOR:

positionSensorManager.getDefaultSensor (חיישן.TYPE_ROTATION_VECTOR);

2. תרגם את נתוני החיישן

שלא כמו חיישני האור והקרבה הקודמים, חיישני תנועה מחזירים מערכים רב-ממדיים של ערכי חיישן עבור כל SensorEvent. ערכים אלה מעוצבים באמצעות מערכת הקואורדינטות "X, Y, Z" הסטנדרטית, המחושבת ביחס למכשיר כאשר הוא מוחזק ככיוון "הטבעי" המוגדר כברירת מחדל.

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

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

ראשית, מערכת קואורדינטות המכשירים היא מערכת קואורדינטות 3, צירים X, Y, Z רגילה, כאשר כל נקודה בכל אחד משלושת הצירים מיוצגת על ידי וקטור תלת ממדי. המשמעות היא שעלינו ליצור מערך של 9 ערכי ציפה:

float rotationMatrix = צף חדש;

לאחר מכן נוכל להעביר מערך זה לשיטת getRotationMatrix ():

SensorManager.getRotationMatrixFromVector (rotationMatrix, וקטורים); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z;

השלב הבא הוא שימוש בשיטת SensorManager.remapCoordinateSystem () כדי ליצור מחדש את נתוני החיישן, בהתבסס על הכיוון הנוכחי של המכשיר.

שיטת SensorManager.remapCoordinateSystem () נוקטת בטיעונים הבאים:

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

הנה הקוד בו אשתמש באפליקציה שלי:

float adjustRotationMatrix = ציפה חדשה; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, מתאם RotationMatrix);

לבסוף, נתקשר ל- SensorManager.getOrientation ונאמר לו להשתמש במותאם המתאיםRotationMatrix:

SensorManager.getOrientation (מתאם RotationMatrix, כיוון);

3. עדכן את מיתרי מציין המיקום

מכיוון שיש לנו שתי קבוצות נתונים (pitch and roll), עלינו לאחזר שני מחרוזות מצייני מיקום נפרדות, לאכלס אותם בערכים הנכונים ולאחר מכן לעדכן את תצוגת ה- Text המתאימה:

pitchTextView.setText (getResources (). getString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll));

הצגת נתוני חיישן מרובים: קוד שהושלם

לאחר ביצוע השלבים שלעיל, MainActivity שלך אמור להיראות כך:

יבוא android.app.Activity; יבוא android.os.Bundle; יבוא android.hardware.Sensor; יבוא android.hardware.SensorEvent; יבוא android.hardware.SensorEventListener; יבוא android.hardware.SensorManager; יבוא android.widget.TextView; המעמד הציבורי MainActivity מרחיב מיישם את הפעילות SensorEventListener {פרטי SensorManager motionSensorManager; חיישן תנועה פרטי חיישן; TextView פרטי pitchTextView; TextView פרטי RollTextView; גמר סטטי פרטי int SENSOR_DELAY = 500 * 1000; גמר סטטי פרטי int FROM_RADS_TO_DEGS = -57; @Orride חלל מוגן onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); נסה {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (חיישן. TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (זה, motionSensor, SENSOR_DELAY); } לתפוס (חריג ה) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @ העבר חלל ציבורי עלAccuracyChanged (חיישן חיישן, דיוק int) {// To do //} @ חלף את הריק הציבורי ב- SensorChanged (אירוע SensorEvent) {if (event.sensor == motionSensor) {עדכון (event.values); }} עדכון חלל פרטי (וקטורי ציפה) {// חישוב מטריצת הסיבוב // float rotationMatrix = חדש לצוף; SensorManager.getRotationMatrixFromVector (rotationMatrix, וקטורים); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // הסר מחדש את המטריצה ​​על סמך הכיוון הנוכחי של הפעילות // float adjustRotationMatrix = float new; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, מתאם RotationMatrix); // חישוב כיוון ההתקנים // כיוון הציפה = צף חדש; // לספק את מערך הערכים לצוף לשיטת getOrientation () // SensorManager.getOrientation (מתאםRotationMatrix, התמצאות); המגרש לצוף = כיוון * FROM_RADS_TO_DEGS; רול צף = כיוון * FROM_RADS_TO_DEGS; // עדכן את תצוגות הטקסט עם ערכי המגרש והגליל // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

אתה יכול להוריד את הפרויקט שהושלם מ- GitHub.

בוחן את אפליקציית חיישני ה- Android הסופית שלנו

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

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

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

• התקן את היישום ב- AVD שלך.
• בחר "עוד", אשר משיק את חלון "בקרות מורחבות".
• בתפריט השמאלי, בחר "חיישנים וירטואליים."
• ודא שבחרת בכרטיסייה "תאוצה". כרטיסייה זו כוללת פקדים שיכולים לדמות שינויים במיקום ההתמצאות והמכשיר.
• נסה להתנסות עם המחוונים השונים (סיבוב: Z-Rot, X-Rot, Y-Rot; ו- Move: X, Y ו- Z) וכפתורי ה- "Rotation Device" השונים, כדי לראות כיצד הם משפיעים על חיישן הגלילה של היישום שלך. "ו-" חיישן המגרש ".

מסיימים

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

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