Multi-Display Communications API

AAOS में, मल्टी-डिसप्ले कम्यूनिकेशन एपीआई का इस्तेमाल, सिस्टम के पास खास अधिकारों वाले ऐप्लिकेशन से किया जा सकता है. इससे कार के किसी दूसरे ऑक्यूपंट ज़ोन में चल रहे उसी ऐप्लिकेशन (एक ही पैकेज का नाम) से कम्यूनिकेट किया जा सकता है. इस पेज पर, एपीआई को इंटिग्रेट करने का तरीका बताया गया है. ज़्यादा जानने के लिए आप CarOccupantZoneManager.OccupantZoneInfo भी देख सकते हैं.

ऑक्यूपंट ज़ोन

ऑक्यूपंट ज़ोन की मदद से, किसी उपयोगकर्ता को डिसप्ले के सेट से मैप किया जाता है. हर ऑक्यूपंट ज़ोन में, DISPLAY_TYPE_MAIN टाइप का डिसप्ले होता है. किसी ऑक्यूपंट ज़ोन में, क्लस्टर डिसप्ले जैसे अन्य डिसप्ले भी हो सकते हैं. हर ऑक्यूपंट ज़ोन को एक Android उपयोगकर्ता असाइन किया जाता है. हर उपयोगकर्ता के अपने खाते और ऐप्लिकेशन होते हैं.

public class MyReceiverService extends AbstractReceiverService {

    @Override
    public void onConnectionInitiated(@NonNull OccupantZoneInfo senderZone) {
    }

    @Override
    public void onPayloadReceived(@NonNull OccupantZoneInfo senderZone,
            @NonNull Payload payload) {
    }
}

<service android:name=".MyReceiverService"
         android:permission="android.car.occupantconnection.permission.BIND_RECEIVER_SERVICE"
         android:exported="true">
    <intent-filter>
        <action android:name="android.car.intent.action.RECEIVER_SERVICE" />
    </intent-filter>
</service>

<!-- This permission is needed for connection API -->
<uses-permission android:name="android.car.permission.MANAGE_OCCUPANT_CONNECTION"/>
<!-- This permission is needed for discovery API -->
<uses-permission android:name="android.car.permission.MANAGE_REMOTE_DEVICE"/>
<!-- This permission is needed if the client app calls CarRemoteDeviceManager#setOccupantZonePower() -->
<uses-permission android:name="android.car.permission.CAR_POWER"/>

// packages/services/Car/data/etc/com.google.android.car.multidisplaytest.xml
<permissions>
    <privapp-permissions package="com.google.android.car.multidisplaytest">
        … …
        <permission name="android.car.permission.MANAGE_OCCUPANT_CONNECTION"/>
        <permission name="android.car.permission.MANAGE_REMOTE_DEVICE"/>
        <permission name="android.car.permission.CAR_POWER"/>
    </privapp-permissions>
</permissions>

private CarRemoteDeviceManager mRemoteDeviceManager;
private CarOccupantConnectionManager mOccupantConnectionManager;

private final Car.CarServiceLifecycleListener mCarServiceLifecycleListener = (car, ready) -> {
   if (!ready) {
       Log.w(TAG, "Car service crashed");
       mRemoteDeviceManager = null;
       mOccupantConnectionManager = null;
       return;
   }
   mRemoteDeviceManager = car.getCarManager(CarRemoteDeviceManager.class);
   mOccupantConnectionManager = car.getCarManager(CarOccupantConnectionManager.class);
};

Car.createCar(getContext(), /* handler= */ null, Car.CAR_WAIT_TIMEOUT_WAIT_FOREVER,
       mCarServiceLifecycleListener);

// The maps are accessed by the main thread only, so there is no multi-thread issue.
private final ArrayMap<OccupantZoneInfo, Integer> mOccupantZoneStateMap = new ArrayMap<>();
private final ArrayMap<OccupantZoneInfo, Integer> mAppStateMap = new ArrayMap<>();

private final StateCallback mStateCallback = new StateCallback() {
        @Override
        public void onOccupantZoneStateChanged(
                @androidx.annotation.NonNull OccupantZoneInfo occupantZone,
                int occupantZoneStates) {
            mOccupantZoneStateMap.put(occupantZone, occupantZoneStates);
        }
        @Override
        public void onAppStateChanged(
                @androidx.annotation.NonNull OccupantZoneInfo occupantZone,
                int appStates) {
            mAppStateMap.put(occupantZone, appStates);
        }
    };

