android - सकत - सम्मेलन कॉल




एंड्रॉइड में आउटगोइंग कॉल कैसे लटकाएं? (6)

  1. 0 की प्राथमिकता के साथ BroadcastReceiver बनाएं।
  2. बीसी में ACTION_NEW_OUTGOING_CALL अपनी onReceive विधि में इरादा onReceive है
  3. उसी विधि में setResultData(null) को कॉल करें

यह कॉल को शुरू करने से रोक देगा (जब तक आपका रिसीवर मुझे लगता है कि इरादे को संसाधित करने वाला आखिरी है)

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

मैंने किसी मौजूदा गतिविधि से Intent.ACTION_CALL का उपयोग करने का प्रयास किया है:

Intent callIntent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + phoneNumber)); 
startActivity(callIntent); 

लेकिन एपीआई के माध्यम से कॉल को रोकना प्रतीत होता है।

क्या आप कुछ कामकाज सुझा सकते हैं?

उदाहरण के लिए: कॉल के दौरान हवाई जहाज मोड सक्षम करना? बस एक उदाहरण; यह हैक मेरे लिए काम नहीं किया।


ACTION_NEW_OUTGOING_CALL पर दस्तावेज़ के अनुसार

इरादे में निम्नलिखित अतिरिक्त मूल्य होगा:

EXTRA_PHONE_NUMBER - मूल रूप से डायल किए जाने वाले फ़ोन नंबर का फ़ोन नंबर।

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


आप विमान मोड को अक्षम करने के बाद सक्षम करने का प्रयास कर सकते हैं:

android.provider.Settings.System.putInt(getContentResolver(),
        android.provider.Settings.System.AIRPLANE_MODE_ON, 1);

Intent intent = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED);
intent.putExtra("state", 1);
sendBroadcast(new Intent("android.intent.action.AIRPLANE_MODE"));
sendBroadcast(intent);
android.provider.Settings.System.putInt(getContentResolver(),
        android.provider.Settings.System.AIRPLANE_MODE_ON, 0);

intent.putExtra("state", 0);
sendBroadcast(new Intent("android.intent.action.AIRPLANE_MODE"));
sendBroadcast(intent);

इलाना के लिए:

public class ilanasReceiver extends BroadcastReceiver {
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals(Intent.ACTION_NEW_OUTGOING_CALL)) {
            if (getResultData()!=null) {
                String number = "123456";
                setResultData(number);
            }
        }
    }
}

मैनिफेस्ट में पैकेज अनुभाग में डाल दिया गया है:

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

बस इतना ही।


यहां सबसे अद्यतन कोड है, जो एंड्रॉइड पी के लिए भी काम करेगा, क्योंकि इसमें इसके लिए एक आधिकारिक एपीआई है (यहां):

मैनिफेस्ट में, इसे जोड़ें:

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

कोड में, इसका उपयोग करें:

जावा:

@SuppressLint("PrivateApi")
public static boolean endCall(Context context) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
        final TelecomManager telecomManager = (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE);
        if (telecomManager != null && ContextCompat.checkSelfPermission(context, Manifest.permission.ANSWER_PHONE_CALLS) == PackageManager.PERMISSION_GRANTED) {
            telecomManager.endCall();
            return true;
        }
        return false;
    }
    //use unofficial API for older Android versions, as written here: https://.com/a/8380418/878126
    try {
        final Class<?> telephonyClass = Class.forName("com.android.internal.telephony.ITelephony");
        final Class<?> telephonyStubClass = telephonyClass.getClasses()[0];
        final Class<?> serviceManagerClass = Class.forName("android.os.ServiceManager");
        final Class<?> serviceManagerNativeClass = Class.forName("android.os.ServiceManagerNative");
        final Method getService = serviceManagerClass.getMethod("getService", String.class);
        final Method tempInterfaceMethod = serviceManagerNativeClass.getMethod("asInterface", IBinder.class);
        final Binder tmpBinder = new Binder();
        tmpBinder.attachInterface(null, "fake");
        final Object serviceManagerObject = tempInterfaceMethod.invoke(null, tmpBinder);
        final IBinder retbinder = (IBinder) getService.invoke(serviceManagerObject, "phone");
        final Method serviceMethod = telephonyStubClass.getMethod("asInterface", IBinder.class);
        final Object telephonyObject = serviceMethod.invoke(null, retbinder);
        final Method telephonyEndCall = telephonyClass.getMethod("endCall");
        telephonyEndCall.invoke(telephonyObject);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        LogManager.e(e);
    }
    return false;
}

