Manage call recording on the client
Important
Functionality described in this document is currently in public preview. This preview version is provided without a service-level agreement, and we don't recommend it for production workloads. Certain features might not be supported or might have constrained capabilities. For more information, see Supplemental Terms of Use for Microsoft Azure Previews.
Call recording, lets your users record their calls made with Azure Communication Services. Here we learn how to manage recording on the client side. Before this can work, you'll need to set up server side recording.
Prerequisites
- An Azure account with an active subscription. Create an account for free.
- A deployed Communication Services resource. Create a Communication Services resource.
- A user access token to enable the calling client. For more information, see Create and manage access tokens.
- Optional: Complete the quickstart to add voice calling to your application
Install the SDK
Use the npm install
command to install the Azure Communication Services calling and common SDKs for JavaScript.
npm install @azure/communication-common --save
npm install @azure/communication-calling --save
Initialize required objects
A CallClient, instance is required for most call operations. Let's create a new CallClient
instance. You can configure it with custom options like a Logger instance.
When you have a CallClient
instance, you can create a CallAgent
instance by calling the createCallAgent
method on the CallClient
instance. This method asynchronously returns a CallAgent
instance object.
The createCallAgent
method uses CommunicationTokenCredential
as an argument. It accepts a user access token.
You can use the getDeviceManager
method on the CallClient
instance to access deviceManager
.
const { CallClient } = require('@azure/communication-calling');
const { AzureCommunicationTokenCredential} = require('@azure/communication-common');
const { AzureLogger, setLogLevel } = require("@azure/logger");
// Set the logger's log level
setLogLevel('verbose');
// Redirect log output to wherever desired. To console, file, buffer, REST API, etc...
AzureLogger.log = (...args) => {
console.log(...args); // Redirect log output to console
};
const userToken = '<USER_TOKEN>';
callClient = new CallClient(options);
const tokenCredential = new AzureCommunicationTokenCredential(userToken);
const callAgent = await callClient.createCallAgent(tokenCredential, {displayName: 'optional Azure Communication Services user name'});
const deviceManager = await callClient.getDeviceManager()
Record calls
Note
This API is provided as a preview for developers and may change based on feedback that we receive. Do not use this API in a production environment. To use this api please use 'beta' release of Azure Communication Services Calling Web SDK.
Call recording is an extended feature of the core Call
API. You first need to import calling Features from the Calling SDK:
import { Features} from "@azure/communication-calling";
Then you can get the recording feature API object from the call instance:
const callRecordingApi = call.feature(Features.Recording);
Then, to check if the call is being recorded, inspect the isRecordingActive
property of callRecordingApi
. It returns Boolean
.
const isRecordingActive = callRecordingApi.isRecordingActive;
You can also subscribe to recording changes:
const isRecordingActiveChangedHandler = () => {
console.log(callRecordingApi.isRecordingActive);
};
callRecordingApi.on('isRecordingActiveChanged', isRecordingActiveChangedHandler);
Install the SDK
Locate your project level build.gradle and make sure to add mavenCentral()
to the list of repositories under buildscript
and allprojects
buildscript {
repositories {
...
mavenCentral()
...
}
}
allprojects {
repositories {
...
mavenCentral()
...
}
}
Then, in your module level build.gradle add the following lines to the dependencies section
dependencies {
...
implementation 'com.azure.android:azure-communication-calling:1.0.0'
...
}
Initialize the required objects
To create a CallAgent
instance you have to call the createCallAgent
method on a CallClient
instance. This asynchronously returns a CallAgent
instance object.
The createCallAgent
method takes a CommunicationUserCredential
as an argument, which encapsulates an access token.
To access the DeviceManager
, a callAgent instance must be created first, and then you can use the CallClient.getDeviceManager
method to get the 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();
To set a display name for the caller, use this alternative method:
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();
Record calls
Warning
Up until version 1.1.0 and beta release version 1.1.0-beta.1 of the Azure Communication Services Calling Android SDK has the isRecordingActive
and addOnIsRecordingActiveChangedListener
are part of the Call
object. For new beta releases, those APIs have been moved as an extended feature of Call
just like described below.
Note
This API is provided as a preview for developers and may change based on feedback that we receive. Do not use this API in a production environment. To use this api please use 'beta' release of Azure Communication Services Calling Android SDK
Call recording is an extended feature of the core Call
object. You first need to obtain the recording feature object:
RecordingCallFeature callRecordingFeature = call.feature(Features.RECORDING);
Then, to check if the call is being recorded, inspect the isRecordingActive
property of callRecordingFeature
. It returns boolean
.
boolean isRecordingActive = callRecordingFeature.isRecordingActive();
You can also subscribe to recording changes:
private void handleCallOnIsRecordingChanged(PropertyChangedEvent args) {
boolean isRecordingActive = callRecordingFeature.isRecordingActive();
}
callRecordingFeature.addOnIsRecordingActiveChangedListener(handleCallOnIsRecordingChanged);
If you want to start recording from your application, please first follow Calling Recording overview for the steps to set up call recording.
Once you have the call recording setup on your server, from your Android application you need to obtain the ServerCallId
value from the call and then send it to your server to start the recording process. The ServerCallId
value can be found using getServerCallId()
from the CallInfo
class, which can be found in the class object using getInfo()
.
try {
String serverCallId = call.getInfo().getServerCallId().get();
// Send serverCallId to your recording server to start the call recording.
} catch (ExecutionException | InterruptedException e) {
} catch (UnsupportedOperationException unsupportedOperationException) {
}
When recording is started from the server, the event handleCallOnIsRecordingChanged
will trigger and the value of callRecordingFeature.isRecordingActive()
will be true
.
Just like starting the call recording, if you want to stop the call recording you need to get the ServerCallId
and send it to your recording server so that it can stop the call recording.
try {
String serverCallId = call.getInfo().getServerCallId().get();
// Send serverCallId to your recording server to stop the call recording.
} catch (ExecutionException | InterruptedException e) {
} catch (UnsupportedOperationException unsupportedOperationException) {
}
When recording is stopped from the server, the event handleCallOnIsRecordingChanged
will trigger and the value of callRecordingFeature.isRecordingActive()
will be false
.
Set up your system
Create the Xcode project
In Xcode, create a new iOS project and select the Single View App template. This quickstart uses the SwiftUI framework, so you should set the Language to Swift and User Interface to SwiftUI.
You're not going to create unit tests or UI tests during this quickstart. Feel free to clear the Include Unit Tests and Include UI Tests text boxes.
Install the package and dependencies with CocoaPods
Create a Podfile for your application, like this:
platform :ios, '13.0' use_frameworks! target 'AzureCommunicationCallingSample' do pod 'AzureCommunicationCalling', '~> 1.0.0' end
Run
pod install
.Open
.xcworkspace
with Xcode.
Request access to the microphone
To access the device's microphone, you need to update your app's information property list with NSMicrophoneUsageDescription
. You set the associated value to a string
that will be included in the dialog that the system uses to request access from the user.
Right-click the Info.plist
entry of the project tree and select Open As > Source Code. Add the following lines in the top-level <dict>
section, and then save the file.
<key>NSMicrophoneUsageDescription</key>
<string>Need microphone access for VOIP calling.</string>
Set up the app framework
Open your project's ContentView.swift file and add an import
declaration to the top of the file to import the AzureCommunicationCalling
library. In addition, import AVFoundation
. You'll need it for audio permission requests in the code.
import AzureCommunicationCalling
import AVFoundation
Initialize CallAgent
To create a CallAgent
instance from CallClient
, you have to use a callClient.createCallAgent
method that asynchronously returns a CallAgent
object after it's initialized.
To create a call client, you have to pass a CommunicationTokenCredential
object.
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)
}
Pass the CommunicationTokenCredential
object that you created to CallClient
, and set the display name.
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")
}
})
Record calls
Warning
Up until version 1.1.0 and beta release version 1.1.0-beta.1 of the Azure Communication Services Calling iOS SDK has the isRecordingActive
as part of the Call
object and didChangeRecordingState
is part of CallDelegate
delegate. For new beta releases, those APIs have been moved as an extended feature of Call
just like described below.
Note
This API is provided as a preview for developers and may change based on feedback that we receive. Do not use this API in a production environment. To use this api please use 'beta' release of Azure Communication Services Calling iOS SDK
Call recording is an extended feature of the core Call
object. You first need to obtain the recording feature object:
let callRecordingFeature = call.feature(Features.recording)
Then, to check if the call is being recorded, inspect the isRecordingActive
property of callRecordingFeature
. It returns Bool
.
let isRecordingActive = callRecordingFeature.isRecordingActive;
You can also subscribe to recording changes by implementing RecordingCallFeatureDelegate
delegate on your class with the event didChangeRecordingState
:
callRecordingFeature.delegate = self
// didChangeRecordingState is a member of RecordingCallFeatureDelegate
public func recordingCallFeature(_ recordingCallFeature: RecordingCallFeature, didChangeRecordingState args: PropertyChangedEventArgs) {
let isRecordingActive = recordingFeature.isRecordingActive
}
If you want to start recording from your application, please first follow Calling Recording overview for the steps to set up call recording.
Once you have the call recording setup on your server, from your iOS application you need to obtain the ServerCallId
value from the call and then send it to your server to start the recording process. The ServerCallId
value can be found using getServerCallId()
from the CallInfo
class, which can be found in the class object using getInfo()
.
// Send serverCallId to your recording server to start the call recording.
let serverCallId = call.info.getServerCallId(){ (serverId, error) in }
When recording is started from the server, the event didChangeRecordingState
will trigger and the value of recordingFeature.isRecordingActive
will be true
.
Just like starting the call recording, if you want to stop the call recording you need to get the ServerCallId
and send it to your recording server so that it can stop the call recording.
// Send serverCallId to your recording server to stop the call recording.
let serverCallId = call.info.getServerCallId(){ (serverId, error) in }
When recording is stopped from the server, the event didChangeRecordingState
will trigger and the value of recordingFeature.isRecordingActive
will be false
.
Setting up
Creating the Visual Studio project
For UWP app, in Visual Studio 2022, create a new Blank App (Universal Windows)
project. After entering the project name, feel free to pick any Windows SDK greater than 10.0.17763.0
.
For WinUI 3 app, create a new project with the Blank App, Packaged (WinUI 3 in Desktop)
template to set up a single-page WinUI 3 app. Windows App SDK version 1.3 and above is required.
Install the package and dependencies with NuGet Package Manager
The Calling SDK APIs and libraries are publicly available via a NuGet package. The following steps exemplify how to find, download, and install the Calling SDK NuGet package.
- Open NuGet Package Manager (
Tools
->NuGet Package Manager
->Manage NuGet Packages for Solution
) - Click on
Browse
and then typeAzure.Communication.Calling.WindowsClient
in the search box. - Make sure that
Include prerelease
check box is selected. - Click on the
Azure.Communication.Calling.WindowsClient
package, selectAzure.Communication.Calling.WindowsClient
1.4.0-beta.1 or newer version. - Select the checkbox corresponding to the CS project on the right-side tab.
- Click on the
Install
button.
Record calls
Call recording is an extended feature of the core Call
object. You first need to obtain the recording feature object:
RecordingCallFeature recordingFeature = call.Features.Recording;
Then, to check if the call is being recorded, inspect the IsRecordingActive
property of recordingFeature
. It returns boolean
.
boolean isRecordingActive = recordingFeature.IsRecordingActive;
You can also subscribe to recording changes:
private async void Call__OnIsRecordingActiveChanged(object sender, PropertyChangedEventArgs args)
boolean isRecordingActive = recordingFeature.IsRecordingActive;
}
recordingFeature.IsRecordingActiveChanged += Call__OnIsRecordingActiveChanged;
Next steps
Feedback
Submit and view feedback for