if (mRemoteDeviceManager != null) {
   mRemoteDeviceManager.registerStateCallback(getActivity().getMainExecutor(),
           mStateCallback);
}

private boolean canRequestConnectionToReceiver(OccupantZoneInfo receiverZone) {
    Integer zoneState = mOccupantZoneStateMap.get(receiverZone);
    if ((zoneState == null) || (zoneState.intValue() & (FLAG_OCCUPANT_ZONE_POWER_ON
            // FLAG_OCCUPANT_ZONE_SCREEN_UNLOCKED is not implemented yet. Right now
            // just ignore this flag.
            //  | FLAG_OCCUPANT_ZONE_SCREEN_UNLOCKED
            | FLAG_OCCUPANT_ZONE_CONNECTION_READY)) == 0) {
        return false;
    }
    Integer appState = mAppStateMap.get(receiverZone);
    if ((appState == null) ||
        (appState.intValue() & (FLAG_CLIENT_INSTALLED
            | FLAG_CLIENT_SAME_LONG_VERSION | FLAG_CLIENT_SAME_SIGNATURE
            | FLAG_CLIENT_RUNNING | FLAG_CLIENT_IN_FOREGROUND)) == 0) {
        return false;
    }
    return true;
}

if (mRemoteDeviceManager != null) {
    mRemoteDeviceManager.unregisterStateCallback();
}

    private final ConnectionRequestCallback mRequestCallback = new ConnectionRequestCallback() {
        @Override
        public void onConnected(OccupantZoneInfo receiverZone) {
        }

        @Override
        public void onFailed(OccupantZoneInfo receiverZone, int connectionError) {
        }

        @Override
        public void onDisconnected(OccupantZoneInfo receiverZone) {
        }
    };

if (mOccupantConnectionManager != null && canRequestConnectionToReceiver(receiverZone)) {
    mOccupantConnectionManager.requestConnection(receiverZone,
                getActivity().getMainExecutor(), mRequestCallback);
}

जब भेजने वाला क्लाइंट, पाने वाले क्लाइंट से कनेक्शन का अनुरोध करता है, तो पाने वाले ऐप्लिकेशन में मौजूद AbstractReceiverService कार सेवा से बाइंड हो जाएगा. साथ ही, AbstractReceiverService.onConnectionInitiated() को शुरू किया जाएगा. भेजने वाला कनेक्शन का अनुरोध करना में बताए गए तरीके के मुताबिक, onConnectionInitiated() एक ऐब्स्ट्रैक्ट तरीका है. इसे क्लाइंट ऐप्लिकेशन को लागू करना होगा.

जब पाने वाला क्लाइंट, कनेक्शन का अनुरोध स्वीकार करता है, तो भेजने वाले क्लाइंट का ConnectionRequestCallback.onConnected() शुरू हो जाएगा. इसके बाद, कनेक्शन बन जाएगा.

(भेजने वाला) पेलोड भेजना

कनेक्शन बनने के बाद, भेजने वाला क्लाइंट, पाने वाले क्लाइंट को Payload भेज **सकता है**:

if (mOccupantConnectionManager != null) {
    Payload payload = ...;
    try {
        mOccupantConnectionManager.sendPayload(receiverZone, payload);
    } catch (CarOccupantConnectionManager.PayloadTransferException e) {
        Log.e(TAG, "Failed to send Payload to " + receiverZone);
    }
}

भेजने वाला क्लाइंट, Payload में Binder ऑब्जेक्ट या बाइट कलेक्शन डाल सकता है. अगर भेजने वाले क्लाइंट को अन्य डेटा टाइप भेजने हैं, तो उसे डेटा को बाइट कलेक्शन में सीरियल में बदलना होगा. इसके बाद, बाइट कलेक्शन का इस्तेमाल करके Payload ऑब्जेक्ट बनाना होगा और Payload भेजना होगा. इसके बाद, पाने वाले क्लाइंट को मिले Payload से बाइट कलेक्शन मिलता है. साथ ही, वह बाइट कलेक्शन को अनुमानित डेटा ऑब्जेक्ट में सीरियल से बदलता है. उदाहरण के लिए, अगर भेजने वाला क्लाइंट, आईडी FragmentB वाले पाने वाले एंडपॉइंट को hello स्ट्रिंग भेजना चाहता है, तो वह इस तरह का डेटा टाइप तय करने के लिए, Proto Buffers का इस्तेमाल कर सकता है:

