Talk to us
Talk to us
menu

Blog Post

start building
Developer

How to Easily Build Voice Application with Voice API

How to Easily Build Voice Application with Voice API

As the world is transitioning to a new technology for real-time communication, voice calling is modernizing its existence with better features for voice API for developers to connect users anytime, anywhere. By making a global shift, these voice APIs are stepping towards unified communications of all types of major industries. It attracted the attention of skilled developers to try to build their own voice chat apps.

This post is for those thriving developers to get into detailed research using guidance on these real-time communications voice chat APIs to build their voice communications apps. If you had the goal of implementing a web application that could automatically write out what you were talking about and perform actions with voice commands. We think it is a good idea to deliver a way to hear feedback from the application. Here are the best solutions for the developer to build a voice Application with the voice API of ZEGOCLOUD.

zegocloud voice api

What is Voice API?

The Voice API is a tool for software developers to use to make phone calls and receive calls with simple, easy-to-understand APIs. Behind the scenes, the voice API bridges public switched telephone networks (PSTNs) and Internet-connected applications. The Voice API allows software developers to program voice calls to applications without requiring specialized communication knowledge or hardware.

Using the voice API, developers can build calling logic that extends to any device, any user on any network, anywhere in the world. Developers can also add full VoIP functionality to their applications to make calls on the Internet alone, without the need to connect to PSTN.

Benefits of Voice call applications to build with Voice API

There are countless benefits to adding voice calling to your mobile or browser-based application. There are numerous use cases, whether you are a member of an online community, a remote worker, a doctor, and patient, or trying to connect an enterprise with its customer base. This section describes the key benefits of this feature and how it can be useful for almost any business.

  • Clear, fast communication

Voice communication minimizes the risk of misinterpretation. Even if you have to go through a complicated procedure, you can easily explain it over the phone.

  • Cost-effectiveness

Voice calls apps significantly reduce domestic and international call rates. Unlike traditional phone solutions, voice chat apps do not require expensive equipment or maintenance.

  • Convenience

Voice calls provide a very quick and easy way to connect. You can easily find your contacts by scrolling through the app’s contact list. Just click the button or touch the screen to start the connection. The high-speed Internet connection allows you to communicate instantly between domestic and international calls. Plus, you can make calls on various devices, including smartphones, tablets, laptops, and desktops, to make your business more efficient.

  • Audio Conference

In-app calls, unlike traditional calls, allow voice conferencing with 4-12 users, regardless of whether there is a media server. It is the best set-up for business meetings, medical discussions, financial consultations, HR interviews, and more when two or more people need to participate in the call.

  • High Quality

A mature voice chat app has an excellent quality advantage compared to standard telephone services. Communication is clear and smooth, with interference, delay, or dropout issues.

Best Voice Chat API for Mobile and Web Apps 

All APIs may have unique features or offerings. However, developers must analyze the requirements to build voice chats for Android, iOS & Web. The basic plan is to integrate a voice API that allows to development of a calling function that covers all types of users on any device, anywhere in the world, through many networks. Major criteria to measure good Voice Chat API.

Popularity: A competent voice chat API gives developers programmatic control over calls and allows them to build call logic and VoIP functionality. However, the level of popularity and the number of users show the voice API’s efficiency.

Price: Affordability is also a key factor in distinguishing the best voice API providers. Live Voice call APIs can provide many features but are accessible by companies only if they are cost-effective.

Ease of use: Developers can integrate voice-calling APIs with CRM, help desk, apps, and many other mobile and web platforms, but this Integration must be easy and adaptable. Therefore, when considering and selecting the best voice call API for an app developer, it is necessary to ensure good usability.

ZEGOCLOUD API to Build Voice Application

