שימוש בספריית האפליקציות של Android למכוניות

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

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

Codelab

מידע בסיסי על ספריית האפליקציות לרכב

arrow_forward

לפני שמתחילים

1. למידע נוסף על עיצוב לנהיגה דפים שמכילים את ספריית האפליקציות של הרכב
   • אפליקציות ניווט ואפליקציות אחרות שקשורות לנהיגה סקירות כלליות של קטגוריות
   • סקירה כללית בנושא בניית אפליקציות באמצעות תבניות
   • אבני בניין שכוללות תבניות ורכיבי תבנית
   • תהליכים לדוגמה הדגמה של דפוסים נפוצים של חוויית משתמש
   • דרישות לגבי אפליקציות בתבניות
2. כדאי לקרוא את המונחים והמושגים המרכזיים .
3. מומלץ לקרוא על מערכת Android Auto UI ו-Android Automotive OS עיצוב.
4. בודקים את נתוני הגרסה.
5. כדאי לעיין בטעימות.

מונחי מפתח ומושגים מרכזיים

מודלים ותבניות

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

מארח

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

הגבלות על תבניות

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

Screen

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

CarAppService

CarAppService הוא שיעור מופשט Service שהאפליקציה שלכם צריך להטמיע ולייצא כדי שהמארח יוכל לגלות ולנהל אותו. CarAppService של האפליקציה הוא והם אחראים לוודא שהחיבור למארח יכול להיות מהימן באמצעות createHostValidator ולאחר מכן לספק Session לכל חיבור באמצעות onCreateSession.

Session

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

כשSession מופעל, כמו כשהאפליקציה מופעלת בפעם הראשונה, המארח מבקש לבצע Screen להצגה באמצעות onCreateScreen .

התקנה של ספריית האפליקציות של הרכב

לעיון בספרייה של Jetpack דף גרסה של להוראות להוספת הספרייה לאפליקציה.

הגדרת קובצי המניפסט של האפליקציה

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

להצהיר על שירות CarAppService

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

צריך גם להצהיר על הקטגוריה של האפליקציה בקטע אלמנט <category> של האפליקציה מסנן Intent. לצפייה ברשימה של קטגוריות נתמכות של אפליקציות לערכים המותרים של מהרכיב הזה.

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

<application>
    ...
   <service
       ...
        android:name=".MyCarAppService"
        android:exported="true">
      <intent-filter>
        <action android:name="androidx.car.app.CarAppService"/>
        <category android:name="androidx.car.app.category.POI"/>
      </intent-filter>
    </service>

    ...
<application>

קטגוריות נתמכות של אפליקציות

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

• androidx.car.app.category.NAVIGATION: אפליקציה שמספקת מסלול מפורט מסלול ניווט. יצירת אפליקציות ניווט לרכבים לקבלת מסמכים נוספים בנושא.
• androidx.car.app.category.POI: אפליקציה שמספקת פונקציונליות רלוונטית כדי למצוא נקודות עניין כמו מקומות חניה, תחנות טעינה תחנות דלק. ביצוע צ'ק-אאוט יצירת אפליקציות של נקודות עניין למכוניות בשביל מסמכים נוספים בקטגוריה הזו.
• androidx.car.app.category.IOT: אפליקציה שמאפשרת למשתמשים לבצע פעולות רלוונטיות פעולות במכשירים מחוברים מתוך הרכב. ביצוע צ'ק-אאוט יצירת אינטרנט של אפליקציות למכוניות בשביל מסמכים נוספים בקטגוריה הזו.

אפשר לעיין במאמר איכות האפליקציות ל-Android למכוניות עבור תיאורים מפורטים של כל קטגוריה וקריטריונים לאפליקציות שמשויכות אליהן.

ציון השם והסמל של האפליקציה

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

אפשר לציין את השם והסמל של האפליקציה שמשמשים לייצוג האפליקציה באמצעות label icon מאפיינים של CarAppService:

...
<service
   android:name=".MyCarAppService"
   android:exported="true"
   android:label="@string/my_app_name"
   android:icon="@drawable/my_app_icon">
   ...
</service>
...

אם התווית או הסמל לא מוצהרים רכיב <service>, המארח חוזר לערכים שצוינו רכיב <application>.

הגדרת עיצוב בהתאמה אישית

