'कार के लिए Android ऐप्लिकेशन' की लाइब्रेरी का इस्तेमाल करना

Android for Cars ऐप्लिकेशन की लाइब्रेरी की मदद से नेविगेशन, लोकप्रिय जगह, और इंटरनेट ऑफ़ थिंग्स (आईओटी) को सेट किया जा सकता है कार में जोड़े गए ऐप्लिकेशन. ऐसा करने के लिए, इसमें टेंप्लेट का एक सेट उपलब्ध कराया जाता है, जो ड्राइवर का ध्यान भटकने से रोकने के लिए डिज़ाइन किया गया है मानकों का पालन करना होगा और ऐसी चीज़ों का ध्यान रखना होगा जिनमें कार की स्क्रीन पर मौजूद अलग-अलग तरह के फ़ैक्टर शामिल हों और इनपुट मोडलिटी.

यह गाइड, लाइब्रेरी की मुख्य सुविधाओं और सिद्धांतों के बारे में खास जानकारी देती है. बेसिक ऐप्लिकेशन को सेट अप करने की प्रोसेस के बारे में जानकारी देता है.

कोडलैब (कोड बनाना सीखना)

कार ऐप्लिकेशन की लाइब्रेरी की बुनियादी बातें जानें

arrow_forward

शुरू करने से पहले

1. डिज़ाइन फ़ॉर ड्राइविंग देखें कार ऐप्लिकेशन लाइब्रेरी को कवर करने वाले पेज
   • नेविगेशन ऐप्लिकेशन और ड्राइविंग से जुड़े अन्य ऐप्लिकेशन कैटगरी की खास जानकारी
   • टेंप्लेट की मदद से ऐप्लिकेशन बनाने के बारे में खास जानकारी
   • बिल्डिंग ब्लॉक टेंप्लेट और टेंप्लेट कॉम्पोनेंट शामिल हैं
   • सैंपल फ़्लो उपयोगकर्ता अनुभव के सामान्य पैटर्न दिखाए गए हैं
   • टेंप्लेट वाले ऐप्लिकेशन की ज़रूरी शर्तें
2. यहां दी गई मुख्य शर्तों और सिद्धांतों को पढ़ें सेक्शन में जाएं.
3. स्वयं को Android Auto सिस्टम के बारे में जानें यूज़र इंटरफ़ेस (यूआई) और Android Automotive OS डिज़ाइन के लिए जानी जाती है.
4. रिलीज़ नोट देखें.
5. सैंपल देखें.

मुख्य शब्द और सिद्धांत

मॉडल और टेंप्लेट

यूज़र इंटरफ़ेस को मॉडल ऑब्जेक्ट के ग्राफ़ से दिखाया जाता है. इस ग्राफ़ को टेंप्लेट के हिसाब से, उन्हें अलग-अलग तरीकों से व्यवस्थित किया जा सकता है से. टेंप्लेट उन मॉडल के सबसेट होते हैं जो उन ग्राफ़. मॉडल में उपयोगकर्ता को दिखाई जाने वाली जानकारी शामिल होती है के पहलुओं को कॉन्फ़िगर करने के लिए विशेषताओं को शामिल किया है. ऐसी जानकारी को विज़ुअल के तौर पर दिखाना—उदाहरण के लिए, टेक्स्ट के रंग या इमेज साइज़. होस्ट, मॉडल को ऐसे व्यू में बदल देता है जो पूरा होने के लिए डिज़ाइन किए गए हों ड्राइवर का ध्यान भटकने से रोकने के लिए तय किए गए स्टैंडर्ड और ध्यान रखता है कि कार की स्क्रीन फ़ैक्टर और इनपुट के मोडलिटी पर ध्यान दिया जाता है.

होस्ट

होस्ट, बैकएंड कॉम्पोनेंट है जो दी गई सुविधा को लागू करता है के एपीआई का इस्तेमाल करें, ताकि आपका ऐप्लिकेशन कार में चल सके. कॉन्टेंट बनाने होस्ट की ज़िम्मेदारियां, आपके ऐप्लिकेशन को खोजने से लेकर उसे मैनेज करने तक की हैं आपके मॉडल को व्यू में बदलने और ऐप्लिकेशन को सूचना भेजने की यह लाइफ़साइकल उपयोगकर्ता इंटरैक्शन की संख्या बढ़ानी होती है. मोबाइल डिवाइसों पर, 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> एलिमेंट इंटेंट फ़िल्टर का इस्तेमाल करें. इसकी सूची देखें काम करने वाली ऐप्लिकेशन श्रेणियों के लिए मंज़ूर किए गए मानों के लिए इस एलिमेंट का इस्तेमाल करें.

