Habilitar as notificações por push

Siga o início rápido

As notificações push da Web por meio do SDK de Chamada Web dos Serviços de Comunicação do Azure estão em prévia e disponíveis a partir da versão 1.12.0-beta.2+.

Para obter instruções passo a passo, confira o início rápido no GitHub.

• Uma conta do Firebase com o FCM (Firebase Cloud Messaging) habilitado e com o serviço FCM conectado a uma instância dos Hubs de Notificação do Azure. Para obter mais informações, consulte Notificações dos Serviços de Comunicação.

• O Android Studio versão 3.6 ou posterior para compilar o seu aplicativo.

• Um conjunto de permissões para habilitar o aplicativo Android a receber mensagens de notificação do FCM. No arquivo AndroidManifest.xml, adicione o seguinte conjunto de permissões logo após <manifest ...> ou abaixo da marca </application>:

  <uses-permission android:name="android.permission.INTERNET"/>
  <uses-permission android:name="android.permission.GET_ACCOUNTS"/>
  <uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
  

Considerações sobre notificações por push móveis

As notificações por push móveis são as notificações pop-up que aparecem em dispositivos móveis. Para chamadas, este artigo foca nas notificações por push de voz sobre Protocolo de Internet (VoIP).

Instalar o SDK

Localize o arquivo build.gradle de nível do projeto e adicione mavenCentral() à lista de repositórios em buildscript e allprojects:

buildscript {
    repositories {
    ...
        mavenCentral()
    ...
    }
}

allprojects {
    repositories {
    ...
        mavenCentral()
    ...
    }
}

Em seguida, no arquivo build.gradle no nível do módulo, adicione as seguintes linhas à seção dependencies:

dependencies {
    ...
    implementation 'com.azure.android:azure-communication-calling:1.0.0'
    ...
}

Inicializar objetos necessários

Para criar uma instância CallAgent, você precisa chamar o método createCallAgent em uma instância CallClient. Essa chamada retorna de forma assíncrona um objeto de instância CallAgent.

O método createCallAgent usa CommunicationUserCredential como argumento, que encapsula um token de acesso.

Para acessar DeviceManager, você deverá criar uma instância callAgent primeiro. Em seguida, você poderá usar o método CallClient.getDeviceManager para obter DeviceManager.

String userToken = '<user token>';
CallClient callClient = new CallClient();
CommunicationTokenCredential tokenCredential = new CommunicationTokenCredential(userToken);
android.content.Context appContext = this.getApplicationContext(); // From within an activity, for instance
CallAgent callAgent = callClient.createCallAgent(appContext, tokenCredential).get();
DeviceManager deviceManager = callClient.getDeviceManager(appContext).get();

Para definir um nome de exibição para o chamador, use este método alternativo:

String userToken = '<user token>';
CallClient callClient = new CallClient();
CommunicationTokenCredential tokenCredential = new CommunicationTokenCredential(userToken);
android.content.Context appContext = this.getApplicationContext(); // From within an activity, for instance
CallAgentOptions callAgentOptions = new CallAgentOptions();
callAgentOptions.setDisplayName("Alice Bob");
DeviceManager deviceManager = callClient.getDeviceManager(appContext).get();
CallAgent callAgent = callClient.createCallAgent(appContext, tokenCredential, callAgentOptions).get();

Registrar notificações por push

Para se registrar para notificações por push, o aplicativo precisa chamar registerPushNotification() em uma instância CallAgent com um token de registro de dispositivo.

Para obter o token de registro do dispositivo, adicione o SDK do Firebase ao arquivo build.gradle do módulo de aplicativo, adicionando as seguintes linhas na seção dependencies se elas ainda não estiverem lá:

// Add the SDK for Firebase Cloud Messaging
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:20.2.4'

No arquivo build.gradle do nível do projeto, adicione a seguinte linha na seção dependencies, caso ela ainda não tenha sido adicionada:

classpath 'com.google.gms:google-services:4.3.3'