כדי להגדיר עיצוב מותאם אישית לאפליקציה לרכב, צריך להוסיף רכיב <meta-data> קובץ מניפסט, באופן הבא:

<meta-data
    android:name="androidx.car.app.theme"
    android:resource="@style/MyCarAppTheme />

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

<resources>
  <style name="MyCarAppTheme">
    <item name="carColorPrimary">@layout/my_primary_car_color</item>
    <item name="carColorPrimaryDark">@layout/my_primary_dark_car_color</item>
    <item name="carColorSecondary">@layout/my_secondary_car_color</item>
    <item name="carColorSecondaryDark">@layout/my_secondary_dark_car_color</item>
    <item name="carPermissionActivityLayout">@layout/my_custom_background</item>
  </style>
</resources>

רמת ה-API של האפליקציה לרכב

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

להצהיר על רמת ה-API המינימלית של אפליקציית Car באפליקציה שלך קובץ AndroidManifest.xml:

<manifest ...>
    <application ...>
        <meta-data
            android:name="androidx.car.app.minCarApiLevel"
            android:value="1"/>
    </application>
</manifest>

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

יצירת CarAppService וסשן

האפליקציה שלך צריכה להרחיב את מחלקה CarAppService והטמעה שלו onCreateSession , שתחזיר Session במופע שתואם לחיבור הנוכחי למארח:

class HelloWorldService : CarAppService() {
    ...
    override fun onCreateSession(): Session {
        return HelloWorldSession()
    }
    ...
}

public final class HelloWorldService extends CarAppService {
    ...
    @Override
    @NonNull
    public Session onCreateSession() {
        return new HelloWorldSession();
    }
    ...
}

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

class HelloWorldSession : Session() {
    ...
    override fun onCreateScreen(intent: Intent): Screen {
        return HelloWorldScreen(carContext)
    }
    ...
}

public final class HelloWorldSession extends Session {
    ...
    @Override
    @NonNull
    public Screen onCreateScreen(@NonNull Intent intent) {
        return new HelloWorldScreen(getCarContext());
    }
    ...
}

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

יצירת מסך פתיחה

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

בקטע הקוד הבא מוסבר איך להצהיר (declare) על Screen שמשתמש ב תבנית של PaneTemplate ל תציג הודעת "שלום עולם!" פשוטה string:

class HelloWorldScreen(carContext: CarContext) : Screen(carContext) {
    override fun onGetTemplate(): Template {
        val row = Row.Builder().setTitle("Hello world!").build()
        val pane = Pane.Builder().addRow(row).build()
        return PaneTemplate.Builder(pane)
            .setHeaderAction(Action.APP_ICON)
            .build()
    }
}

public class HelloWorldScreen extends Screen {
    @NonNull
    @Override
    public Template onGetTemplate() {
        Row row = new Row.Builder().setTitle("Hello world!").build();
        Pane pane = new Pane.Builder().addRow(row).build();
        return new PaneTemplate.Builder(pane)
            .setHeaderAction(Action.APP_ICON)
            .build();
    }
}

המחלקה CarContext

הכיתה CarContext היא תת-מחלקה ContextWrapper נגיש אל Session וגם Screen מופעים. הוא מספק גישה לשירותי רכב, כמו ScreenManager לניהול מקבץ מסך; ה AppManager להגדרות כלליות שקשורות לאפליקציות פונקציונליות, כמו גישה לאובייקט Surface שרטוט מפות; וגם NavigationManager שמשמשות אפליקציות ניווט מפורטות כדי לתקשר ניווט מטא-נתונים ועוד קשור לניווט אירועים עם המארח.

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

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

הטמעת ניווט במסך

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

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

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

val template = MessageTemplate.Builder("Hello world!")
    .setHeaderAction(Action.BACK)
    .addAction(
        Action.Builder()
            .setTitle("Next screen")
            .setOnClickListener { screenManager.push(NextScreen(carContext)) }
            .build())
    .build()

MessageTemplate template = new MessageTemplate.Builder("Hello world!")
    .setHeaderAction(Action.BACK)
    .addAction(
        new Action.Builder()
            .setTitle("Next screen")
            .setOnClickListener(
                () -> getScreenManager().push(new NextScreen(getCarContext())))
            .build())
    .build();