नीचे दिया गया कोड स्निपेट बताता है कि जहां तक अपनी मेनिफ़ेस्ट फ़ाइल में इंटरेस्ट ऐप्लिकेशन जोड़ें:

<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>

इस्तेमाल किए जा सकने वाले ऐप्लिकेशन की कैटगरी

इनमें से एक या ज़्यादा कैटगरी जोड़कर अपने ऐप्लिकेशन की कैटगरी बताएं जब आपने बताए गए तरीके से 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>

कार ऐप्लिकेशन का एपीआई लेवल

कार ऐप्लिकेशन लाइब्रेरी अपने एपीआई लेवल तय करती है, ताकि आप जान सकें कि लाइब्रेरी की सुविधाएं, वाहन पर टेंप्लेट होस्ट के साथ काम करती हैं. किसी होस्ट के साथ काम करने वाला सबसे बड़ा Car ऐप्लिकेशन एपीआई लेवल वापस पाने के लिए, getCarAppApiLevel() तरीका.

अपनी AndroidManifest.xml फ़ाइल:

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

इसके लिए दस्तावेज़ देखें RequiresCarApi पुराने सिस्टम के साथ काम करने की सुविधा को बनाए रखने और एलान करने के तरीके की जानकारी किसी सुविधा का इस्तेमाल करने के लिए, एपीआई लेवल का कम से कम ज़रूरी लेवल. किस एपीआई की परिभाषा जानने के लिए कार ऐप्लिकेशन लाइब्रेरी की किसी खास सुविधा का इस्तेमाल करने के लिए, किसी खास लेवल की ज़रूरत होती है, तो के लिए संदर्भ दस्तावेज़ 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 इंस्टेंस, कार की स्क्रीन में दिखने वाली यूज़र इंटरफ़ेस (यूआई) की स्थिति.

नीचे दिया गया स्निपेट दिखाता है कि Screen, जो PaneTemplate टेम्प्लेट को एक सामान्य “नमस्ते दुनिया!” स्ट्रिंग:

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 लागू करने पर, यह टेंप्लेट दिखता है.

मैप बनाएं

नेविगेशन और लोकप्रिय जगह (पीओआई) ऐप्लिकेशन, इन टेंप्लेट का इस्तेमाल करके 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.

उपयोगकर्ताओं को अपने मैप से इंटरैक्ट करने दें

इन टेंप्लेट का इस्तेमाल करते समय, उपयोगकर्ताओं की इंटरैक्ट करने के लिए सहायता जोड़ी जा सकती है बनाए गए मैप के साथ, जैसे कि मैप के अलग-अलग हिस्सों को ज़ूम और पैन करना.

इंटरैक्टिविटी कॉलबैक लागू करना

SurfaceCallback इंटरफ़ेस में कई कॉलबैक विधियां हैं, जिन्हें आप मैप पर इंटरैक्टिविटी जोड़ने के लिए लागू कर सकते हैं इन टेंप्लेट की मदद से:

मैप ऐक्शन बार जोड़ें

इन टेंप्लेट में मैप से जुड़ी कार्रवाइयों के लिए, मैप ऐक्शन बार हो सकता है, जैसे कि ज़ूम इन और ज़ूम आउट करना, फिर से सेंटर में लाना, कंपास दिखाना, और अन्य कार्रवाइयां दिखाने के लिए चुना जा सकता है. मैप कार्रवाई बार में आइकॉन के लिए ज़्यादा से ज़्यादा चार बटन हो सकते हैं जिसे टास्क की गहराई पर असर डाले बिना रीफ़्रेश किया जा सकता है. डिवाइस कुछ समय से इस्तेमाल में न होने पर, यह छिप जाता है और ऐक्टिव स्थिति पर फिर से दिखता है.

मैप पर इंटरैक्टिव कॉलबैक पाने के लिए, आपको मैप के ऐक्शन बार में Action.PAN बटन जोड़ना ज़रूरी है. जब उपयोगकर्ता पैन बटन दबाता है, तो होस्ट पैन मोड में चला जाता है, जैसा कि नीचे बताया गया है सेक्शन में जाएं.