Adicione o seguinte plug-in ao início do arquivo, caso ele ainda não tenha sido adicionado:

apply plugin: 'com.google.gms.google-services'

Na barra de ferramentas, selecione Sincronizar Agora. Adicione o snippet de código a seguir para obter o token de registro do dispositivo que o SDK do Firebase Cloud Messaging gerou para a instância do aplicativo cliente. Certifique-se de adicionar as seguintes importações ao cabeçalho da atividade principal, para que a instância possa recuperar o token.

import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.iid.FirebaseInstanceId;
import com.google.firebase.iid.InstanceIdResult;

Adicione esse snippet para recuperar o token:

FirebaseInstanceId.getInstance().getInstanceId()
    .addOnCompleteListener(new OnCompleteListener<InstanceIdResult>() {
        @Override
        public void onComplete(@NonNull Task<InstanceIdResult> task) {
            if (!task.isSuccessful()) {
                Log.w("PushNotification", "getInstanceId failed", task.getException());
                return;
            }

            // Get the new instance ID token
            String deviceToken = task.getResult().getToken();
            // Log
            Log.d("PushNotification", "Device Registration token retrieved successfully");
        }
    });

Registre o token de registro de dispositivo com o SDK dos Serviços de Chamada para obter notificações por push da chamada de entrada:

String deviceRegistrationToken = "<Device Token from previous section>";
try {
    callAgent.registerPushNotification(deviceRegistrationToken).get();
}
catch(Exception e) {
    System.out.println("Something went wrong while registering for Incoming Calls Push Notifications.")
}

Gerenciar as notificações push

Para receber notificações por push de chamada de entrada, chame handlePushNotification() em uma instância CallAgent com um conteúdo.

Para obter o conteúdo do Firebase Cloud Messaging, comece criando um serviço (selecione Arquivo>Novo>Serviço>Serviço) que estende a classe do SDK do Firebase FirebaseMessagingService e substitui o método onMessageReceived. Esse método é o manipulador de eventos chamado quando o Firebase Cloud Messaging entrega a notificação por push ao aplicativo.

public class MyFirebaseMessagingService extends FirebaseMessagingService {
    private java.util.Map<String, String> pushNotificationMessageDataFromFCM;

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        // Check if the message contains a notification payload.
        if (remoteMessage.getNotification() != null) {
            Log.d("PushNotification", "Message Notification Body: " + remoteMessage.getNotification().getBody());
        }
        else {
            pushNotificationMessageDataFromFCM = remoteMessage.getData();
        }
    }
}

Adicione a seguinte definição de serviço ao arquivo AndroidManifest.xml, dentro da marca <application>:

<service
    android:name=".MyFirebaseMessagingService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>

Depois de recuperar o conteúdo, você pode passá-lo para o SDK dos Serviços de Comunicação para ser analisado em um objeto interno IncomingCallInformation. Esse objeto manipula a chamada do método handlePushNotification em uma instância de CallAgent. Você cria uma instância de CallAgent chamando o método createCallAgent(...) na classe CallClient.

try {
    IncomingCallInformation notification = IncomingCallInformation.fromMap(pushNotificationMessageDataFromFCM);
    Future handlePushNotificationFuture = callAgent.handlePushNotification(notification).get();
}
catch(Exception e) {
    System.out.println("Something went wrong while handling the Incoming Calls Push Notifications.");
}

Quando a administração de mensagens de notificação por push for bem-sucedida e os todos os manipuladores de eventos forem registrados corretamente, o aplicativo tocará.

Cancelar o registro de notificações por push

Os aplicativos podem cancelar o registro de notificações por push a qualquer momento. Para cancelar o registro, chame o método unregisterPushNotification() em callAgent:

try {
    callAgent.unregisterPushNotification().get();
}
catch(Exception e) {
    System.out.println("Something went wrong while un-registering for all Incoming Calls Push Notifications.")
}

Desabilitar notificações por push internas para uma chamada de entrada