האובייקט Action.BACK הוא Action רגיל שבאופן אוטומטי להפעלה של ScreenManager.pop. אפשר לשנות את ההתנהגות הזו באמצעות OnBackPressedDispatcher שבמכונה CarContext

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

רענון התוכן של תבנית

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

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

אנחנו ממליצים לבנות את המסכים כך שיהיו בין Screen לבין הסוג שהיא מחזירה באמצעות ההטמעה של onGetTemplate.

שרטוט מפות

אפליקציות ניווט ונקודות עניין (POI) שמשתמשות בתבניות הבאות יכולות שרטט מפות באמצעות גישה אל Surface:

הצהרה על ההרשאה לפלטפורמה

בנוסף להרשאה הנדרשת לתבנית שבה משתמשים באפליקציה, האפליקציה שלך חייבת להצהיר על ההרשאה androidx.car.app.ACCESS_SURFACE AndroidManifest.xml כדי לקבל גישה למשטח:

<manifest ...>
  ...
  <uses-permission android:name="androidx.car.app.ACCESS_SURFACE" />
  ...
</manifest>

גישה לפלטפורמה

כדי לגשת אל Surface שהמארח מספק, צריך להטמיע SurfaceCallback ומספקים שמיישמים בAppManager מרכז שירות לרכב. הסכום הנוכחי של Surface מועבר אל SurfaceCallback בפרמטר SurfaceContainer של onSurfaceAvailable() ו-onSurfaceDestroyed() התקשרות חזרה.

carContext.getCarService(AppManager::class.java).setSurfaceCallback(surfaceCallback)

carContext.getCarService(AppManager.class).setSurfaceCallback(surfaceCallback);

הבנת השטח הגלוי של פני השטח

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

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

תמיכה בעיצוב כהה

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

כדי להחליט אם לשרטט מפה כהה, אפשר להשתמש CarContext.isDarkMode . בכל פעם שהסטטוס של העיצוב הכהה ישתנה, תקבלו הודעה למספר Session.onCarConfigurationChanged

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

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

הטמעת קריאה חוזרת (callbacks) של אינטראקטיביות

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

הוספה של שורת פעולות במפה

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

כדי לקבל קריאות חוזרות (callback) של אינטראקטיביות במפה, חובה להוסיף לחצן Action.PAN בשורת הפעולות במפה. כשהמשתמש לוחץ על לחצן התנועה, המארח עובר למצב 'הזזה', כפי שמתואר .

אם האפליקציה לא תכיל את Action.PAN בשורת הפעולות במפה, הוא לא מקבל קלט של משתמשים SurfaceCallback methods, והמארח יוצא מכל מכשיר קודם לכן הזזה.

במסך מגע, לחצן ההזזה לא מוצג.

הסבר על מצב הזזה

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

אינטראקציה עם המשתמש

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

טיפול בקלט של משתמשים

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

val action = Action.Builder()
    .setTitle("Navigate")
    .setOnClickListener(::onClickNavigate)
    .build()

Action action = new Action.Builder()
    .setTitle("Navigate")
    .setOnClickListener(this::onClickNavigate)
    .build();

השיטה onClickNavigate יכולה להפעיל את אפליקציית ברירת המחדל למכונית באמצעות CarContext.startCarApp method:

private fun onClickNavigate() {
    val intent = Intent(CarContext.ACTION_NAVIGATE, Uri.parse("geo:0,0?q=" + address))
    carContext.startCarApp(intent)
}

private void onClickNavigate() {
    Intent intent = new Intent(CarContext.ACTION_NAVIGATE, Uri.parse("geo:0,0?q=" + address));
    getCarContext().startCarApp(intent);
}

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

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

val row = Row.Builder()
    .setTitle("Open Settings")
    .setOnClickListener(ParkedOnlyOnClickListener.create(::openSettingsOnPhone))
    .build()

Row row = new Row.Builder()
    .setTitle("Open Settings")
    .setOnClickListener(ParkedOnlyOnClickListener.create(this::openSettingsOnPhone))
    .build();

הצגת התראות

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

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

val notification = NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
    .setContentTitle(titleOnThePhone)
    .extend(
        CarAppExtender.Builder()
            .setContentTitle(titleOnTheCar)
            ...
            .build())
    .build()