अगर आपके ऐप्लिकेशन में Action.PAN, सेव नहीं किया जाता है बटन दिखाई देता है, तो इसे इससे उपयोगकर्ता इनपुट नहीं मिलता SurfaceCallback तरीके और होस्ट, पहले से चालू किसी भी तरीके को बंद कर देता है पैन मोड.

टचस्क्रीन पर, 'पैन करें' बटन नहीं दिखता है.

पैन मोड के बारे में जानकारी

पैन मोड में, टेंप्लेट होस्ट, नॉन-टच इनपुट से उपयोगकर्ता के इनपुट का अनुवाद करता है रोटरी कंट्रोलर और टचपैड जैसे डिवाइस 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 तरीका:

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);
}

ऐप्लिकेशन शुरू करने के तरीके के बारे में ज़्यादा जानकारी पाने के लिए, ACTION_NAVIGATE इंटेंट, इंटेंट के साथ कार ऐप्लिकेशन शुरू करें देखें सेक्शन में जाएं.

कुछ कार्रवाइयां, जैसे कि वे कार्रवाइयां जिन्हें जारी रखने के लिए उपयोगकर्ता को निर्देश देना ज़रूरी होता है मोबाइल डिवाइस पर इंटरैक्शन, सिर्फ़ कार पार्क होने पर ही किए जा सकते हैं. Google आपके यूआरएल पैरामीटर को कैसे इस्तेमाल करेगा, यह तय करने के लिए 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 मान के साथ कॉल किया जाता है, तो ज़्यादा प्राथमिकता वाली सूचना इस तौर पर दिखती है सिर्फ़ एक बार हन.

अपनी कार के ऐप्लिकेशन की सूचनाओं को डिज़ाइन करने के बारे में ज़्यादा जानने के लिए, Google डिज़ाइन फ़ॉर ड्राइविंग गाइड सूचनाएं.

टोस्ट दिखाएं

आपका ऐप्लिकेशन, इसका इस्तेमाल करके टोस्ट दिखा सकता है CarToast, जैसा कि इस स्निपेट में दिखाया गया है:

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

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

अनुमतियां मांगें

अगर आपके ऐप्लिकेशन को प्रतिबंधित डेटा या कार्रवाइयों के ऐक्सेस की ज़रूरत हो, तो उदाहरण के लिए, जगह—Android के स्टैंडर्ड नियम अनुमतियां लागू करें. अनुमति पाने का अनुरोध करने के लिए, CarContext.requestPermissions() तरीका.

इस्तेमाल करने के फ़ायदे CarContext.requestPermissions(), इसका इस्तेमाल करने के बजाय मानक Android API, इन कामों के लिए आपको अपना 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 डेटा यूआरआई वाले इंटेंट से:

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 में दो टेंप्लेट भेजता है और फिर स्क्रीन को पुश करता है B, यह अब तीन और टेंप्लेट भेज सकता है. इसके अलावा, अगर हर स्क्रीन स्ट्रक्चर्ड है एक टेंप्लेट भेजने के लिए किया जाता है, तो ऐप्लिकेशन पांच स्क्रीन इंस्टेंस को पुश ScreenManager स्टैक.

इन पाबंदियों के कुछ खास मामले होते हैं: टेंप्लेट रीफ़्रेश करना और वापस जाना और कार्रवाइयां रीसेट करें.

टेंप्लेट रीफ़्रेश हो जाता है

कुछ कॉन्टेंट अपडेट को टेंप्लेट की सीमा के तहत नहीं गिना जाता. सामान्य तौर पर, अगर कोई ऐप्लिकेशन एक ही तरह के नए टेंप्लेट को पुश करता है और पिछले टेंप्लेट के समान मुख्य कॉन्टेंट, नया टेंप्लेट को कोटे में गिना जाता है. उदाहरण के लिए, किसी पंक्ति की टॉगल स्थिति को अपडेट करके इसमें ListTemplate को शामिल नहीं किया जाता को कम कर सकते हैं. ज़्यादा जानने के लिए, अलग-अलग टेंप्लेट के दस्तावेज़ देखें कॉन्टेंट अपडेट के किस तरह के अपडेट को रीफ़्रेश माना जा सकता है.

बैक ऑपरेशन