message MyData {
  required string receiver_endpoint_id = 1;
  required string data = 2;
}

पहली इमेज में, Payload के फ़्लो को दिखाया गया है:

(पाने वाले की सेवा) पेलोड पाना और भेजना

जब पाने वाले ऐप्लिकेशन को Payload मिलता है, तो उसका AbstractReceiverService.onPayloadReceived() शुरू हो जाएगा. पेलोड भेजना में बताए गए तरीके के मुताबिक, onPayloadReceived() एक ऐब्स्ट्रैक्ट तरीका है. इसे क्लाइंट ऐप्लिकेशन को लागू करना होगा. इस तरीके में, क्लाइंट Payload को उससे जुड़े पाने वाले एंडपॉइंट पर फ़ॉरवर्ड कर सकता है या Payload को कैश कर सकता है. इसके बाद, जब अनुमानित पाने वाला एंडपॉइंट रजिस्टर हो जाए, तब उसे भेजा जा सकता है.

(पाने वाला एंडपॉइंट) रजिस्टर करना और रजिस्ट्रेशन रद्द करना

ज़रूरी है कि पाने वाला ऐप्लिकेशन, पाने वाले एंडपॉइंट को रजिस्टर करने के लिए registerReceiver() को कॉल करे. इसका एक सामान्य इस्तेमाल यह है कि किसी फ़्रैगमेंट को Payload पाने की ज़रूरत होती है. इसलिए, वह पाने वाले एंडपॉइंट को रजिस्टर करता है:

private final PayloadCallback mPayloadCallback = (senderZone, payload) -> {
    …
};

if (mOccupantConnectionManager != null) {
    mOccupantConnectionManager.registerReceiver("FragmentB",
                getActivity().getMainExecutor(), mPayloadCallback);
}

जब पाने वाले क्लाइंट में मौजूद AbstractReceiverService, Payload को पाने वाले एंडपॉइंट पर भेजता है, तो उससे जुड़ा PayloadCallback शुरू हो जाएगा.

क्लाइंट ऐप्लिकेशन, एक से ज़्यादा पाने वाले एंडपॉइंट रजिस्टर कर सकता है. हालांकि, ज़रूरी है कि क्लाइंट ऐप्लिकेशन में उनके receiverEndpointId यूनीक हों. AbstractReceiverService, receiverEndpointId का इस्तेमाल करके यह तय करेगा कि `Payload` को किन पाने वाले एंडपॉइंट पर भेजना है. उदाहरण के लिए:

• भेजने वाला क्लाइंट, Payload में receiver_endpoint_id:FragmentB तय करता है. Payload पाने पर, पाने वाले क्लाइंट में मौजूद AbstractReceiverService, Payload को FragmentB पर भेजने के लिए, forwardPayload("FragmentB", payload) को कॉल करता है
• भेजने वाला क्लाइंट, Payload में data_type:VOLUME_CONTROL तय करता है. पाने पर, पाने वाले क्लाइंट में मौजूद AbstractReceiverService को पता होता है कि इस तरह का Payload, FragmentB पर भेजा जाना चाहिए. इसलिए, वह forwardPayload("FragmentB", payload) को कॉल करता हैPayload

if (mOccupantConnectionManager != null) {
    mOccupantConnectionManager.unregisterReceiver("FragmentB");
}

(भेजने वाला) कनेक्शन खत्म करना

जब भेजने वाले क्लाइंट को पाने वाले क्लाइंट को Payload भेजने की ज़रूरत नहीं होती (उदाहरण के लिए, जब वह इनऐक्टिव हो जाता है), तो उसे कनेक्शन खत्म कर देना चाहिए.

if (mOccupantConnectionManager != null) {
    mOccupantConnectionManager.disconnect(receiverZone);
}

डिसकनेक्ट होने के बाद, भेजने वाला क्लाइंट, पाने वाले क्लाइंट को Payload नहीं भेज सकता.