Notification notification = new NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
    .setContentTitle(titleOnThePhone)
    .extend(
        new CarAppExtender.Builder()
            .setContentTitle(titleOnTheCar)
            ...
            .build())
    .build();

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

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

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

אם המיקום NotificationCompat.Builder.setOnlyAlertOnce מופעלת עם ערך של true, התראה בעדיפות גבוהה מוצגת HUN רק פעם אחת.

אפשר למצוא מידע נוסף על עיצוב ההתראות באפליקציית הרכב בקטע המדריך של Google Design לנהיגה על התראות.

הצגת הודעות קופצות

האפליקציה שלך יכולה להציג הודעה קופצת באמצעות CarToast כפי שמוצג בקטע הקוד הזה:

CarToast.makeText(carContext, "Hello!", CarToast.LENGTH_SHORT).show()

CarToast.makeText(getCarContext(), "Hello!", CarToast.LENGTH_SHORT).show();

בקשת הרשאות

אם לאפליקציה שלך נדרשת גישה לפעולות או לנתונים מוגבלים – לדוגמה, מיקום - הכללים הרגילים של Android הרשאות חלות. כדי לבקש הרשאה, אפשר להשתמש CarContext.requestPermissions() .

היתרון של שימוש CarContext.requestPermissions(), בניגוד לשימוש ממשקי API רגילים של Android, הם שאתה לא צריך להפעיל Activity משלך כדי יוצרים את תיבת הדו-שיח של ההרשאות. בנוסף, תוכלו להשתמש באותו קוד בשני המכשירים את Android Auto ו-Android Automotive OS, במקום ליצור ותהליכי עבודה תלויי פלטפורמה.

עיצוב תיבת הדו-שיח להרשאות ב-Android Auto

ב-Android Auto, תיבת הדו-שיח להרשאות של המשתמש תופיע בטלפון. כברירת מחדל, לא יופיע רקע מאחורי תיבת הדו-שיח. כדי להגדיר התאמה אישית רקע, צריך להצהיר על עיצוב של אפליקציה לרכב קובץ AndroidManifest.xml והגדרת המאפיין carPermissionActivityLayout לעיצוב של האפליקציה לרכב.

<meta-data
    android:name="androidx.car.app.theme"
    android:resource="@style/MyCarAppTheme />

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

<resources>
  <style name="MyCarAppTheme">
    <item name="carPermissionActivityLayout">@layout/my_custom_background</item>
  </style>
</resources>

איך מפעילים אפליקציה לרכב עם כוונה

אפשר לקרוא ל- CarContext.startCarApp כדי לבצע אחת מהפעולות הבאות:

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

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

val notification = notificationBuilder
    ...
    .extend(
        CarAppExtender.Builder()
            .setContentIntent(
                PendingIntent.getBroadcast(
                    context,
                    ACTION_VIEW_PARKING_RESERVATION.hashCode(),
                    Intent(ACTION_VIEW_PARKING_RESERVATION)
                        .setComponent(ComponentName(context, MyNotificationReceiver::class.java)),
                    0))
            .build())

Notification notification = notificationBuilder
    ...
    .extend(
        new CarAppExtender.Builder()
            .setContentIntent(
                PendingIntent.getBroadcast(
                    context,
                    ACTION_VIEW_PARKING_RESERVATION.hashCode(),
                    new Intent(ACTION_VIEW_PARKING_RESERVATION)
                        .setComponent(new ComponentName(context, MyNotificationReceiver.class)),
                    0))
            .build());

האפליקציה שלך צריכה גם להצהיר על BroadcastReceiver כלומר מופעלת לעיבוד הכוונה כשהמשתמש בוחר בפעולה ממשק התראות והפעלה CarContext.startCarApp עם Intent, כולל ה-URI של הנתונים:

class MyNotificationReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val intentAction = intent.action
        if (ACTION_VIEW_PARKING_RESERVATION == intentAction) {
            CarContext.startCarApp(
                intent,
                Intent(Intent.ACTION_VIEW)
                    .setComponent(ComponentName(context, MyCarAppService::class.java))
                    .setData(Uri.fromParts(MY_URI_SCHEME, MY_URI_HOST, intentAction)))
        }
    }
}

