Core-Telecom

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

Core-Telecom लाइब्रेरी, एपीआई का एक बेहतर और लगातार काम करने वाला सेट उपलब्ध कराकर, कॉल करने की सुविधा देने वाले ऐप्लिकेशन को Android प्लैटफ़ॉर्म के साथ इंटिग्रेट करने की प्रोसेस को आसान बनाती है

अगर आपको इसे लागू करने के बारे में जानना है, तो GitHub पर सैंपल ऐप्लिकेशन देखें:

• कम साइज़ वाला सैंपल ऐप्लिकेशन — Core-Telecom एपीआई के इस्तेमाल को दिखाने वाला छोटा उदाहरण. बुनियादी कॉन्सेप्ट को तुरंत समझने के लिए एकदम सही.
• ज़्यादा सुविधाओं वाला सैंपल ऐप्लिकेशन (कोर-टेलीकॉम टीम ने डेवलप किया है) — यह ऐप्लिकेशन, टेलीकॉम की बेहतर सुविधाओं और सबसे सही तरीकों को दिखाता है. इंटिग्रेशन के जटिल मामलों को समझने के लिए, यह एक बेहतरीन संसाधन है.

Core-Telecom सेट अप करना

अपने ऐप्लिकेशन की build.gradle फ़ाइल में androidx.core:core-telecom डिपेंडेंसी जोड़ें:

dependencies {
    implementation ("androidx.core:core-telecom:1.0.0")
}

अपने AndroidManifest.xml में MANAGE_OWN_CALLS अनुमति का एलान करें:

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

अपना ऐप्लिकेशन रजिस्टर करना

सिस्टम में कॉल जोड़ने के लिए, CallsManager का इस्तेमाल करके अपने कॉलिंग ऐप्लिकेशन को Android के साथ रजिस्टर करें. रजिस्टर करते समय, अपने ऐप्लिकेशन की सुविधाओं के बारे में बताएं. उदाहरण के लिए, ऑडियो, वीडियो के साथ काम करने की सुविधा:

val callsManager = CallsManager(context)

val capabilities: @CallsManager.Companion.Capability Int =
    (CallsManager.CAPABILITY_BASELINE or
          CallsManager.CAPABILITY_SUPPORTS_VIDEO_CALLING)

callsManager.registerAppWithTelecom(capabilities)

कॉल मैनेजमेंट

कॉल लाइफ़साइकल बनाने और उसे मैनेज करने के लिए, Core-Telecom API का इस्तेमाल करें.

कॉल बनाना

CallAttributesCompat ऑब्जेक्ट, किसी यूनीक कॉल की प्रॉपर्टी तय करता है. इसमें ये विशेषताएं हो सकती हैं:

• displayName: कॉल करने वाले का नाम.
• address: कॉल का पता (उदाहरण के लिए, फ़ोन नंबर, मीटिंग का लिंक).
• direction: इनकमिंग या आउटगोइंग.
• callType: ऑडियो या वीडियो.
• callCapabilities: ट्रांसफ़र और होल्ड करने की सुविधा काम करती है.

इनकमिंग कॉल बनाने का उदाहरण यहां दिया गया है:

fun createIncomingCallAttributes(
    callerName: String,
    callerNumber: String,
    isVideoCall: Boolean): CallAttributesCompat {
    val addressUri = Uri.parse("YourAppScheme:$callerNumber")

    // Define capabilities supported by your call.
    val callCapabilities = CallAttributesCompat.CallCapability(
        supportsSetInactive = CallAttributesCompat.SUPPORTS_SET_INACTIVE // Call can be made inactive (implies hold)
    )

    return CallAttributesCompat(
        displayName = callerName,
        address = addressUri,
        direction = CallAttributesCompat.DIRECTION_INCOMING,
        callType = if (isVideoCall) CallAttributesCompat.CALL_TYPE_VIDEO_CALL else CallAttributesCompat.CALL_TYPE_AUDIO_CALL,
        callCapabilitiesCompat = callCapabilities
    )
}

कॉल जोड़ना

सिस्टम में नया कॉल जोड़ने और रिमोट सरफ़ेस अपडेट मैनेज करने के लिए, CallAttributesCompat और कॉलबैक के साथ callsManager.addCall का इस्तेमाल करें. addCall ब्लॉक में मौजूद callControlScope, आपके ऐप्लिकेशन को कॉल की स्थिति में बदलाव करने और ऑडियो से जुड़े अपडेट पाने की अनुमति देता है:

try {
    callsManager.addCall(
        INCOMING_CALL_ATTRIBUTES,
        onAnswerCall, // Watch needs to know if it can answer the call.
        onSetCallDisconnected,
        onSetCallActive,
        onSetCallInactive
    ) {
        // The call was successfully added once this scope runs.
        callControlScope = this
    }
}
catch(addCallException: Exception){
   // Handle the addCall failure.
}

कॉल का उत्तर दें

CallControlScope में इनकमिंग कॉल का जवाब देने के लिए:

when (val result = answer(CallAttributesCompat.CALL_TYPE_AUDIO_CALL)) {
    is CallControlResult.Success -> { /* Call answered */ }
    is CallControlResult.Error -> { /* Handle error */ }
}

कॉल अस्वीकार करना

CallControlScope में DisconnectCause.REJECTED के साथ disconnect() का इस्तेमाल करके कॉल को अस्वीकार करें:

disconnect(DisconnectCause(DisconnectCause.REJECTED))

आउटगोइंग कॉल चालू करना

रिमोट पार्टी के जवाब देने के बाद, आउटगोइंग कॉल को चालू पर सेट करें:

when (val result = setActive()) {
    is CallControlResult.Success -> { /* Call active */ }
    is CallControlResult.Error -> { /* Handle error */ }
}

कॉल को होल्ड पर रखना

कॉल को होल्ड पर रखने के लिए, setInactive() का इस्तेमाल करें:

when (val result = setInactive()) {
    is CallControlResult.Success -> { /* Call on hold */ }
    is CallControlResult.Error -> { /* Handle error */ }
}

कॉल डिसकनेक्ट करना

DisconnectCause के साथ disconnect() का इस्तेमाल करके कॉल को डिसकनेक्ट करने के लिए:

disconnect(DisconnectCause(DisconnectCause.LOCAL))

कॉल के ऑडियो एंडपॉइंट मैनेज करना

CallControlScope में currentCallEndpoint, availableEndpoints, और isMuted Flow का इस्तेमाल करके, ऑडियो एंडपॉइंट को मॉनिटर और मैनेज करना

fun observeAudioStateChanges(callControlScope: CallControlScope) {
    with(callControlScope) {
        launch { currentCallEndpoint.collect { /* Update UI */ } }
        launch { availableEndpoints.collect { /* Update UI */ } }
        launch { isMuted.collect { /* Handle mute state */ } }
    }
}

requestEndpointChange() का इस्तेमाल करके, ऑडियो के लिए इस्तेमाल किया जा रहा डिवाइस बदलें:

coroutineScope.launch {
     callControlScope.requestEndpointChange(callEndpoint)
}

फ़ोरग्राउंड में सहायता

फ़ोरग्राउंड में काम करने के लिए, लाइब्रेरी ConnectionService (Android 13 एपीआई लेवल 33 और उससे पहले के वर्शन) या foregroundtypes (Android 14 एपीआई लेवल 34 और उसके बाद के वर्शन) का इस्तेमाल करती है.

फ़ोरग्राउंड की ज़रूरी शर्तों के तहत, ऐप्लिकेशन को सूचना पोस्ट करनी होगी, ताकि उपयोगकर्ताओं को पता चल सके कि ऐप्लिकेशन फ़ोरग्राउंड में चल रहा है.

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

फ़ोरग्राउंड सेवाओं के बारे में ज़्यादा जानें.

रिमोट से Surface की सहायता पाना

स्मार्टवॉच, ब्लूटूथ हेडसेट, Android Auto जैसे रिमोट डिवाइसों से, फ़ोन के बिना कॉल मैनेज किया जा सकता है. आपके ऐप्लिकेशन को CallsManager.addCall के लिए दिए गए कॉलबैक लैम्ब्डा (onAnswerCall, onSetCallDisconnected, onSetCallActive, onSetCallInactive) लागू करने होंगे, ताकि इन डिवाइसों से शुरू की गई कार्रवाइयों को मैनेज किया जा सके.

जब कोई रिमोट ऐक्शन होता है, तो उससे जुड़ा लैम्ब्डा फ़ंक्शन चालू हो जाता है.

अगर कोई निर्देश पूरा हो जाता है, तो यह लैंब्डा सिग्नल भेजता है. अगर कमांड को पूरा नहीं किया जा सकता, तो lambda को एक अपवाद फेंकना चाहिए.

सही तरीके से लागू करने पर, अलग-अलग डिवाइसों पर कॉल को आसानी से कंट्रोल किया जा सकता है. अलग-अलग रिमोट प्लैटफ़ॉर्म पर पूरी तरह से जांच करें.