किसी टास्क में सब-फ़्लो चालू करने के लिए, होस्ट यह पता लगाता है कि कोई ऐप्लिकेशन ScreenManager स्टैक और अपडेट में से Screen बचा हुआ कोटा, ऐप्लिकेशन के टेंप्लेट की संख्या के हिसाब से तय होता है को पीछे करें.

उदाहरण के लिए, अगर ऐप्लिकेशन स्क्रीन A में होने पर दो टेंप्लेट भेजता है, फिर पुश करता है स्क्रीन B जोड़ने के साथ-साथ दो और टेंप्लेट भेजता है. हालांकि, ऐप्लिकेशन के लिए सिर्फ़ एक कोटा बचा है. अगर आपने ऐप्लिकेशन फिर से स्क्रीन A पर पॉप-अप करता है, इसलिए होस्ट कोटा को तीन पर रीसेट कर देता है. ऐसा इसलिए, क्योंकि ऐप्लिकेशन दो टेम्प्लेट से पीछे चला गया है.

ध्यान दें कि, स्क्रीन पर वापस पॉप-अप करते समय, ऐप्लिकेशन को एक ऐसा टेंप्लेट भेजना होगा जो उसी तरह का हो जो उस स्क्रीन पर आखिरी बार भेजा गया था. कोई और भेजा जा रहा है टेंप्लेट टाइप की वजह से गड़बड़ी होती है. हालांकि, जब तक प्रकार वापस कार्रवाई के दौरान, ऐप्लिकेशन आपकी साइट की सामग्री को आसानी से संशोधित कर सकता है कोटा को प्रभावित किए बिना टेम्प्लेट कर सकते हैं.

कार्रवाइयां रीसेट करें

कुछ टेंप्लेट में खास सिमेंटिक्स होते हैं, जो टास्क खत्म होने के बारे में बताते हैं. इसके लिए उदाहरण के लिए, NavigationTemplate एक ऐसा व्यू है जो स्क्रीन पर बना रहेगा और नए के साथ रीफ़्रेश हो जाएगा उपयोगकर्ता के इस्तेमाल के बारे में सिलसिलेवार निर्देश. जब यह इनमें से किसी एक पर पहुंच जाए होस्ट, टेंप्लेट के कोटा को रीसेट करता है. तो वह नए काम का पहला कदम है. इससे ऐप्लिकेशन को नया टास्क शुरू करने की अनुमति मिलती है. यह देखने के लिए कि कौनसे टेंप्लेट रीसेट ट्रिगर होते हैं, अलग-अलग टेंप्लेट के दस्तावेज़ देखें होस्ट पर.

अगर होस्ट को सूचना कार्रवाई से ऐप्लिकेशन शुरू करने का इंटेंट मिलता है या कोटा को भी रीसेट कर दिया जाता है. इस तरीके की मदद से, ऐप्लिकेशन सूचनाओं से एक नया टास्क फ़्लो शुरू करता है. साथ ही, वह सही रहता है, भले ही कोई ऐप्लिकेशन पहले से ही बंधा हुआ है और स्क्रीन पर दिखाई दे रहा है.

ज़्यादा जानकारी के लिए, सूचनाएं दिखाएं सेक्शन देखें कार की स्क्रीन में अपने ऐप्लिकेशन की सूचनाएं दिखाने का तरीका जानें. ज़्यादा जानकारी के लिए, इंटेंट के साथ कार ऐप्लिकेशन शुरू करें सेक्शन से, आपको यह जानकारी मिलेगी कि सूचना पर कार्रवाई करके अपना ऐप्लिकेशन शुरू करें.

कनेक्शन एपीआई

यह तय किया जा सकता है कि आपका ऐप्लिकेशन, 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();
}

कंस्ट्रेंट एपीआई

अलग-अलग कारों में Item इंस्टेंस इन्हें दिखाने हैं उपयोगकर्ता को एक बार में ट्रैक कर सकते हैं. इसका इस्तेमाल करें ConstraintManager रनटाइम के दौरान कॉन्टेंट की सीमा देखने और आइटम की सही संख्या सेट करने के लिए आपके टेंप्लेट में.

CarContext से ConstraintManager लें:

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 कार ऐप्लिकेशन API लेवल 2 और उसके बाद वाले वर्शन के साथ, मुख्य यूनिट की जानकारी दें.

SignInTemplate बनाने के लिए, SignInMethod तय करें. द कार फ़िलहाल, ऐप्लिकेशन लाइब्रेरी में साइन-इन करने के ये तरीके काम करते हैं:

• InputSignInMethod का इस्तेमाल करें.
• PinSignInMethod पिन से साइन-इन करने के लिए, जहां उपयोगकर्ता अपने फ़ोन से अपने खाते को लिंक करता है मुख्य यूनिट पर दिखने वाले पिन का इस्तेमाल करके.
• ProviderSignInMethod सेवा देने वाली कंपनी के तौर पर साइन-इन के लिए, जैसे कि Google साइन इन और One Tap.
• QRCodeSignInMethod क्यूआर कोड साइन इन के लिए, जहां उपयोगकर्ता साइन-इन पूरा करने के लिए क्यूआर कोड स्कैन करता है उसका फ़ोन. यह सुविधा, कार एपीआई लेवल 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.
    }
};

InputSignInMethod Builder के लिए, InputCallback ज़रूरी है.

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();

आखिर में, SignInTemplate बनाने के लिए, अपने नए InputSignInMethod का इस्तेमाल करें.

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();

Account Manager का इस्तेमाल करें

पुष्टि करने वाले Android Automotive OS वाले ऐप्लिकेशन का इस्तेमाल करना ज़रूरी है Account Manager की ये वजहें हो सकती हैं:

• बेहतर उपयोगकर्ता अनुभव और खाते को मैनेज करना आसान होना: लोग सभी ऐप्लिकेशन को आसानी से मैनेज कर सकते हैं सिस्टम सेटिंग में मौजूद खाता मेन्यू से अपने खाते बनाना, जिसमें साइन-इन करना भी शामिल है और साइन-आउट करें.
• "मेहमान" अनुभव: कार, शेयर किए गए डिवाइस होती हैं. इसलिए, OEM ये चालू कर सकते हैं: वाहन में मेहमानों के अनुभव, जहां खाते जोड़े नहीं जा सकते.

टेक्स्ट स्ट्रिंग के वैरिएंट जोड़ें

अलग-अलग कार की स्क्रीन के लिए, अलग-अलग साइज़ में टेक्स्ट दिख सकता है. Car App API की मदद से लेवल 2 और उससे ऊपर के लेवल के लिए, आप किसी टेक्स्ट स्ट्रिंग के एक से ज़्यादा वैरिएंट को सबसे अच्छे उस स्क्रीन पर फ़िट हो जाता है. यह देखने के लिए कि टेक्स्ट के वैरिएंट कहां स्वीकार किए जाते हैं, टेंप्लेट देखें और CarText लेने वाले कॉम्पोनेंट.

CarText में टेक्स्ट स्ट्रिंग के वैरिएंट जोड़ने के लिए, CarText.Builder.addVariant() तरीका:

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();

स्ट्रिंग को सबसे ज़्यादा से सबसे कम पसंदीदा के क्रम में जोड़ें—उदाहरण के लिए, सबसे लंबे से लेकर सबसे छोटा. होस्ट उचित लंबाई वाली स्ट्रिंग चुनता है, जो कार की स्क्रीन पर कितनी जगह बची है.

पंक्तियों के लिए इनलाइन कैरिकॉन जोड़ें

इनका इस्तेमाल करके, अपने ऐप्लिकेशन को बेहतर तरीके से दिखाने के लिए, आइकॉन में टेक्स्ट जोड़ा जा सकता है CarIconSpan. इसके लिए दस्तावेज़ देखें CarIconSpan.create देखें. यहां जाएं: स्पैंटैस्टिक स्पैन के साथ टेक्स्ट स्टाइलिंग का इस्तेमाल करें.

  
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();
  
  

कार हार्डवेयर एपीआई

कार ऐप्लिकेशन के एपीआई लेवल 3 से शुरू करते हुए, कार ऐप्लिकेशन की लाइब्रेरी में ऐसे एपीआई मौजूद हैं जिनसे का इस्तेमाल वाहन की प्रॉपर्टी और सेंसर को ऐक्सेस करने के लिए कर सकता है.

ज़रूरी शर्तें

Android Auto के साथ एपीआई इस्तेमाल करने के लिए, इस पर डिपेंडेंसी जोड़कर शुरुआत करें आपके Android के लिए build.gradle फ़ाइल में androidx.car.app:app-projected ऑटो मॉड्यूल. Android Automotive OS के लिए, इस पर डिपेंडेंसी जोड़ें आपके Android के लिए build.gradle फ़ाइल में androidx.car.app:app-automotive Automotive OS का मॉड्यूल.