public class MyNotificationReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        String intentAction = intent.getAction();
        if (ACTION_VIEW_PARKING_RESERVATION.equals(intentAction)) {
            CarContext.startCarApp(
                intent,
                new Intent(Intent.ACTION_VIEW)
                    .setComponent(new ComponentName(context, MyCarAppService.class))
                    .setData(Uri.fromParts(MY_URI_SCHEME, MY_URI_HOST, intentAction)));
        }
    }
}

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

override fun onNewIntent(intent: Intent) {
    val screenManager = carContext.getCarService(ScreenManager::class.java)
    val uri = intent.data
    if (uri != null
        && MY_URI_SCHEME == uri.scheme
        && MY_URI_HOST == uri.schemeSpecificPart
        && ACTION_VIEW_PARKING_RESERVATION == uri.fragment
    ) {
        val top = screenManager.top
        if (top !is ParkingReservationScreen) {
            screenManager.push(ParkingReservationScreen(carContext))
        }
    }
}

@Override
public void onNewIntent(@NonNull Intent intent) {
    ScreenManager screenManager = getCarContext().getCarService(ScreenManager.class);
    Uri uri = intent.getData();
    if (uri != null
        && MY_URI_SCHEME.equals(uri.getScheme())
        && MY_URI_HOST.equals(uri.getSchemeSpecificPart())
        && ACTION_VIEW_PARKING_RESERVATION.equals(uri.getFragment())
    ) {
        Screen top = screenManager.getTop();
        if (!(top instanceof ParkingReservationScreen)) {
            screenManager.push(new ParkingReservationScreen(getCarContext()));
        }
    }
}

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

הגבלות על תבניות

המארח מגביל את מספר התבניות שאפשר להציג במשימה נתונה לכל היותר מבין חמישה, מתוכם התבנית האחרונה חייבת להיות אחת מהסוגים הבאים:

• NavigationTemplate
• PaneTemplate
• MessageTemplate

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

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

מתבצע רענון של התבנית

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

פעולות אחורה

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

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

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

איפוס פעולות

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

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

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

ממשק API לחיבור

אפשר לבדוק אם האפליקציה פועלת ב-Android Auto או ב-Android Automotive OS באמצעות CarConnection API אל לאחזר פרטי חיבור בזמן הריצה.

לדוגמה, ב-Session של האפליקציה לרכב, מאתחלים CarConnection וגם הרשמה לעדכונים של LiveData:

CarConnection(carContext).type.observe(this, ::onConnectionStateUpdated)

new CarConnection(getCarContext()).getType().observe(this, this::onConnectionStateUpdated);

במצב הצפייה, אתם יכולים להגיב לשינויים במצב החיבור:

fun onConnectionStateUpdated(connectionState: Int) {
  val message = when(connectionState) {
    CarConnection.CONNECTION_TYPE_NOT_CONNECTED -> "Not connected to a head unit"
    CarConnection.CONNECTION_TYPE_NATIVE -> "Connected to Android Automotive OS"
    CarConnection.CONNECTION_TYPE_PROJECTION -> "Connected to Android Auto"
    else -> "Unknown car connection type"
  }
  CarToast.makeText(carContext, message, CarToast.LENGTH_SHORT).show()
}

private void onConnectionStateUpdated(int connectionState) {
  String message;
  switch(connectionState) {
    case CarConnection.CONNECTION_TYPE_NOT_CONNECTED:
      message = "Not connected to a head unit";
      break;
    case CarConnection.CONNECTION_TYPE_NATIVE:
      message = "Connected to Android Automotive OS";
      break;
    case CarConnection.CONNECTION_TYPE_PROJECTION:
      message = "Connected to Android Auto";
      break;
    default:
      message = "Unknown car connection type";
      break;
  }
  CarToast.makeText(getCarContext(), message, CarToast.LENGTH_SHORT).show();
}

ממשק API של מגבלות

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

כדי להתחיל, צריך לקבל ConstraintManager מ-CarContext:

val manager = carContext.getCarService(ConstraintManager::class.java)

ConstraintManager manager = getCarContext().getCarService(ConstraintManager.class);

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

val gridItemLimit = manager.getContentLimit(ConstraintManager.CONTENT_LIMIT_TYPE_GRID)