ZEGOCLOUD is the best Voice Chat API for Mobile and Web Applications because of all the above major factors for the best voice chat API you can get here. It is very user-friendly. This guide explains how to implement basic audio features in ZEGO Express SDK. Express Audio is a real-time audio, interactive service product that can provide developers convenient access, high-definition, smooth, multi-platform interoperability, low latency, high continuity audio and video services, enabling one-to-many, many-to-many real-time audio interactions, live shows of shows, audio conferences and other scenarios. Extreme Speed Audio also allows developers to access audio and video services at full speed on a four-line-code platform, allowing developers to build products and services for a perfect audio experience in 30 minutes.

Features 

  • ZEGO Express SDK: It is a real-time audio and video SDK developed by ZEGO. You can quickly build high-quality, low-latency, and smooth real-time audio and video communications on various platform apps and support large-scale parallel processing.
  • Stream publishing: It offers the stream publishing process. The client app captures audio and video streams and sends them to ZEGO Real-Time Audio and Video Cloud.
  • Room: A service organizes room user groups and allows users in the same room to send and receive audio, video, and messages in real-time.
  • If you want to publish or play a stream, first, you need to log in to a room.
  • It is important to know one thing users can be notified only about modifications in the room they are in (new users joining rooms, existing users leaving rooms, new audio-video streams, etc.).

What can it do?

  • Social: For many people, text chat may feel unsatisfactory, video calls may be overwhelming, and audio conversations may be a good idea. In real-time voice chat, users tend to interact with each other longer.
  • In-game Audio: By adding real-time voice to the game, players can interact in real-time while playing together, creating a more impressive experience. As gamers engage more, so does their bottom line.
  • Voice conference: High-quality voice calls enable remote employees to collaborate effectively in real-time, from anywhere.
  • IoT Devices: By adding real-time voice functionality to IoT devices, you can achieve a smarter and more convenient lifestyle.

We also offer a ZEGO call solution that includes a demo calling app and full open-source sample code to help you quickly build the calling app for the scenario you want in just a few minutes because it is very simple.

Guides on Voice Call API for iOS Developers

Integrate the SDK

Set up the development environment such as get you laptop or PC in front of you and make sure you have good internet connection to get started smoothly.

Before integrating the ZEGO Express SDK, make sure the development environment meets the following requirements:

  • React Native 0.60.0 or later
  • It is necessary that you’re an iOS device or iOS Simulator that is running on iOS 9.0 or later and supports audio and video. We recommend you use a real device.
  • Your device is connected to the internet.
  • Configure the VS Code environment. Search the “React Native Tools” in the application store to download it.

Optional: Create a new project

Skip to this step if a project already exists.

Import the SDK

Enter the root directory of your project, open the package.json, and add the “zego-express-engine-reactnative”: “^x.y.z” to the dependencies.

  • In the root directory of your project, run the npm install zego-express-engine-reactnative –save command or the yarn add zego-express-engine-reactnative command to install the SDK.
  • Go to the iOS root directory, run the pod install command to install the dependencies.
  • Once you’ve done the operations above, you will be available to use the zego-express-engine-reactnative SDK in your project either in JavaScript or TypeScript (TypeScript is recommended).

Add permissions

Permissions can be set as needed.

In Xcode, select the target project, go to Info > Custom iOS Target Properties.

add permissions

Add the + button to add microphone and camera permissions.

  • Privacy – Camera Usage Description
  • Privacy – Microphone Usage Description

After the permission is added, it will be shown as below:

device permissions

Creating a ZegoExpressEngine Instance:

Step 1: User Interface: Creating UI as you like is not necessary. It is optional. User interface (UI) is the point at which humans and computers interact and communicate on a device. It includes the display screen, keyboard, mouse, and desktop appearance. So you can adjust it before starting.

Step 2: Import Header Files: To import the header, use the preprocessor directive #include to instruct the compiler to import and process the remaining code before compiling it. Import the header file ZegoExpressEngine.h into your project.

// Import the header file ZegoExpressEngine.h 
#import <ZegoExpressEngine/ZegoExpressEngine.h>