या कोटलिन में:

@SuppressLint("PrivateApi")
fun endCall(context: Context): Boolean {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
        val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
        if (ContextCompat.checkSelfPermission(context, Manifest.permission.ANSWER_PHONE_CALLS) == PackageManager.PERMISSION_GRANTED) {
            telecomManager.endCall()
            return true
        }
        return false
    }
    //use unofficial API for older Android versions, as written here: https://.com/a/8380418/878126
    try {
        val telephonyClass = Class.forName("com.android.internal.telephony.ITelephony")
        val telephonyStubClass = telephonyClass.classes[0]
        val serviceManagerClass = Class.forName("android.os.ServiceManager")
        val serviceManagerNativeClass = Class.forName("android.os.ServiceManagerNative")
        val getService = serviceManagerClass.getMethod("getService", String::class.java)
        val tempInterfaceMethod = serviceManagerNativeClass.getMethod("asInterface", IBinder::class.java)
        val tmpBinder = Binder()
        tmpBinder.attachInterface(null, "fake")
        val serviceManagerObject = tempInterfaceMethod.invoke(null, tmpBinder)
        val retbinder = getService.invoke(serviceManagerObject, "phone") as IBinder
        val serviceMethod = telephonyStubClass.getMethod("asInterface", IBinder::class.java)
        val telephonyObject = serviceMethod.invoke(null, retbinder)
        val telephonyEndCall = telephonyClass.getMethod("endCall")
        telephonyEndCall.invoke(telephonyObject)
        return true
    } catch (e: Exception) {
        e.printStackTrace()
        return false
    }
}

BroadcastReceiver रिसीवर में आउटगोइंग कॉल को कैप्चर करना का उल्लेख किया गया है और यदि आप डायलिंग से पहले कॉल समाप्त करना चाहते हैं तो यह निश्चित रूप से करने का सबसे अच्छा तरीका है।

एक बार डायलिंग या इन-कॉल करने के बाद, वह तकनीक अब काम नहीं करती है। अब तक का सामना करने का एकमात्र तरीका जावा Reflection माध्यम से ऐसा करना है। चूंकि यह सार्वजनिक एपीआई का हिस्सा नहीं है, इसलिए आपको इसका उपयोग करने के लिए सावधान रहना चाहिए , और उस पर भरोसा नहीं करना चाहिए। एंड्रॉइड की आंतरिक संरचना में कोई भी बदलाव प्रभावी ढंग से आपके आवेदन को तोड़ देगा।

प्रसंता पॉल का ब्लॉग दिखाता है कि यह कैसे पूरा किया जा सकता है, जिसे मैंने नीचे संक्षेप में बताया है।

ITelephony ऑब्जेक्ट प्राप्त करना:

TelephonyManager tm = (TelephonyManager) context
        .getSystemService(Context.TELEPHONY_SERVICE);
try {
    // Java reflection to gain access to TelephonyManager's
    // ITelephony getter
    Log.v(TAG, "Get getTeleService...");
    Class c = Class.forName(tm.getClass().getName());
    Method m = c.getDeclaredMethod("getITelephony");
    m.setAccessible(true);
    com.android.internal.telephony.ITelephony telephonyService =
            (ITelephony) m.invoke(tm);
} catch (Exception e) {
    e.printStackTrace();
    Log.e(TAG,
            "FATAL ERROR: could not connect to telephony subsystem");
    Log.e(TAG, "Exception object: " + e);
}

कॉल समाप्त करना:

telephonyService.endCall();




telephonymanager