int gridItemLimit = manager.getContentLimit(ConstraintManager.CONTENT_LIMIT_TYPE_GRID);

הוספת תהליך כניסה

אם באפליקציה יש חוויית משתמש מחוברת לחשבון, תוכלו להשתמש בתבניות כמו SignInTemplate ו-LongMessageTemplate עם Car App API ברמה 2 ואילך כדי לטפל בכניסה לאפליקציה ליחידה הראשית של הרכב.

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

• InputSignInMethod לכניסה עם שם משתמש/סיסמה.
• PinSignInMethod לכניסה באמצעות קוד אימות, שבה המשתמש מקשר את החשבון מהטלפון באמצעות קוד אימות שמוצג על היחידה הראשית.
• ProviderSignInMethod לכניסה לספק, כמו כניסה באמצעות חשבון Google והקשה אחת.
• QRCodeSignInMethod לכניסה באמצעות קוד QR, שבה המשתמש סורק קוד QR כדי להשלים את הכניסה בטלפון שלהם. האפשרות הזו זמינה ב-Car API ברמה 4 ואילך.

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

val callback = object : InputCallback {
    override fun onInputSubmitted(text: String) {
        // You will receive this callback when the user presses Enter on the keyboard.
    }

    override fun onInputTextChanged(text: String) {
        // You will receive this callback as the user is typing. The update
        // frequency is determined by the host.
    }
}

InputCallback callback = new InputCallback() {
    @Override
    public void onInputSubmitted(@NonNull String text) {
        // You will receive this callback when the user presses Enter on the keyboard.
    }

    @Override
    public void onInputTextChanged(@NonNull String text) {
        // You will receive this callback as the user is typing. The update
        // frequency is determined by the host.
    }
};

נדרש InputCallback לInputSignInMethod Builder.

val passwordInput = InputSignInMethod.Builder(callback)
    .setHint("Password")
    .setInputType(InputSignInMethod.INPUT_TYPE_PASSWORD)
    ...
    .build()

InputSignInMethod passwordInput = new InputSignInMethod.Builder(callback)
    .setHint("Password")
    .setInputType(InputSignInMethod.INPUT_TYPE_PASSWORD)
    ...
    .build();

לבסוף, משתמשים ב-InputSignInMethod החדש כדי ליצור SignInTemplate.

SignInTemplate.Builder(passwordInput)
    .setTitle("Sign in with username and password")
    .setInstructions("Enter your password")
    .setHeaderAction(Action.BACK)
    ...
    .build()

new SignInTemplate.Builder(passwordInput)
    .setTitle("Sign in with username and password")
    .setInstructions("Enter your password")
    .setHeaderAction(Action.BACK)
    ...
    .build();

שימוש במנהל החשבון

באפליקציות ל-Android Automotive OS שיש להן אימות חובה להשתמש AccountManager מהסיבות הבאות:

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

הוספת וריאנטים של מחרוזת טקסט

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

אפשר להוסיף וריאנטים של מחרוזת טקסט ל-CarText עם CarText.Builder.addVariant() method:

val itemTitle = CarText.Builder("This is a very long string")
    .addVariant("Shorter string")
    ...
    .build()

CarText itemTitle = new CarText.Builder("This is a very long string")
    .addVariant("Shorter string")
    ...
    .build();

לאחר מכן אפשר להשתמש בCarText הזה - לדוגמה, כטקסט הראשי של GridItem.

GridItem.Builder()
    .addTitle(itemTitle)
    ...
    .build()

new GridItem.Builder()
    .addTitle(itemTitle)
    ...
    build();

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

הוספת CarIcons מוטבעים בשורות

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

  
val rating = SpannableString("Rating: 4.5 stars")
rating.setSpan(
    CarIconSpan.create(
        // Create a CarIcon with an image of four and a half stars
        CarIcon.Builder(...).build(),
        // Align the CarIcon to the baseline of the text
        CarIconSpan.ALIGN_BASELINE
    ),
    // The start index of the span (index of the character '4')
    8,
    // The end index of the span (index of the last 's' in "stars")
    16,
    Spanned.SPAN_INCLUSIVE_INCLUSIVE
)

val row = Row.Builder()
    ...
    .addText(rating)
    .build()
  
  

  