इसके अलावा, अपनी AndroidManifest.xml फ़ाइल में, आपको ये काम करने होंगे इन कामों के लिए ज़रूरी ज़रूरी अनुमतियों का एलान करना होगा कार के उस डेटा का अनुरोध करें जिसका आपको इस्तेमाल करना है. ध्यान दें कि ये अनुमतियां भी ज़रूरी हैं आपको उपयोगकर्ता की ओर से दिया गया है. Google आपके यूआरएल पैरामीटर को कैसे इस्तेमाल करेगा, यह तय करने के लिए Android Auto और Android Automotive OS, दोनों पर एक ही कोड का इस्तेमाल करें. प्लैटफ़ॉर्म-निर्भर फ़्लो बनाने से ज़्यादा है. हालांकि, जिन अनुमतियों की ज़रूरत है अलग हैं.

कार की जानकारी

इस टेबल में उन प्रॉपर्टी के बारे में बताया गया है जो CarInfo एपीआई और इन अनुमतियों का अनुरोध करना ज़रूरी है:

उदाहरण के लिए, शेष रेंज पाने के लिए, इंस्टैंशिएट करके 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);

यह न मानें कि कार का डेटा हर समय उपलब्ध है. अगर आपको गड़बड़ी का कोई मैसेज मिलता है, तो की स्थिति इसके लिए अनुरोध किया है, ताकि यह बेहतर ढंग से समझा जा सके कि आपने जिस डेटा का अनुरोध किया है वह उसे वापस नहीं पाया जा सकता. देखें के लिए संदर्भ दस्तावेज़ CarInfo क्लास की पूरी परिभाषा.

कार सेंसर्स

CarSensors क्लास आपको वाहन के एक्सलरोमीटर, जाइरोस्कोप, कंपास, और जगह की जानकारी का डेटा. इन वैल्यू की उपलब्धता, इन बातों पर निर्भर कर सकती है: ओईएम. एक्सलरोमीटर, जाइरोस्कोप, और कंपास से मिले डेटा का फ़ॉर्मैट यह आपको मिल सकता है, जैसे कि 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 ऑब्जेक्ट से इंटरैक्ट करता है लाइफ़साइकल कॉलबैक शुरू किए जाते हैं, जैसा कि नीचे दिए गए डायग्राम में बताया गया है.

CarAppService और सेशन की लाइफ़साइकल

पूरी जानकारी के लिए, Session.getLifecycle तरीका.

स्क्रीन का लाइफ़साइकल

पूरी जानकारी के लिए, Screen.getLifecycle तरीका.

कार के माइक्रोफ़ोन से रिकॉर्ड करें

आपके ऐप्लिकेशन की CarAppService और CarAudioRecord एपीआई, तो आपके ऐप्लिकेशन को उपयोगकर्ता की कार के माइक्रोफ़ोन का ऐक्सेस दिया जा सकता है. उपयोगकर्ताओं को यह देना होगा कार के माइक्रोफ़ोन को ऐक्सेस करने के लिए आपके ऐप्लिकेशन को अनुमति. आपका ऐप्लिकेशन, वीडियो को रिकॉर्ड और आपके ऐप्लिकेशन में उपयोगकर्ता के इनपुट को प्रोसेस कर सके.

रिकॉर्ड करने की अनुमति

कोई भी ऑडियो रिकॉर्ड करने से पहले, आपको 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 for Cars ऐप्लिकेशन की लाइब्रेरी से जुड़ी समस्या की शिकायत करना

अगर आपको लाइब्रेरी में कोई समस्या मिलती है, तो Google समस्या को ट्रैक करने वाला टूल. समस्या वाले टेंप्लेट में मांगी गई पूरी जानकारी भरना न भूलें.

नई समस्या जोड़ें

नई समस्या दर्ज करने से पहले, कृपया देख लें कि वह लाइब्रेरी की रिलीज़ में शामिल है या नहीं समस्याओं की सूची में शामिल किया गया है या समस्याओं की सूची में शामिल किया गया है. आप इस तरह से सदस्यता ले सकते हैं और समस्याओं के लिए वोट कर सकते हैं ट्रैकर में किसी समस्या के लिए स्टार पर क्लिक करके. ज़्यादा जानकारी के लिए, यह देखें किसी समस्या के लिए सदस्यता लेना.