Core-Telecom

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

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

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 Flows का इस्तेमाल करके, ऑडियो एंडपॉइंट को मॉनिटर और मैनेज करना

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) लागू करने होंगे, ताकि इन डिवाइसों से शुरू की गई कार्रवाइयों को मैनेज किया जा सके.

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

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

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

कॉल एक्सटेंशन

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

एक्सटेंशन के साथ कॉल बनाना

कॉल बनाने के लिए, CallManager#addCall का इस्तेमाल करने के बजाय, CallManager#addCallWithExtensions का इस्तेमाल किया जा सकता है. इससे ऐप्लिकेशन को ExtensionInitializationScope नाम के दूसरे स्कोप का ऐक्सेस मिलता है. इस स्कोप की मदद से, ऐप्लिकेशन उन वैकल्पिक एक्सटेंशन के सेट को शुरू कर सकता है जिनके साथ यह काम करता है. इसके अलावा, इस स्कोप में एक और तरीका onCall उपलब्ध है. इससे एक्सटेंशन की सुविधा के लिए डेटा का आदान-प्रदान और उसे शुरू करने की प्रोसेस पूरी होने के बाद, ऐप्लिकेशन को CallControlScope वापस मिल जाता है.

scope.launch {
    mCallsManager.addCallWithExtensions(
        attributes,
        onAnswer,
        onDisconnect,
        onSetActive,
        onSetInactive
    ) {
        // Initialize extension-specific code...

        // After the call has been initialized, perform in-call actions
        onCall {
            // Example: process call state updates
            callStateFlow.onEach { newState ->
                // handle call state updates and notify telecom
            }.launchIn(this)

            // Use initialized extensions...
        }
    }
}

सहायता टीम के साथ कॉल में शामिल लोग

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

mCallsManager.addCallWithExtensions(...) {
        // Initialize extensions...

        // Notifies Jetpack that this app supports the participant
        // extension and provides the initial participants state in the call.
        val participantExtension = addParticipantExtension(
            initialParticipants,
            initialActiveParticipant
        )

        // After the call has been initialized, perform in-call control actions
        onCall {
            // other in-call control and extension actions...

            // Example: update remote surfaces when the call participants change
            participantsFlow.onEach { newParticipants ->
                participantExtension.updateParticipants(newParticipants)
            }.launchIn(this)
        }
    }

कॉल में शामिल लोगों के बारे में रिमोट डिवाइसों को सूचना देने के साथ-साथ, ParticipantExtension#updateActiveParticipant का इस्तेमाल करके सक्रिय व्यक्ति की जानकारी भी अपडेट की जा सकती है.

इसके अलावा, कॉल में शामिल लोगों से जुड़ी वैकल्पिक कार्रवाइयों के लिए भी सहायता उपलब्ध है. ऐप्लिकेशन, ParticipantExtension#addRaiseHandSupport का इस्तेमाल करके, कॉल में हिस्सा लेने वाले लोगों को हाथ उठाने की सुविधा दे सकता है. साथ ही, यह भी देख सकता है कि किन अन्य लोगों ने हाथ उठाया है.

mCallsManager.addCallWithExtensions(...) {
        // Initialize extensions...

        // Notifies Jetpack that this app supports the participant
        // extension and provides the initial list of participants in the call.
        val participantExtension = addParticipantExtension(initialParticipants)
        // Notifies Jetpack that this app supports the notion of participants
        // being able to raise and lower their hands.
        val raiseHandState = participantExtension.addRaiseHandSupport(
                initialRaisedHands
            ) { onHandRaisedStateChanged ->
                // handle this user's raised hand state changed updates from
                // remote surfaces.
            }

        // After the call has been initialized, perform in-call control actions
        onCall {
            // other in-call control and extension actions...

            // Example: update remote surfaces when the call participants change
            participantsFlow.onEach { newParticipants ->
                participantExtension.updateParticipants(newParticipants)
            }.launchIn(this)
            // notify remote surfaces of which of the participants have their
            // hands raised
            raisedHandsFlow.onEach { newRaisedHands ->
                raiseHandState.updateRaisedHands(newRaisedHands)
            }.launchIn(this)
        }
    }

सहायता टीम से कॉल आने पर साइलेंट मोड चालू करना

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