O conteúdo por push de uma chamada de entrada pode ser entregue ao destinatário da chamada de duas maneiras:

• Usando FCM e registrando o token de dispositivo com a API mencionada anteriormente, registerPushNotification em CallAgent ou TeamsCallAgent
• Registrando o SDK com um serviço interno após a criação de CallAgent ou TeamsCallAgent para fazer com que o conteúdo por push seja entregue

Usando a propriedade setDisableInternalPushForIncomingCall em CallAgentOptions ou TeamsCallAgentOptions, é possível instruir o SDK a desabilitar a entrega do conteúdo por push usando o serviço de push interno:

CallAgentOptions callAgentOptions = new CallAgentOptions();
callAgentOptions.setDisableInternalPushForIncomingCall(true);

Implementar notificações por push móveis do iOS

As notificações por push móveis são as notificações pop-up que aparecem em dispositivos móveis. Para chamadas, este artigo foca nas notificações por push de voz sobre Protocolo de Internet (VoIP). Para obter um guia sobre a integração do CallKit em seu aplicativo iOS, confira Integrar com o CallKit.

Configurar o seu sistema

Siga essas etapas para configurar seu sistema.

Criar o projeto do Xcode

No Xcode, crie um projeto do iOS e selecione o modelo Aplicativo de Modo de Exibição Único. Como este artigo usa a estrutura SwiftUI, defina Linguagem como Swift e Interface como SwiftUI.

Você não criará testes neste artigo. Fique à vontade para limpar a caixa de seleção Incluir Testes.

Instalar o pacote e as dependências usando o CocoaPods

1. Crie um Podfile para seu aplicativo, como este exemplo:

   platform :ios, '13.0'
   use_frameworks!
   target 'AzureCommunicationCallingSample' do
       pod 'AzureCommunicationCalling', '~> 1.0.0'
   end
   

2. Execute pod install.

3. Abra o .xcworkspace usando o Xcode.

Solicitar acesso ao microfone

Para acessar o microfone do dispositivo, você precisa atualizar a lista de propriedades de informações do aplicativo usando NSMicrophoneUsageDescription. Defina o valor associado como uma cadeia de caracteres incluída na caixa de diálogo que é usada pelo sistema para solicitar o acesso do usuário.

Clique com o botão direito do mouse na entrada Info.plist da árvore de projeto e selecione Abrir Como>Código-Fonte. Adicione as linhas a seguir na seção do nível superior<dict>e, em seguida, salve o arquivo.

<key>NSMicrophoneUsageDescription</key>
<string>Need microphone access for VOIP calling.</string>

Configurar o framework de aplicativos

Abra o arquivo ContentView.swift do projeto. Adicione uma declaração import à parte superior do arquivo para importar a biblioteca AzureCommunicationCalling. Além disso, importe AVFoundation. Você precisa dele para solicitações de permissão de áudio no código.

import AzureCommunicationCalling
import AVFoundation

Inicialização do CallAgent

Para criar uma instância CallAgent a partir de CallClient, você precisa usar o método callClient.createCallAgent que retorna de forma assíncrona um objeto CallAgent após sua inicialização.

Para criar um cliente de chamada, passe um objeto CommunicationTokenCredential:

import AzureCommunication

let tokenString = "token_string"
var userCredential: CommunicationTokenCredential?
do {
    let options = CommunicationTokenRefreshOptions(initialToken: token, refreshProactively: true, tokenRefresher: self.fetchTokenSync)
    userCredential = try CommunicationTokenCredential(withOptions: options)
} catch {
    updates("Couldn't created Credential object", false)
    initializationDispatchGroup!.leave()
    return
}

// tokenProvider needs to be implemented by Contoso, which fetches a new token
public func fetchTokenSync(then onCompletion: TokenRefreshOnCompletion) {
    let newToken = self.tokenProvider!.fetchNewToken()
    onCompletion(newToken, nil)
}