कनेक्शन का फ़्लो

दूसरी इमेज में, कनेक्शन का फ़्लो दिखाया गया है.

समस्या हल करना

लॉग देखना

लॉग देखने के लिए:

1. लॉगिंग के लिए, यह निर्देश चलाएं:

   adb shell setprop log.tag.CarRemoteDeviceService VERBOSE && adb shell setprop log.tag.CarOccupantConnectionService VERBOSE && adb logcat -s "AbstractReceiverService","CarOccupantConnectionManager","CarRemoteDeviceManager","CarRemoteDeviceService","CarOccupantConnectionService"

2. CarRemoteDeviceService और CarOccupantConnectionService की इंटरनल स्थिति को डंप करने के लिए:

   adb shell dumpsys car_service --services CarRemoteDeviceService && adb shell dumpsys car_service --services CarOccupantConnectionService

CarRemoteDeviceManager और CarOccupantConnectionManager की वैल्यू 'नल' होना

इन संभावित मुख्य वजहों की जांच करें:

1. कार सेवा क्रैश हो गई. जैसा कि पहले बताया गया है, कार सेवा क्रैश होने पर, दोनों मैनेजर को जान-बूझकर रीसेट करके null पर सेट कर दिया जाता है. कार सेवा के रीस्टार्ट होने पर, दोनों मैनेजर की वैल्यू 'नल' से बदलकर कोई दूसरी वैल्यू सेट कर दी जाती है.

2. CarRemoteDeviceService या CarOccupantConnectionService चालू नहीं है. यह पता करने के लिए कि इनमें से कोई एक सेवा चालू है या नहीं, यह निर्देश चलाएं:

   adb shell dumpsys car_service --services CarFeatureController

   • mDefaultEnabledFeaturesFromConfig देखें. इसमें car_remote_device_service और car_occupant_connection_service शामिल होना चाहिए. उदाहरण के लिए:

     mDefaultEnabledFeaturesFromConfig:[car_evs_service, car_navigation_service, car_occupant_connection_service, car_remote_device_service, car_telemetry_service, cluster_home_service, com.android.car.user.CarUserNoticeService, diagnostic, storage_monitoring, vehicle_map_service]
     

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

     // packages/services/Car/service/res/values/config.xml
     <string-array translatable="false" name="config_allowed_optional_car_features">
          <item>car_occupant_connection_service</item>
          <item>car_remote_device_service</item>
          … …
     </string-array>
     

एपीआई को कॉल करते समय होने वाली गड़बड़ी

अगर क्लाइंट ऐप्लिकेशन, एपीआई का इस्तेमाल तय किए गए तरीके से नहीं कर रहा है, तो गड़बड़ी हो सकती है. इस मामले में, क्लाइंट ऐप्लिकेशन, समस्या हल करने के लिए गड़बड़ी में मौजूद मैसेज और क्रैश स्टैक की जांच कर सकता है. एपीआई का गलत इस्तेमाल करने के उदाहरण:

• registerStateCallback() इस क्लाइंट ने पहले ही StateCallback रजिस्टर कर लिया है.
• unregisterStateCallback() इस CarRemoteDeviceManager इंस्टेंस ने कोई StateCallback रजिस्टर नहीं किया है.
• registerReceiver() receiverEndpointId पहले से रजिस्टर है.
• unregisterReceiver() receiverEndpointId रजिस्टर नहीं है.
• requestConnection() कनेक्शन का कोई अनुरोध पहले से मौजूद है या कनेक्शन पहले से बना हुआ है.
• cancelConnection() रद्द करने के लिए, कनेक्शन का कोई अनुरोध मौजूद नहीं है.
• sendPayload() कनेक्शन नहीं बना है.
• disconnect() कनेक्शन नहीं बना है.

क्लाइंट1, क्लाइंट2 को पेलोड भेज सकता है, लेकिन क्लाइंट2, क्लाइंट1 को पेलोड नहीं भेज सकता

कनेक्शन को डिज़ाइन करते समय, इसे एकतरफ़ा बनाया गया है. दोतरफ़ा कनेक्शन बनाने के लिए, ज़रूरी है कि client1 और client2, दोनों एक-दूसरे से कनेक्शन का अनुरोध करें और फिर मंज़ूरी पाएं.