mCallsManager.addCallWithExtensions(...) {
        // Initialize extensions...

        // Add support for locally silencing the call's outgoing audio and
        // register a handler for when the user changes the call silence state
        // from a remote surface.
        val callSilenceExtension = addLocalCallSilenceExtension(
            initialCallSilenceState = false
        ) { newCallSilenceStateRequest ->
            // handle the user's request to enable/disable call silence from
            // a remote surface
        }

        // After the call has been initialized, perform in-call control actions
        onCall {
            // other in-call control and extension actions...

            // When the call's call silence state changes, update remote
            // surfaces of the new state.
            callSilenceState.onEach { isSilenced ->
                callSilenceExtension.updateIsLocallySilenced(isSilenced)
            }.launchIn(this)
        }
    }

सहायता के लिए कॉल करने के आइकॉन

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

mCallsManager.addCallWithExtensions(...) {
        // Initialize extensions...

        // Add support for a custom call icon to be displayed during the
        // lifetime of the call.
        val callIconExtension = addCallIconExtension(
            initialCallIconUri = initialUri
        )

        // After the call has been initialized, perform in-call control actions
        onCall {
            // other in-call control and extension actions...

            // When the call's icon changes, update remote surfaces by providing
            // the new URI.
            callIconUri.onEach { newIconUri ->
                callIconExtension.updateCallIconUri(newIconUri)
            }.launchIn(this)
        }
    }

सिस्टम कॉल लॉग के साथ इंटिग्रेट करना

Core-Telecom, आपके ऐप्लिकेशन को सिस्टम कॉल लॉग के साथ इंटिग्रेट करने की अनुमति देता है. इस सुविधा की मदद से, VoIP ऐप्लिकेशन का इस्तेमाल करके किए गए या पाए गए कॉल, सिस्टम डायलर के कॉल इतिहास में दिखते हैं. इससे उपयोगकर्ता, डायलर का इस्तेमाल करके कॉल बैक कर सकते हैं.

कॉल लॉग इंटिग्रेशन की सुविधा चालू करना

इस सुविधा को चालू करने के लिए, आपके ऐप्लिकेशन को AndroidManifest.xml में TelecomManager.ACTION_CALL_BACK इंटेंट को हैंडल करने के लिए रजिस्टर करना होगा. साथ ही, कॉलबैक को प्रोसेस करने के लिए Activity देना होगा. उदाहरण के लिए, मान लें कि VoipCallbackActivity वह गतिविधि है जो कॉलबैक को हैंडल करती है. ऐसे में, आपका मेनिफ़ेस्ट ऐसा दिखना चाहिए:

मेनिफ़ेस्ट में इंटेंट रजिस्टर करना

<activity
    android:name=".VoipCallbackActivity"
    android:exported="true">
    <intent-filter>
        <action android:name="android.telecom.action.CALL_BACK" />
    </intent-filter>
</activity>

कॉलबैक इंटेंट को हैंडल करना

जब कोई उपयोगकर्ता सिस्टम डायलर से कॉल बैक शुरू करता है, तो आपकी रजिस्टर की गई गतिविधि, TelecomManager.ACTION_CALL_BACK ऐक्शन के साथ लॉन्च होती है. इस इंटेंट में TelecomManager.EXTRA_UUID शामिल है. यह आपके ऐप्लिकेशन को तब दिया जाता है, जब आपने CallsManager का इस्तेमाल करके कॉल जोड़ा था.

CallControlScope तरीके से, कॉल के लिए यह यूनीक आईडी getCallId मिलता है.

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

class VoipCallbackActivity : Activity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        if (intent?.action == TelecomManager.ACTION_CALL_BACK) {
            val uuidString = intent.getStringExtra(TelecomManager.EXTRA_UUID)
            if (uuidString != null) {
                val uuid = UUID.fromString(uuidString)
                
                // Retrieve your persisted call info using the UUID
                val callData = CallRepository.getCallByUuid(uuid)
                
                if (callData != null) {
                    // Place the call again using your app's logic
                    // ...
                }
            }
        }
        finish()
    }
}

कॉल लॉग इंटिग्रेशन से ऑप्ट-आउट करना

डिफ़ॉल्ट रूप से, कॉल की जानकारी को सिस्टम कॉल लॉग में सेव किया जाता है. इस सुविधा से हर कॉल के हिसाब से ऑप्ट-आउट किया जा सकता है. इसके लिए, CallAttributesCompat बनाते समय isLogged पैरामीटर को false पर सेट करें:

val callAttributes = CallAttributesCompat(
    displayName = callerName,
    address = addressUri,
    direction = CallAttributesCompat.DIRECTION_OUTGOING,
    isLogExcluded = true // Opt-out of system call logging
)