Step 3: Create an instance of ZegoExpressEngine

To create a singleton instance of the ZegoExpressEngine class, call the createEngine method with the project’s AppID.

To receive callbacks, implement an event handler object that conforms to the ZegoEventHandler protocol (for example, self) and pass the implemented event handler object as an eventHandler parameter to the createEngine method. You can also set an event handler by passing nil as the eventHandler parameter to the createEngine method and then calling the setEventHandler method after the engine is created.

/**
*  appID: The AppID value you get from the ZEGOCLOUD Admin console.
*  The AppID ranges from 0 - 4294967295.
* appSign: The AppSign you get from the ZEGOCLOUD Admin console.
* scenario: the scenario you use. [ZegoScenarioGeneral] refers to the general scenario. 
*/
ZegoEngineProfile *profile = [[ZegoEngineProfile alloc] init];
profile.appID = <#appID#>;
profile.appSign = <#appSign#>;
profile.scenario = ZegoScenarioGeneral;
// Create a ZegoExpressEngine instance and set eventHandler to [self]. If eventHandler is set to [nil], no callback will be received. You can set up the event handler later by calling the [-setEventHandler:] method.
[ZegoExpressEngine createEngineWithProfile:profile eventHandler:self];

Log into a room

Step1: Login

Note: You must generate a token before you can log in to the room. You must generate a token before you can log in to the room.

To log in to a conference room:

  1. Create a ZegoUser with a unique user ID.
  2. Call the loginRoom method with the given parameters:

The unique room ID as the roomID parameter

Use the ZegoUser object you created in the previous step as the user parameter.

If roomID does not exist, a new room is created and automatically logged in when you call the loginRoom method.

//create a user
ZegoUser *user = [ZegoUser userWithUserID:@"user1"];

ZegoRoomConfig *roomConfig = [[ZegoRoomConfig alloc] init];
// Token is generated by the user's own server. For an easier and convenient debugging, you can get a temporary token from the ZEGOCLOUD Admin Console
roomConfig.token = @"xxxxx";
// onRoomUserUpdate callback can be received only by passing in a ZegoRoomConfig whose "isUserStatusNotify" parameter value is "true".
roomConfig.isUserStatusNotify = YES;
// log in to a room
[[ZegoExpressEngine sharedEngine] loginRoom:roomID user:user config:roomConfig callback:^(int errorCode, NSDictionary * _Nullable extendedData) {
    // (Optional callback) The result of logging in to the room. If you only pay attention to the login result, you can use this callback.
}];

Suppose the app terminates abnormally after successfully logging in to a room. In that case, you must exit the room by calling the logoutRoom method after restarting the app, then log in to the room again by calling the loginRoom method.

Step 2: Listen and process room users and stream-related event callbacks

If necessary, you can implement the event handlers’ corresponding event callback methods to listen and process the various events that occur after you log in to the room. Below are the general event callbacks associated with room users and streams.

  • onRoomStateUpdate: A callback for updating the current user’s room connection status. If the current user’s room connection status changes (for example, if the present user is detached from the room or if login authentication fails), the SDK sends an event notification through this callback.
  • onRoomUserUpdate: A callback to update the status of other users in the room. When other users join or leave a room, the SDK sends event notifications via this callback.
  • onRoomStreamUpdate: A callback to update the status of a stream in a room. The SDK sends event notifications via this callback when a new stream is published to a room or when an existing stream in a room is stopped.
// Conform to the ZegoEventHandler protocol to handle event callbacks
@interface ViewController () <ZegoEventHandler>
// ······
@end

@implementation ViewController

// Common event callbacks related to room users and streams.

// Callback for updates on the current user's room connection status.
- (void)onRoomStateUpdate:(ZegoRoomState)state errorCode:(int)errorCode extendedData:(nullable NSDictionary *)extendedData roomID:(NSString *)roomID {
    // Implement the callback handling logic as needed. 
}

