So erkennen Sie eingehende Anrufe programmgesteuert

Question

Ich brauche meine App, um eine Benachrichtigung zu senden, wenn es einen Anruf gibt (eingehender Anruf, verbunden, Anruf beendet) Ich registrierte meine ViewController mit Benachrichtigung.

[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(callReceived:) name:CTCallStateIncoming object:nil]; 
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(callEnded:) name:CTCallStateDisconnected object:nil]; 
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(callConnected:) name:CTCallStateConnected object:nil]; 

Ich habe auch eine Methode aufrufen

-(IBAction)checkForCall:(id)sender{ 
    NSLog(@"call state %@ id %@",call.callState,call.callID); 
    CTCallCenter *callCenter = [[CTCallCenter alloc] init]; 
    callCenter.callEventHandler = ^(CTCall* call){ 
     if (call.callState == CTCallStateDisconnected) 
     { 
      NSLog(@"Call has been disconnected"); 

     } 
     else if (call.callState == CTCallStateConnected) 
     { 
      NSLog(@"Call has just been connected"); 

     } 
     else if(call.callState == CTCallStateIncoming) 
     { 
      NSLog(@"Call is incoming"); 

     } 
     else 
     { 
      NSLog(@"None of the conditions"); 
     } 
    }; 
} 

Aber keines dieser Zustand arbeitet zu überprüfen. Bitte hilf mir.

Wo ist der Fehler? Gibt es einen Code, der sagt, wie Core-Telefonie zu verwenden ist?

Answer 1

Dies sind die Statusnamen, nicht die Benachrichtigungsnamen. Sie müssen callEventHandler einrichten und den Status dort überprüfen.

Answer 2

Verwendung dieses

Appdelegate.h

#import <CoreTelephony/CTCallCenter.h> 
#import <CoreTelephony/CTCall.h> 
... 
@property (nonatomic, strong) CTCallCenter* callCenter; 

AppDelegate.m

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions 
{ 
    .... 
    self.callCenter = [[CTCallCenter alloc] init]; 
    [self handleCall]; 
    .... 
} 

-(void)handleCall 
{ 
    self.callCenter.callEventHandler = ^(CTCall *call){ 

     if ([call.callState isEqualToString: CTCallStateConnected]) 
     { 
      //NSLog(@"call stopped"); 
     } 
     else if ([call.callState isEqualToString: CTCallStateDialing]) 
     { 
     } 
     else if ([call.callState isEqualToString: CTCallStateDisconnected]) 
     { 
      //NSLog(@"call played"); 
     } 
     else if ([call.callState isEqualToString: CTCallStateIncoming]) 
     { 
      //NSLog(@"call stopped"); 
     } 
    }; 
    } 

Answer 3

In Swift 3 

Verwenden CXCallObserver

import CallKit 

var callObserver = CXCallObserver() 

class AppDelegate: UIResponder, UIApplicationDelegate, CXCallObserverDelegate { 

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool { 

callObserver.setDelegate(self, queue: nil) //Set delegate to self to call delegate method. 

return true 

} 

func callObserver(_ callObserver: CXCallObserver, callChanged call: CXCall) { 

    if call.hasConnected { 
     Print("Call Connect -> \(call.uuid)") 
    } 

    if call.isOutgoing { 
     Print("Call outGoing \(call.uuid)") 
    } 

    if call.hasEnded { 
     Print("Call hasEnded \(call.uuid)") 
    } 

    if call.isOnHold { 
     Print("Call onHold \(call.uuid)") 
     } 
    } 
} 

Answer 4

für iOS 10 und schnelle 3:

a) Kopie und fügen Sie in einem neuen leeren Controller in einem neuen Projekt b) ausführt, wird asyncAfter einen Anruf auslösen ... HINWEIS: funktioniert nur auf dem Gerät.

// only for iOS10 

import UIKit 
import CoreTelephony 
import CallKit 

class ViewController: UIViewController, CXCallObserverDelegate { 
    var callCenter : CTCallCenter? 
    var observer : CXCallObserver? 

    override func viewDidLoad() { 
     super.viewDidLoad() 

     setup() 

     let delay = 2.0 
     let when = DispatchTime.now() + delay 
     DispatchQueue.main.asyncAfter(deadline: when, execute: {() -> Void in 
      self.makeCall() 
     }) 
    } 

    final func setup() { 

     let networkInfo = CTTelephonyNetworkInfo() 
     let code = networkInfo.subscriberCellularProvider?.mobileCountryCode 
     print("\(code)") 

     self.observer = CXCallObserver() 
     self.observer?.setDelegate(self, queue: nil) 

     self.callCenter = CTCallCenter() 
    } 

    final func makeCall() { 

     guard let url = URL(string: "telprompt://55555") else { 
      print("illegal URL") 
      return 
     } 

     guard UIApplication.shared.canOpenURL(url) else{ 
      print("cannot open url") 
      return 
     } 

     // iso9.. UIApplication.shared.openURL(url) 

     UIApplication.shared.open(url, options: [:], completionHandler: { (Bool) in 

     }) 
    } 

    public func callObserver(_ callObserver: CXCallObserver, callChanged call: CXCall){ 

     print("isOutgoing = \(call.isOutgoing)") 
     print("hasConnected = \(call.hasConnected)") 
     print("hasEnded = \(call.hasEnded)") 
    } 
}