Passe o objeto CommunicationTokenCredential que você criou para CallClient e defina o nome de exibição:

self.callClient = CallClient()
let callAgentOptions = CallAgentOptions()
options.displayName = " iOS Azure Communication Services User"

self.callClient!.createCallAgent(userCredential: userCredential!,
    options: callAgentOptions) { (callAgent, error) in
        if error == nil {
            print("Create agent succeeded")
            self.callAgent = callAgent
        } else {
            print("Create agent failed")
        }
})

Configurar notificações por push

Antes de iniciar as tarefas de registro, tratamento e cancelamento do registro de notificações por push, conclua esta tarefa de instalação:

1. Em Xcode, vá paraAssinatura e Funcionalidades. Adicione uma funcionalidade selecionando+ funcionalidadee,em seguida, selecioneNotificações por Push.
2. Adicione outra funcionalidade selecionando+ funcionalidadee, em seguida, selecioneModos de Segundo Plano.
3. Em Modos de Segundo Plano, selecione as caixas de seleção Voz sobre IP e Notificações Remotas.

Registrar notificações por push

Para registrar notificações por push, chame registerPushNotification() em uma instância de CallAgent usando um token de registro de dispositivo.

O registro das notificações por push precisa acontecer após a inicialização bem-sucedida. Quando o objeto callAgent for destruído, logoutserá chamado, o que cancelará automaticamente o registro das notificações por push.

let deviceToken: Data = pushRegistry?.pushToken(for: PKPushType.voIP)
callAgent.registerPushNotifications(deviceToken: deviceToken!) { (error) in
    if(error == nil) {
        print("Successfully registered to push notification.")
    } else {
        print("Failed to register push notification.")
    }
}

Gerenciar as notificações push

Para receber notificações de chamadas recebidas por push, chame handlePushNotification() em uma instância de CallAgent com um conteúdo de dicionário:

let callNotification = PushNotificationInfo.fromDictionary(pushPayload.dictionaryPayload)

callAgent.handlePush(notification: callNotification) { (error) in
    if (error == nil) {
        print("Handling of push notification was successful")
    } else {
        print("Handling of push notification failed")
    }
}

Cancelar o registro de notificações por push

Os aplicativos podem cancelar o registro de notificações por push a qualquer momento. Para cancelar o registro, chame o método unregisterPushNotification em CallAgent.

callAgent.unregisterPushNotification { (error) in
    if (error == nil) {
        print("Unregister of push notification was successful")
    } else {
       print("Unregister of push notification failed, please try again")
    }
}

Desabilitar notificações por push internas para uma chamada de entrada

O conteúdo por push de uma chamada de entrada pode ser entregue ao destinatário da chamada de duas maneiras:

• Usando o APNS (Serviço de Notificação por Push) da Apple e registrando o token de dispositivo com a API mencionada anteriormente, registerPushNotification em CallAgent ou TeamsCallAgent
• Registrando o SDK com um serviço interno após a criação de CallAgent ou TeamsCallAgent para fazer com que o conteúdo por push seja entregue

Usando a propriedade disableInternalPushForIncomingCall em CallAgentOptions ou TeamsCallAgentOptions, você pode instruir o SDK a desabilitar a entrega do conteúdo por push por meio do serviço de push interno:

let options = CallAgentOptions()
options.disableInternalPushForIncomingCall = true

Implementar notificações por push do Windows

As notificações por push móveis são as notificações pop-up que aparecem em dispositivos móveis. Para chamadas, este artigo foca nas notificações por push de voz sobre Protocolo de Internet (VoIP).

As notificações por push na plataforma Windows são entregues por meio do WNS (Serviço de Notificação por Push do Windows).

Configurar o seu sistema

Siga essas etapas para configurar seu sistema.

Criar o projeto do Visual Studio

Para um aplicativo da Plataforma Universal do Windows, no Visual Studio 2022, crie um projeto Aplicativo em Branco (Universal do Windows). Depois de inserir o nome do projeto, fique à vontade para escolher qualquer SDK do Windows posterior a 10.0.17763.0.