// Callback for updates on the status of other users in the room.
// Users can only receive callbacks when the isUserStatusNotify property of ZegoRoomConfig is set to `true` when logging in to the room (loginRoom).
- (void)onRoomUserUpdate:(ZegoUpdateType)updateType userList:(NSArray<ZegoUser *> *)userList roomID:(NSString *)roomID {
    // Implement the callback handling logic as needed. 
}

// Callback for updates on the status of the streams in the room.
- (void)onRoomStreamUpdate:(ZegoUpdateType)updateType streamList:(NSArray< ZegoStream * > *)streamList extendedData:(nullable NSDictionary *)extendedData roomID:(NSString *)roomID {
    // Implement the callback handling logic as needed. 
    // If users want to play the streams published by other users in the room, call the startPlayingStream method with the corresponding streamID obtained from the `streamList` parameter where ZegoUpdateType == ZegoUpdateTypeAdd.
}

@end

Publish Stream

Step 1: Start publishing the stream.

To start publishing the local audio stream to a remote user, call the startPublishingStream method by passing the stream ID corresponding to the streamID parameter.

// Start publishing a stream
[[ZegoExpressEngine sharedEngine] startPublishingStream:@"stream1"];

Step 2: Audition and processing of event callbacks related to stream publishing

To listen to and process various events that may occur after stream publishing has started, you may implement the corresponding event callback methods of the event handlers as needed. Below are some common event callbacks related to stream publishing.

  • onPublisherStateUpdate: Callback for updating the stream publishing status. If the status changes after a stream publish have been started (for example, if a network problem is causing the stream to publish to stop and the SDK attempts to start the stream publish again), the SDK sends an event notification via this callback.
// Conform to the ZegoEventHandler protocol to handle event callbacks
@interface ViewController () <ZegoEventHandler>
// ······
@end

@implementation ViewController

// Common event callbacks related to stream publishing.

// Callback for updates on stream publishing status.  
- (void)onPublisherStateUpdate:(ZegoPublisherState)state errorCode:(int)errorCode extendedData:(nullable NSDictionary *)extendedData streamID:(NSString *)streamID {
    // Implement the callback handling logic as needed. 
}

@end

Play Stream

Step 1: Start playing the stream.

To start playing the remote audio stream, call the startPlayingStream method by passing the Stream ID corresponding to the streamID parameter to the canvas parameter.

Stream IDs for streams that other users in the room have published can be obtained from the callback onRoomStreamUpdate.

// Play a remote stream
[[ZegoExpressEngine sharedEngine] startPlayingStream:@"stream1" canvas:[ZegoCanvas canvasWithView:self.view]];

Step 2: Audition and processing of event callbacks related to stream playback

In order to wait for and process various events that may occur after the start of stream reproduction, it is necessary to implement an event callback method corresponding to an event handler. Below are the available event callbacks related to stream playback.

  • onPlayerStateUpdate: A callback for updating the stream’s playback status. If the status changes after the stream start playing (for example, if there is a network issue that interrupts the stream playback, and the SDK tries again to start the stream playback), the SDK will send an event notification through this callback.
// Conform to the ZegoEventHandler protocol to handle event callbacks
@interface ViewController () <ZegoEventHandler>
// ······
@end

@implementation ViewController

// Common event callbacks related to stream playing.

// Callback for updates on stream playing status. 
- (void)onPlayerStateUpdate:(ZegoPlayerState)state errorCode:(int)errorCode extendedData:(NSDictionary *)extendedData streamID:(NSString *)streamID {
    // Implement the callback handling logic as needed. 
}

@end

 

 

Test Voice Call

It is recommended that you run the project on a real device. When the app runs successfully, you should hear audio and see locally captured video from your device.

To try out real-time audio and video, go to ZEGO Express Web Demo and join the same room with the same AppID, Server, and RoomID. If successful, you should be able to see video from both the local and remote sides and hear audio from both sides.