SpannableString rating = new SpannableString("Rating: 4.5 stars");
rating.setSpan(
        CarIconSpan.create(
                // Create a CarIcon with an image of four and a half stars
                new CarIcon.Builder(...).build(),
                // Align the CarIcon to the baseline of the text
                CarIconSpan.ALIGN_BASELINE
        ),
        // The start index of the span (index of the character '4')
        8,
        // The end index of the span (index of the last 's' in "stars")
        16,
        Spanned.SPAN_INCLUSIVE_INCLUSIVE
);
Row row = new Row.Builder()
        ...
        .addText(rating)
        .build();
  
  

ממשקי API לחומרה של רכב

החל מרמת 3 של ה-API לאפליקציה של Car, ספריית האפליקציות למכונית כוללת ממשקי API יכול להשתמש בו כדי לגשת לחיישנים ולמאפייני הרכב.

הדרישות

כדי להשתמש בממשקי ה-API עם Android Auto, צריך קודם להוסיף תלות androidx.car.app:app-projected לקובץ build.gradle ב-Android מודול אוטומטי. ב-Android Automotive OS, צריך להוסיף תלות ב- androidx.car.app:app-automotive לקובץ build.gradle ב-Android מודול Automotive OS.

בנוסף, בקובץ AndroidManifest.xml צריך: להצהיר על ההרשאות הרלוונטיות שנדרשות כדי מבקשים את נתוני הרכב שרוצים להשתמש בהם. שימו לב שההרשאות האלה צריכות להיות גם הוענקה לך על ידי המשתמש. אפשר להשתמש אותו קוד גם ב-Android Auto וגם ב-Android Automotive OS, מאשר ליצור תהליכים תלויי-פלטפורמה. עם זאת, ההרשאות הנדרשות הם שונים.

מידע על רכב

בטבלה זו מפורטים המאפיינים שמוצגים CarInfo ממשקי API ההרשאות שנדרשות כדי להשתמש בהן:

לדוגמה, כדי לקבל את הטווח שנותר, צריך ליצור אובייקט CarInfo, ואז יוצרים ורושמים OnCarDataAvailableListener:

val carInfo = carContext.getCarService(CarHardwareManager::class.java).carInfo

val listener = OnCarDataAvailableListener<EnergyLevel> { data ->
    if (data.rangeRemainingMeters.status == CarValue.STATUS_SUCCESS) {
      val rangeRemaining = data.rangeRemainingMeters.value
    } else {
      // Handle error
    }
  }

carInfo.addEnergyLevelListener(carContext.mainExecutor, listener)
…
// Unregister the listener when you no longer need updates
carInfo.removeEnergyLevelListener(listener)

CarInfo carInfo = getCarContext().getCarService(CarHardwareManager.class).getCarInfo();

OnCarDataAvailableListener<EnergyLevel> listener = (data) -> {
  if(data.getRangeRemainingMeters().getStatus() == CarValue.STATUS_SUCCESS) {
    float rangeRemaining = data.getRangeRemainingMeters().getValue();
  } else {
    // Handle error
  }
};

carInfo.addEnergyLevelListener(getCarContext().getMainExecutor(), listener);
…
// Unregister the listener when you no longer need updates
carInfo.removeEnergyLevelListener(listener);

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

חיישנים לרכב

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

val carSensors = carContext.getCarService(CarHardwareManager::class.java).carSensors

val listener = OnCarDataAvailableListener<Compass> { data ->
    if (data.orientations.status == CarValue.STATUS_SUCCESS) {
      val orientation = data.orientations.value
    } else {
      // Data not available, handle error
    }
  }

carSensors.addCompassListener(CarSensors.UPDATE_RATE_NORMAL, carContext.mainExecutor, listener)
…
// Unregister the listener when you no longer need updates
carSensors.removeCompassListener(listener)

CarSensors carSensors = getCarContext().getCarService(CarHardwareManager.class).getCarSensors();

OnCarDataAvailableListener<Compass> listener = (data) -> {
  if (data.getOrientations().getStatus() == CarValue.STATUS_SUCCESS) {
    List<Float> orientations = data.getOrientations().getValue();
  } else {
    // Data not available, handle error
  }
};

carSensors.addCompassListener(CarSensors.UPDATE_RATE_NORMAL, getCarContext().getMainExecutor(),
    listener);