Para um aplicativo do WinUI 3, crie um projeto com o modelo Aplicativo em Branco, Empacotado (WinUI 3 na Área de Trabalho) para configurar um aplicativo do WinUI 3 de página única. O SDK do Aplicativo do Windows versão 1.3 ou posterior é necessário.

Instalar o pacote e as dependências usando o Gerenciador de Pacotes do NuGet

As bibliotecas e as APIs do SDK de Chamada estão disponíveis publicamente por meio de um pacote NuGet.

Para localizar, baixar e instalar o pacote NuGet do SDK de chamadas, siga estas etapas:

1. Abra o Gerenciador de Pacotes do NuGet selecionando Ferramentas>Gerenciador de Pacotes do NuGet>Gerenciar de Pacotes do NuGet para Solução.
2. Selecione Procurar e insira Azure.Communication.Calling.WindowsClient na caixa de pesquisa.
3. Verifique se a caixa de seleção Incluir pré-lançamento está marcada.
4. Selecione o pacote Azure.Communication.Calling.WindowsClient e, em seguida, selecione Azure.Communication.Calling.WindowsClient1.4.0-beta.1 ou uma versão mais recente.
5. Marque a caixa de seleção que corresponde ao projeto dos Serviços de Comunicação do Azure no painel direito.
6. Selecione Instalar.

Configurar notificações por push

Antes de iniciar as tarefas de registro, manipulação e exibição de uma notificação do Windows para responder ou recusar uma chamada de entrada, conclua esta tarefa de instalação:

1. Siga o Tutorial : Enviar notificações para aplicativos da Plataforma Universal do Windows usando Hubs de Notificação do Azure. Depois de seguir o tutorial, você terá:

   • Um aplicativo que tem os pacotesWindowsAzure.Messaging.Managed e Microsoft.Toolkit.Uwp.Notifications.
   • Um nome do Hub de Notificações do Azure mencionado como <AZURE_PNH_HUB_NAME> e a cadeia de conexão do Hub de Notificações do Azure mencionada como <AZURE_PNH_HUB_CONNECTION_STRING> nesse artigo.

2. Para se registrar em um canal WNS em cada inicialização de aplicativo, adicione o código de inicialização em seu arquivo App.xaml.cs:

   // App.xaml.cs
   
   protected override async void OnLaunched(LaunchActivatedEventArgs e)
   {
       await InitNotificationsAsync();
   
       ...
   }
   
   private async Task InitNotificationsAsync()
   {
       if (AZURE_PNH_HUB_NAME != "<AZURE_PNH_HUB_NAME>" && AZURE_PNH_HUB_CONNECTION_STRING != "<AZURE_PNH_HUB_CONNECTION_STRING>")
       {
           var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
           channel.PushNotificationReceived += Channel_PushNotificationReceived;
   
           var hub = new NotificationHub(AZURE_PNH_HUB_NAME, AZURE_PNH_HUB_CONNECTION_STRING);
           var result = await hub.RegisterNativeAsync(channel.Uri);
   
           if (result.ChannelUri != null)
           {
               PNHChannelUri = new Uri(result.ChannelUri);
           }
           else
           {
               Debug.WriteLine("Cannot register WNS channel");
           }
       }
   }
   

3. Registre o manipulador de eventos ativado quando uma nova mensagem de notificação por push chegar em App.xaml.cs:

   // App.xaml.cs
   
   private void Channel_PushNotificationReceived(PushNotificationChannel sender, PushNotificationReceivedEventArgs args)
   {
       switch (args.NotificationType)
       {
         case PushNotificationType.Toast:
         case PushNotificationType.Tile:
         case PushNotificationType.TileFlyout:
         case PushNotificationType.Badge:
             break;
         case PushNotificationType.Raw:
             var frame = (Frame)Window.Current.Content;
             if (frame.Content is MainPage)
             {
                 var mainPage = frame.Content as MainPage;
                 await mainPage.HandlePushNotificationIncomingCallAsync(args.RawNotification.Content);
             }
             break;
       }
   }
   