Guides on Voice Chat API for Android Developers

Build development environment

  • Android Studio 2.1 or later is required. Based on the speed and enhancements of Android Studio 2.0, the stable Android Studio 2.1 introduces updates to the IDE wizards, build systems, and Android Emulator to explore new features and APIs in the developer preview, including the new Jack compilers and Java 8 language support.
  • The Android SDK package: Android SDK 25、, Android SDK Build-Tools 25.0.2、, Android SDK Platform-Tools 25。
  • Android Device with camera and microphone running Android 4.4 or higher. You can also run the project on an Android emulator, but we recommend using a real machine. The Android emulator is an Android Virtual Device (AVD) representing a specific Android device. By using the Android emulator as a target platform, you can run and test Android applications on your PC. The use of the Android emulator is optional.
  • Your Android device and computer are linked to the Internet.

Include SDK in the project

Choose one of the following methods to incorporate ZEGO Express SDK into your project:

The SDK currently supports the Android ABI: armeabi-v7a, arm64-v8a, x86, x86_64.

Method 1: Integrate the SDK Automatically with JCenter

Gradle creates it effortless to build common types of projects, such as Java libraries, by adding layers of conventions and built features through plug-ins. You can also create and publish custom plug-ins that encapsulate your conventions and build functionality. Add the following line to the app/build.

...
dependencies {
    ...
    // x.y.z is the specific version number of the SDK, for example: 2.7.0
    // Latest version number can be get in the SDK release history.
    implementation 'com.github.zegolibrary:express-video:x.y.z'
}

Method 2: Download and Copy the SDK Files Manually

Download ZEGO Express Android SDK and unzip the downloaded SDK package. The Android SDK Build Tool is used to build the actual binaries of the Android app. The main functions of the Android SDK Build Tool are to build, debug, run, and test Android applications.

Copy all folders containing the unzipped .jar and .so files to the project directory (for example, app/libs).

zegocloud voice api file

Add the Import statement for the SDK. Open the app/build.gradle file and add the following:

Add an ndk node within the defaultConfig node and specify the supported APIs.

ndk {
  abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64' 
}

Add the sourceSets node within the android node and specify the directory that contains the SDK files.

sourceSets {
    main {
        jniLibs.srcDirs = ['libs']
    }
}

Add the following code to the dependencies node:

implementation fileTree(dir: 'libs', include: ['*.jar'])

Setting Permissions

Open app/src/main/AndroidManifest.xml and add the following code:

<!-- Permissions required by the SDK -->
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.BLUETOOTH" />
    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />

    <!-- Permissons required by the App -->
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />

    <uses-feature
        android:glEsVersion="0x00020000"
        android:required="true" />

    <uses-feature android:name="android.hardware.camera" />
    <uses-feature android:name="android.hardware.camera.autofocus" />

Prevent Class Name Obfuscation

To prevent the Zego SDK public class names from being obfuscated, please add the following code in the file proguard-rules.pro.

-keep class **.zego.**{*;}

Create an instance of ZegoExpressEngine

1. Create UI as you like. Yser interface of your working environment.

2. Create ZegoExpressEngine Instance

To create a singleton instance of the ZegoExpressEngine class, call the createEngine method with the project’s AppID.

To receive callbacks, implement an event handler object that conforms to the IZegoEventHandler protocol and pass the event handler object that you implemented as an eventHandler parameter to the createEngine method. Alternatively, you can set the event handler by calling the setEventHandler method after the engine is created by passing null as the eventHandler parameter to the createEngine method.

//  Create a ZegoExpressEngine instance and set eventHandler to [self]. 
// If eventHandler is set to [null], no callback will be received. You can set up the event handler later by calling the [setEventHandler:] method.
ZegoEngineProfile profile = new ZegoEngineProfile();
profile.appID = ;  // The AppID you get from ZEGOCLLOUD Admin Console. AppID format: 123456789L
profile.appSign = ;  // The AppSign you get from ZEGOCLOUD Admin Console. AppSign format: @"0123456789012345678901234567890123456789012345678901234567890123" (64 characters)
profile.scenario = ZegoScenario.GENERAL;  // Use general scenario.
profile.application = getApplication();
engine = ZegoExpressEngine.createEngine(profile, null);

