Integrar com o CallKit

Neste documento, veremos como integrar o CallKit ao seu aplicativo iOS.

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• Um recurso dos Serviços de Comunicação implantado. Crie um recurso dos Serviços de Comunicação.
• Um token de acesso de usuário para habilitar o cliente de chamada. Para saber mais, confira Criar e gerenciar token de acesso.
• Opcional: conclua o início rápido para adicionar chamada de voz ao seu aplicativo

Integração do CallKit (no SDK)

A integração do CallKit no SDK do iOS dos Serviços de Comunicação do Azure gerencia a interação com o CallKit para nós. Para executar quaisquer operações de chamada, como mudo/desativação, retenção/retomada, só precisamos chamar a API no SDK dos Serviços de Comunicação do Azure.

Inicializar o agente de chamada com CallKitOptions

Com a instância configurada de CallKitOptions, podemos criar CallAgent com tratamento de CallKit.

let options = CallAgentOptions()
let callKitOptions = CallKitOptions(with: createProviderConfig())
options.callKitOptions = callKitOptions

// Configure the properties of `CallKitOptions` instance here

self.callClient!.createCallAgent(userCredential: userCredential,
    options: options,
    completionHandler: { (callAgent, error) in
    // Initialization
})

Especificar informações do destinatário da chamada para chamadas de saída

Primeiro, precisamos criar uma instância de StartCallOptions() para chamadas de saída ou de JoinCallOptions() para chamadas em grupo.

let options = StartCallOptions()

or

let options = JoinCallOptions()

Em seguida, crie uma instância de CallKitRemoteInfo

options.callKitRemoteInfo = CallKitRemoteInfo()

1. Atribua um valor a callKitRemoteInfo.displayNameForCallKit para personalizar o nome exibido aos destinatários de chamada e configurar o valor de CXHandle. O valor especificado em displayNameForCallKit é exatamente como aparece no log de chamada mais recente. no log de chamada mais recente.

options.callKitRemoteInfo.displayNameForCallKit = "DISPLAY_NAME"

2. A atribuição do valor cxHandle é o que o aplicativo recebe quando o usuário retorna a chamada para esse contato

options.callKitRemoteInfo.cxHandle = CXHandle(type: .generic, value: "VALUE_TO_CXHANDLE")

Especificar informações do destinatário da chamada para chamadas de entrada

Primeiro, precisamos criar uma instância de CallKitOptions:

let callKitOptions = CallKitOptions(with: createProviderConfig())

Configurar as propriedades da instância CallKitOptions:

O bloco passado para a variável provideRemoteInfo será chamado pelo SDK quando recebermos uma chamada de entrada e precisarmos obter um nome de exibição para o chamador de entrada, que precisamos passar para o CallKit.

callKitOptions.provideRemoteInfo = self.provideCallKitRemoteInfo

func provideCallKitRemoteInfo(callerInfo: CallerInfo) -> CallKitRemoteInfo
{
    let callKitRemoteInfo = CallKitRemoteInfo()
    callKitRemoteInfo.displayName = "CALL_TO_PHONENUMBER_BY_APP"      
    callKitRemoteInfo.cxHandle = CXHandle(type: .generic, value: "VALUE_TO_CXHANDLE")
    return callKitRemoteInfo
}

Configurar sessão de áudio

Configurar a sessão de áudio será chamado antes de fazer ou aceitar uma chamada de entrada e antes de retomar a chamada após ela ter sido colocada em espera.

callKitOptions.configureAudioSession = self.configureAudioSession

public func configureAudioSession() -> Error? {
    let audioSession: AVAudioSession = AVAudioSession.sharedInstance()
    var configError: Error?
    do {
        try audioSession.setCategory(.playAndRecord)
    } catch {
        configError = error
    }
    return configError
}

Observação: nos casos em que a Contoso já tiver configurado sessões de áudio, NÃO forneça nil, mas retorne o erro nil no bloco

callKitOptions.configureAudioSession = self.configureAudioSession

public func configureAudioSession() -> Error? {
    return nil
}

Se nil for fornecido para configureAudioSession, o SDK chamará a implementação padrão no SDK.

Manipular o payload da notificação por push recebida

Quando o aplicativo recebe o payload de notificação por push de entrada, é necessário chamar handlePush para processá-lo. O SDK de Chamadas dos Serviços de Comunicação do Azure gerará o evento IncomingCall.