Registrar notificações por push

Para se registrar para receber notificações por push, chame RegisterForPushNotificationAsync() em uma instância de CallAgent com o canal do registro WNS obtido na inicialização do aplicativo.

O registro das notificações por push precisa acontecer após a inicialização bem-sucedida.

// MainPage.xaml.cs

this.callAgent = await this.callClient.CreateCallAgentAsync(tokenCredential, callAgentOptions);
                
if ((Application.Current as App).PNHChannelUri != null)
{
    await this.callAgent.RegisterForPushNotificationAsync((Application.Current as App).PNHChannelUri.ToString());
}

this.callAgent.CallsUpdated += OnCallsUpdatedAsync;
this.callAgent.IncomingCallReceived += OnIncomingCallAsync;

Gerenciar as notificações push

Para receber notificações de chamadas recebidas por push, chame handlePushNotification() em uma instância de CallAgent com um conteúdo de dicionário:

// MainPage.xaml.cs

public async Task HandlePushNotificationIncomingCallAsync(string notificationContent)
{
    if (this.callAgent != null)
    {
        PushNotificationDetails pnDetails = PushNotificationDetails.Parse(notificationContent);
        await callAgent.HandlePushNotificationAsync(pnDetails);
    }
}

Essa chamada dispara um evento de ligação em CallAgent que mostra a notificação de chamada recebida:

// MainPage.xaml.cs

private async void OnIncomingCallAsync(object sender, IncomingCallReceivedEventArgs args)
{
    incomingCall = args.IncomingCall;
    (Application.Current as App).ShowIncomingCallNotification(incomingCall);
}

// App.xaml.cs

public void ShowIncomingCallNotification(IncomingCall incomingCall)
{
    string incomingCallType = incomingCall.IsVideoEnabled ? "Video" : "Audio";
    string caller = incomingCall.CallerDetails.DisplayName != "" ? incomingCall.CallerDetails.DisplayName : incomingCall.CallerDetails.Identifier.RawId;
    new ToastContentBuilder()
    .SetToastScenario(ToastScenario.IncomingCall)
    .AddText(caller + " is calling you.")
    .AddText("New Incoming " + incomingCallType + " Call")
      .AddButton(new ToastButton()
          .SetContent("Decline")
          .AddArgument("action", "decline"))
      .AddButton(new ToastButton()
          .SetContent("Accept")
          .AddArgument("action", "accept"))
      .Show();
}

Adicione o código que se encarregará do pressionamento de botão para a notificação no método OnActivated:

// App.xaml.cs

protected override async void OnActivated(IActivatedEventArgs e)
{   
    // Handle notification activation
    if (e is ToastNotificationActivatedEventArgs toastActivationArgs)
    {
      ToastArguments args = ToastArguments.Parse(toastActivationArgs.Argument);
      string action = args?.Get("action");
    
      if (!string.IsNullOrEmpty(action))
      {
          var frame = Window.Current.Content as Frame;
          if (frame.Content is MainPage)
          {
              var mainPage = frame.Content as MainPage;
              await mainPage.AnswerIncomingCall(action);
          }
      }
    }
}

// MainPage.xaml.cs

public async Task AnswerIncomingCall(string action)
{
    if (action == "accept")
    {
      var acceptCallOptions = new AcceptCallOptions()
      {
          IncomingVideoOptions = new IncomingVideoOptions()
          {
              StreamKind = VideoStreamKind.RemoteIncoming
          }
      };
    
      call = await incomingCall?.AcceptAsync(acceptCallOptions);
      call.StateChanged += OnStateChangedAsync;
      call.RemoteParticipantsUpdated += OnRemoteParticipantsUpdatedAsync;
    }
    else if (action == "decline")
    {
      await incomingCall?.RejectAsync();
    }
}