Log into a room

1. Log in

To log in to a room, call the loginRoom method. If roomID does not exist, calling the loginRoom method creates a new room and automatically logs in.

/** create a user */
ZegoUser user = new ZegoUser("user1");


ZegoRoomConfig roomConfig = new ZegoRoomConfig();
/** Token is generated by the user's own server. For an easier and convenient debugging, you can get a temporary token from the ZEGOCLOUD Admin Console */
roomConfig.token = "xxxx";
/** onRoomUserUpdate callback can be received only by passing in a ZegoRoomConfig whose "isUserStatusNotify" parameter value is "true".*/
roomConfig.isUserStatusNotify = true;

/** log in to a room */
engine.loginRoom("room1", user, roomConfig, (int error, JSONObject extendedData)->{
    // (Optional callback) The result of logging in to the room. If you only pay attention to the login result, you can use this callback.
});  

If the app closes abnormally after successfully logging in to a room, after restarting the app, you must close the room by calling the logoutRoom method and log in to the room by calling the loginRoom method again.

Listen and process room users and stream-related event callbacks

If you want to listen to and process the various events that may occur after you log in to a room, you can implement the corresponding event callback methods in the event handler. Below are the general event callbacks associated with room users and streams.

  • onRoomStateUpdate: A callback for updating the current user’s room connection status. If the current user’s room connection status changes (for example, if the current user is disconnected from the room or if login authentication fails), the SDK sends an event notification through this callback.
  • onRoomUserUpdate: A callback to update the status of other users in the room. When other users join or leave a room, the SDK sends event notifications via this callback.
  • onRoomStreamUpdate: A callback to update the status of a stream in a room. The SDK sends event notifications via this callback when a new stream is published to a room or when an existing stream in a room is stopped.
engine.setEventHandler(new IZegoEventHandler() {

    /** Common event callbacks related to room users and streams. */

    /** Callback for updates on the current user's room connection status. */
    @Override
    public void onRoomStateUpdate(String roomID, ZegoRoomState state, int errorCode, JSONObject extendedData) {
        /** Implement the callback handling logic as needed. */
    }

    /** Callback for updates on the status of other users in the room. */
    @Override
    public void onRoomUserUpdate(String roomID, ZegoUpdateType updateType, ArrayList<ZegoUser> userList) {
        /** Implement the callback handling logic as needed. */
    }

    /** Callback for updates on the status of the streams in the room. */
    @Override
    public void onRoomStreamUpdate(String roomID, ZegoUpdateType updateType, ArrayList<ZegoStream> streamList, JSONObject extendedData){
        /** Implement the callback handling logic as needed. */
     }

});

Conclusion

Using powerful programmable voice APIs, you can build fast, reliable, and secure voice applications that connect, manage, and route calls across any device to create unlimited voice calls. Scale billions of concurrent user conversations across multiple platforms with a complete solution that guarantees high-end scalability with secure APIs and SDKs and increases user engagement and retention with high-quality voice calls. As a result, companies are publishing application programming interfaces (APIs) to enable developers to create and operate powerful voice applications.

APIs enable you to make, receive, and manage calls, creating a rich and reliable voice experience. To help us find the best API for a specific use case, we reviewed voice APIs and suggested you ZEGOCLOUD is the best platform for developers. You can get everything that you expect as a developer. It is very user-friendly to finalize your project in a very low time.

ZEGOCLOUD
ZEGOCLOUD With our fully customizable and easy-to-integrate Live SDK, you can quickly build reliable, scalable, and interactive live streaming into your mobile, web, and desktop apps.

Related posts

Contact us