public func handlePushNotification(_ pushPayload: PKPushPayload)
{
    let callNotification = PushNotificationInfo.fromDictionary(pushPayload.dictionaryPayload)
    if let agent = self.callAgent {
        agent.handlePush(notification: callNotification) { (error) in }
    }
}

// Event raised by the SDK
public func callAgent(_ callAgent: CallAgent, didReceiveIncomingCall incomingcall: IncomingCall) {
}

Podemos usar reportIncomingCall para lidar com notificações por push quando o aplicativo é fechado ou não.

if let agent = self.callAgent {
  /* App is not in a killed state */
  agent.handlePush(notification: callNotification) { (error) in }
} else {
  /* App is in a killed state */
  CallClient.reportIncomingCall(with: callNotification, callKitOptions: callKitOptions) { (error) in
      if (error == nil) {
          DispatchQueue.global().async {
              self.callClient = CallClient()
              let options = CallAgentOptions()
              let callKitOptions = CallKitOptions(with: createProviderConfig())
              callKitOptions.provideRemoteInfo = self.provideCallKitRemoteInfo
              callKitOptions.configureAudioSession = self.configureAudioSession
              options.callKitOptions = callKitOptions
              self.callClient!.createCallAgent(userCredential: userCredential,
                  options: options,
                  completionHandler: { (callAgent, error) in
                  if (error == nil) {
                      self.callAgent = callAgent
                      self.callAgent!.handlePush(notification: callNotification) { (error) in }
                  }
              })
          }
      } else {
          os_log("SDK couldn't handle push notification", log:self.log)
      }
  }
}

Integração do CallKit (no aplicativo)

Se você quiser integrar o CallKit no aplicativo e não usar a implementação do CallKit no SDK, consulte o exemplo de início rápido aqui. Mas uma das coisas importantes a cuidar é iniciar o áudio no momento certo. Como a seguir

let outgoingAudioOptions = OutgoingAudioOptions()
outgoingAudioOptions.muted = true

let incomingAudioOptions = IncomingAudioOptions()
incomingAudioOptions.muted = true

var copyAcceptCallOptions = AcceptCallOptions()
copyStartCallOptions.outgoingAudioOptions = outgoingAudioOptions
copyStartCallOptions.incomingAudioOptions = incomingAudioOptions

callAgent.startCall(participants: participants,
                    options: copyStartCallOptions,
                    completionHandler: completionBlock)

Silenciar o alto-falante e o microfone garante que os dispositivos de áudio físicos não sejam usados até que o CallKit chame didActivateAudioSession em CXProviderDelegate. Caso contrário, a chamada poderá ser descartada ou o áudio não funcionará. Quando didActivateAudioSession é quando os fluxos de áudio devem ser iniciados.

func provider(_ provider: CXProvider, didActivate audioSession: AVAudioSession) {
    Task {
        guard let activeCall = await self.callKitHelper.getActiveCall() else {
            print("No active calls found when activating audio session !!")
            return
        }

        try await startAudio(call: activeCall)
    }
}

func provider(_ provider: CXProvider, didDeactivate audioSession: AVAudioSession) {
    Task {
        guard let activeCall = await self.callKitHelper.getActiveCall() else {
            print("No active calls found when deactivating audio session !!")
            return
        }

        try await stopAudio(call: activeCall)
    }
}

private func stopAudio(call: Call) async throws {
    try await self.callKitHelper.muteCall(callId: call.id, isMuted: true)
    try await call.stopAudio(stream: call.activeOutgoingAudioStream)

    try await call.stopAudio(stream: call.activeIncomingAudioStream)
    try await call.muteIncomingAudio()
}

private func startAudio(call: Call) async throws {
    try await call.startAudio(stream: LocalOutgoingAudioStream())
    try await self.callKitHelper.muteCall(callId: call.id, isMuted: false)

    try await call.startAudio(stream: RemoteIncomingAudioStream())
    try await call.unmuteIncomingAudio()
}
    

É importante também ativar o mudo do áudio de saída antes de interromper o áudio em casos em que o CallKit não invoca didActivateAudioSession. Em seguida, o usuário pode desativar manualmente o microfone.

Próximas etapas

• Saiba como gerenciar vídeo
• Saiba como gerenciar chamadas
• Saiba como gravar chamadas