…
// Unregister the listener when you no longer need updates
carSensors.removeCompassListener(listener);

כדי לקבל גישה לנתוני המיקום מהרכב, צריך גם להצהיר ולבקש את ההרשאה android.permission.ACCESS_FINE_LOCATION.

בדיקה

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

מחזור החיים של CarAppService, הסשן והמסך

Session וגם Screen מחלקות מטמיעות את ממשק LifecycleOwner. בתור המשתמש מקיים אינטראקציה עם האפליקציה, עם האובייקטים Session ו-Screen מחזור חיים מופעלות קריאות חוזרות (callback), כפי שמתואר בתרשימים הבאים.

מחזורי החיים של CarAppService ושל סשן

לקבלת פרטים מלאים, אפשר לעיין במסמכי התיעוד של Session.getLifecycle .

מחזור החיים של מסך

לקבלת פרטים מלאים, אפשר לעיין במסמכי התיעוד של Screen.getLifecycle.

הקלטה מהמיקרופון של הרכב

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

הרשאה להקליט

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

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

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

הקלטת אודיו

אחרי שהמשתמש יאשר את ההקלטה, אפשר יהיה להקליט את האודיו והעיבוד ההקלטה.

val carAudioRecord = CarAudioRecord.create(carContext)
        carAudioRecord.startRecording()

        val data = ByteArray(CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE)
        while(carAudioRecord.read(data, 0, CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE) >= 0) {
            // Use data array
            // Potentially call carAudioRecord.stopRecording() if your processing finds end of speech
        }
        carAudioRecord.stopRecording()
 

CarAudioRecord carAudioRecord = CarAudioRecord.create(getCarContext());
        carAudioRecord.startRecording();

        byte[] data = new byte[CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE];
        while (carAudioRecord.read(data, 0, CarAudioRecord.AUDIO_CONTENT_BUFFER_SIZE) >= 0) {
            // Use data array
            // Potentially call carAudioRecord.stopRecording() if your processing finds end of speech
        }
        carAudioRecord.stopRecording();
 

מיקוד אודיו

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

הנה דוגמה לאופן שבו אפשר להתמקד באודיו:

 
val carAudioRecord = CarAudioRecord.create(carContext)
        
        // Take audio focus so that user's media is not recorded
        val audioAttributes = AudioAttributes.Builder()
            .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
            // Use the most appropriate usage type for your use case
            .setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE)
            .build()
        
        val audioFocusRequest =
            AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE)
                .setAudioAttributes(audioAttributes)
                .setOnAudioFocusChangeListener { state: Int ->
                    if (state == AudioManager.AUDIOFOCUS_LOSS) {
                        // Stop recording if audio focus is lost
                        carAudioRecord.stopRecording()
                    }
                }
                .build()
        
        if (carContext.getSystemService(AudioManager::class.java)
                .requestAudioFocus(audioFocusRequest)
            != AudioManager.AUDIOFOCUS_REQUEST_GRANTED
        ) {
            // Don't record if the focus isn't granted
            return
        }
        
        carAudioRecord.startRecording()
        // Process the audio and abandon the AudioFocusRequest when done

CarAudioRecord carAudioRecord = CarAudioRecord.create(getCarContext());
        // Take audio focus so that user's media is not recorded
        AudioAttributes audioAttributes =
                new AudioAttributes.Builder()
                        .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
                        // Use the most appropriate usage type for your use case
                        .setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE)
                        .build();

        AudioFocusRequest audioFocusRequest =
                new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE)
                        .setAudioAttributes(audioAttributes)
                        .setOnAudioFocusChangeListener(state -> {
                            if (state == AudioManager.AUDIOFOCUS_LOSS) {
                                // Stop recording if audio focus is lost
                                carAudioRecord.stopRecording();
                            }
                        })
                        .build();

        if (getCarContext().getSystemService(AudioManager.class).requestAudioFocus(audioFocusRequest)
                != AUDIOFOCUS_REQUEST_GRANTED) {
            // Don't record if the focus isn't granted
            return;
        }

        carAudioRecord.startRecording();
        // Process the audio and abandon the AudioFocusRequest when done
 

ספריית בדיקות

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

עיינו ב טעימות כדי לקבל דוגמאות לשימוש.

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

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

דיווח על בעיה חדשה

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