DEV Community: Denize Chan

TRTCCalling, a powerful new-gen real-time communication tool

Denize Chan — Fri, 09 Sep 2022 03:24:00 +0000

What is TRTCCalling?

TRTCCalling is a real-time communication solution based on Tencent Real-Time Communication (TRTC) and Tencent Cloud Instant Messaging. It supports one-to-one and group audio/video calls and allows quick integration.

What can TRTCCalling do?

Online customer service, online interview, corporate online communication, online consultation, audio/video social networking, and more.

| Demo address |

https://web.sdk.qcloud.com/component/trtccalling/demo/web/latest/index.html#/login

How do I connect to it?

Step 1. Import the TRTCCalling component

Step 2. Create a TRTCCalling object

Step 3. Log in

Step 4. Make a one-to-one call
Caller: Make a call

Callee: Answer a call

Hang up

We invite you to connect TRTCCalling to your product, and we welcome your feedback and suggestions.

Coroutine-Native SRT

Denize Chan — Tue, 06 Sep 2022 04:27:06 +0000

Coroutines are core technologies for modern servers that significantly simplify the logic and facilitate maintenance. SRT is a new streaming protocol that is gradually taking over from RTMP. With its own I/O framework, SRT can mature only by becoming coroutine-native, the first and crucial step of SRS 5.0.

Since the beginning of 2022, we have explored, discussed, and finally determined the media gateway as the fundamental direction of SRS 5.0, as detailed in Definitions and Solutions of Core Issues with SRS 5.0.

Though popular with live streaming/broadcasting push, SRT is not supported by web browsers. And that's where the media gateway comes into play. Specifically, it converts SRT into RTMP/HLS/WebRTC to deliver an ultra low-latency broadcasting solution that keeps SRT's powerful cross-border transfer capabilities.

The foundation lies in coroutine-native SRT, today's topic. It will have a far-reaching impact on SRS 5.0. For more information on its code, see PR#3010.

First of all, let's talk about its background.

Introduction
RTMP is widely used in the live push field. It is also one of the most compatible protocols with different live streaming origin servers.
With an increasing number of scenarios and the progress of live streaming, some of the acute problems have emerged:

TCP push performs poorly in terms of packet loss, RTT, and jitter for long-distance transfer.
RTMP doesn't support multiple audio tracks or new coding standards such as H.265 and AV1.
Adobe has abandoned RTMP, which has not been updated for years nor will it be updated in the future. To solve these problems, the broadcasting field has widely adopted SRT push since 2018, and more and more push devices and platforms have followed suit. At the end of 2019, SRT push became supported by SRS 4.0. However, there were several shortcomings:
SRT is implemented in SRS with multiple threads in an asynchronous manner, making it hard to troubleshoot program crashes due to exceptions.
SRT is implemented in SRS asynchronously, leading to complex code and maintenance.
SRT playback won't take effect after the HTTP callback, which is triggered by RTMP after the SRT push dependency turns to RTMP. There is no callback for playback.
SRT needs to be converted into RTMP first before it can be converted into WebRTC, causing a high latency. The core cause of these problems is that SRT uses independent and asynchronous I/O and multiple threads that cannot be combined with the existing ST coroutines of SRS. Therefore, SRT must become coroutine-native and fall into the same ST coroutine framework as SRS. This has been achieved in SRS 5.0. For more information on its code, see PR#3010. This is an extremely important feature. Before moving to the coroutine-native SRT, let's take a look at coroutine native itself, as exemplified by the coroutine-native TCP of ST.

Coroutine-native TCP
To begin with, let's see the following logic of the non-coroutine-native code, that is, async code driven by epoll:
int fd = accept(listen_fd); // Got a TCP connection.

int n = read(fd, buf, sizeof(buf));
if (n == -1) {
if (errno == EAGAIN) { // Not ready
return epoll_ctl(fd, EPOLLIN); // Wait for fd to be ready.
}
return n; // Error.
}

printf("Got %d size of data %p", n, buf);
Note: The above is just a sample that helps better express the key logic. You can see epoll sample code for more details.
Generally speaking, read is a business logic, and the data that is read is business data. However, the underlying framework of epoll needs to be called here for fd processing during EAGAIN. As a result, the underlying logic and business logic are mixed, complicating maintenance.
Note: Although NGINX has a packaged framework layer, async callback still exists. If the current function needs to be returned before the fd is ready, many statuses need to be stored and recovered. When the logic is complex, the state machine becomes complicated.
See the following code to see what a coroutine-native logic will be like in this case:
st_netfd_t fd = st_accept(listen_fd); // Got a TCP connection

int n = st_read(fd, buf, sizeof(buf));
if (n == -1) {
return n; // Error.
}

printf("Got %d size of data %p", n, buf);
Obviously, there seems to be no EAGAIN. It may be that data is read or an error occurs. No matter what the case is, fd will always be ready. This means no need to store the status and no repeated read attempts, creating a very good experience when using the business logic.
Why is there no EAGAIN for st_read when epoll is still used? Well, there is, but it has been handled less obviously with the coroutine. Let's see the st_readv function:

ssize_t st_read(_st_netfd_t *fd, void *buf, size_t nbyte) {
while ((n = read(fd->osfd, buf, nbyte)) < 0) {
if (errno == EINTR)
continue;
if (!_IO_NOT_READY_ERROR) // Error, if not EAGAIN.
return -1;

    /* Wait until the socket becomes readable */
    if (st_netfd_poll(fd, POLLIN) < 0) // EAGAIN
        return -1;
}

return n;

}

During EAGAIN, st_netfd_poll is called, which switches the current coroutine and schedules the thread to execute the next coroutine. In addition, the current coroutine will be recovered at some point when the I/O event arrives or a timeout occurs.
Note: Both the coroutine switch and recovery are implemented in the function and imperceptible to the code called at the upper layer. Therefore, there is no EAGAIN error message or return to the upper-layer function, and no need to store and resume the status.
In summary, do the following to make any protocol coroutine-native:

Call the API once, which will directly return upon success.
In the case of a failure, check for the error and return if the error is irrelevant to I/O wait.
Switch the current coroutine and run other coroutines until the arrival of a timeout or the fd event. In the former case, return an error; in the latter case, repeat the above steps. With that, we can make SRT coroutine-native.

Coroutine-native SRT
The srt_recvmsg function is used as an example. It resembles the read function of TCP and is as defined below:

SRT_API int srt_recvmsg (SRTSOCKET u, char* buf, int len);

Implement SrsSrtSocket::recvmsg , another function similar to st_read :

srs_error_t SrsSrtSocket::recvmsg(void* buf, size_t size, ssize_t* nread) {
while (true) {
int ret = srt_recvmsg(srt_fd_, (char*)buf, size);
if (ret >= 0) { // Receive message ok.
recv_bytes_ += ret;
*nread = ret;
return err;
}

// Got something error, return immediately.
if (srt_getlasterror(NULL) != SRT_EASYNCRCV) {
return srs_error_new(ERROR_SRT_IO, "srt_recvmsg");
}

// Wait for the fd ready or error, switch to other coroutines.
if ((err = wait_readable()) != srs_success) { // EAGAIN.
return srs_error_wrap(err, "wait readable");
}
}

return err;
}

As we can see, wait_readable implements coroutine switch and recovery just like st_read , but with the st_cond_t condition variable:

srs_error_t SrsSrtSocket::wait_readable() {
srt_poller_->mod_socket(this, SRT_EPOLL_IN);
srs_cond_timedwait(read_cond_);
}

Note: The SRT_EPOLL_IN event listened by epoll is modified before the fd becomes readable and the condition variable is triggered.
SrsSrtPoller::wait is the function that triggers the condition variable. Its implementation is as follows:

srs_error_t SrsSrtPoller::wait(int timeout_ms, int* pn_fds) {
int ret = srt_epoll_uwait(srt_epoller_fd_, events_.data(), events_.size());
for (int i = 0; i < ret; ++i) {
if (event.events & SRT_EPOLL_IN) {
srt_skt->notify_readable();
}
}
}

void SrsSrtSocket::notify_readable() {
srs_cond_signal(read_cond_);
}

Now the SRT API becomes coroutine-native. The operation is similar for other APIs such as srt_sendmsg, srt_connnect, and srt_accept.
Let's compare coroutine native and the original callback.

Coroutine native vs callback
After making the SRT coroutine-native, we succeeded in separating the business logic from the underlying code, thereby clarifying the upper-layer code logic.
Let's see the accept logic, where event processing is triggered by epoll to create the srt_conn data structure:

while (run_flag) {
int ret = srt_epoll_wait(_pollid, read_fds, &rfd_num, write_fds);
for (int index = 0; index < rfd_num; index++) {
SRT_SOCKSTATUS status = srt_getsockstate(read_fds[index]);
srt_handle_connection(status, read_fds[index], "read fd");
}
}

void srt_server::srt_handle_connection(SRT_SOCKSTATUS status, SRTSOCKET input_fd) {
if (status == SRTS_LISTENING) {
conn_fd = srt_accept(input_fd, (sockaddr*)&scl, &sclen);
_handle_ptr->add_newconn(conn_fd, SRT_EPOLL_IN);
}
}

void srt_handle::add_newconn(SRT_CONN_PTR conn_ptr, int events) {
_push_conn_map.insert(std::make_pair(conn_ptr->get_path(), conn_ptr));
_conn_map.insert(std::make_pair(conn_ptr->get_conn(), conn_ptr));
int ret = srt_epoll_add_usock(_handle_pollid, conn_ptr->get_conn(), &events);
}

Note: The created srt_conn is stored in the global data structure and continuously modified in the follow-up callback events.
The following is a coroutine-native business logic, which starts the processing coroutine after receiving the session:

srs_error_t SrsSrtListener::cycle() {
while (true) {
srs_srt_t client_srt_fd = srs_srt_socket_invalid();
srt_skt_->accept(&client_srt_fd);

srt_server_->accept_srt_client(srt_fd);

}
}

srs_error_t SrsSrtServer::accept_srt_client(srs_srt_t srt_fd) {
fd_to_resource(srt_fd, &srt_conn);
conn_manager_->add(srt_conn);
srt_conn->start();
}

Note: Although srt_conn is maintained by global variables, it is the coroutine-native execution logic—not callback logic or epoll processing—that is relevant.
In the callback logic, you need to view the epoll callback event before maintaining or understanding the code. What's worse, the srt_conn status is modified by different events, making it hard to understand the lifecycle of the object; while in the coroutine-native logic, its lifecycle is contained in the coroutine, it is processed in a coroutine after srt_conn is received, and further read and write operations are also performed in the coroutine.
Let's move on to the read processing logic of srt_conn , where the native read function of SRT is used and the callback is triggered by the epoll event:
while (run_flag) {
int ret = srt_epoll_wait(_pollid, read_fds, &rfd_num, write_fds);
for (int index = 0; index < rfd_num; index++) {
SRT_SOCKSTATUS status = srt_getsockstate(read_fds[index]);
srt_handle_data(status, read_fds[index], "read fd");
}
}

void srt_handle::handle_srt_socket(SRT_SOCKSTATUS status, SRTSOCKET conn_fd) {
auto conn_ptr = get_srt_conn(conn_fd);
int mode = conn_ptr->get_mode();
if (mode == PUSH_SRT_MODE && status == SRTS_CONNECTED) {
handle_push_data(status, path, subpath, conn_fd);
}
}

void srt_handle::handle_push_data(SRT_SOCKSTATUS status, SRTSOCKET conn_fd) {
srt_conn_ptr = get_srt_conn(conn_fd);
if (status != SRTS_CONNECTED) { // Error.
close_push_conn(conn_fd);
return;
}

ret = srt_conn_ptr->read_async(data, DEF_DATA_SIZE);
if (ret <= 0) { // Error.
if (srt_getlasterror(NULL) != SRT_EASYNCRCV) {
return;
}
close_push_conn(conn_fd);
return;
}

srt2rtmp::get_instance()->insert_data_message(data, ret, subpath);
}

Note: We need to process a variety of statuses in the callback, but the srt_conn status changes are determined by different callbacks, so it is not easy to determine the main processing logic of the session.

A coroutine-native version of the SRT business logic will be like:

srs_error_t SrsMpegtsSrtConn::do_publishing() {
while (true) {
ssize_t nb = 0;
if ((err = srt_conn_->read(buf, sizeof(buf), &nb)) != srs_success) {
return srs_error_wrap(err, "srt: recvmsg");
}

if ((err = on_srt_packet(buf, nb)) != srs_success) {
return srs_error_wrap(err, "srt: process packet");
}
}
}

Note: The lifecycle of srt_conn is clear, and its status is returned in the error within the cycle, which can be regarded as the main loop for this session. It will not enter the epoll loop of SRT due to read, and you can ignore the async event trigger and processing during maintenance.

Again, different information is required for code maintenance in different logics. In the async callback logic, you need to know the statuses of the current object, the modified statuses, and the impact of other async events from the callback function. While in the coroutine-native logic, these statuses are irrelevant, and the creation and execution of the coroutine are linear. Or we can say that these statuses are in the coroutine function callback.

Note: The async callback status cannot be in the function callback, as the async callback stack cannot store the srt_conn status. In essence, it is a coroutine which stores the status of the epoll loop. While a coroutine is created according to each srt_conn, and the corresponding srt_conn status is stored in its stack.

In fact, the async callback status can only be stored in the global data structure, while the coroutine status can be stored in each local variable. The local variable of each function is unique to the coroutine and can be used as long as the coroutine doesn't end.

What is next

The coroutine-native SRT still faces some problems and requires follow-up actions:

Directly convert SRT into WebRTC to lower the latency in live streaming.
Replace TCP with SRT for long-linkage transfer between some servers, such as cross-border RTMP forwarding.
Improve the SRT tool chain, such as srs-bench, to support stress testing of SRT streams. Join the SRS open-source community to make a powerful streaming media server available for all.

One more thing
In case you may wonder, let me tell you the differences between a commercial video cloud SRT server and an open-source SRT server as well as the optimizations.
Note: Some optimizations are not suitable for open-source projects, as open-source servers put more emphasis on protocol standardization and compatibility. Therefore, a commercial cloud computing server can be totally different from an open-source server. Even the Linux kernel of the commercial server will greatly differ from that of the open-source server.

Here, some of SRT's most troublesome problems are the high retransmission rate and poorer performance than TCP/QUIC when the bandwidth is limited. Tencent Cloud makes the following optimizations accordingly:

SRT retransmission disorder adaptation: When disordered packets are received, the system will wait for N packets before initiating the first retransmission according to the current degree of the disorder. The native SRT disorder has a fixed value, which can be adjusted to be more adaptive to the network disorder conditions.
SRT transfer parameter optimization: The retransmission rate is halved after the parameter optimization.
Addition of the BBR congestion control algorithm: The native SRT congestion control is weak, and the evaluated bandwidth fluctuates greatly, both of which are resolved by adding the BBR congestion control algorithm.
SRT multi-linkage transfer improved with bandwidth aggregation: The auto mode for live streaming is added to SRT, in addition to its native backup and broadcast modes. In this way, the bandwidths of multiple ENIs are aggregated for live streaming, with smart and dynamic linkage selection.

Tencent Cloud GPU Service

Denize Chan — Fri, 26 Aug 2022 08:04:02 +0000

Not sure which Tencent Cloud GPU instance is right for you? Still fumbling a way to elegantly install the driver and other underlying development tools? These are common questions that bother deep learning researchers and developers. No worries. This document shares all you need to know through the best practices of Tencent Cloud GPU instance.

Environment and objective

The mainstream Tencent Cloud GPU Computing GN7 model with an NVIDIA Tesla T4 GPU is selected as an example, to be more specific, GN7.5XLARGE80. This model features a high comprehensive performance offered by 20 CPU cores and 80 GB memory, making it suitable for general deep neural network training. In addition, it is the most cost-effective GPU T4 model in the world.

Purchase here. Pay-as-you-go models are even more flexible for experiments.

Instance in this tutorial: GPU models like GN7 (recommended) or GN10X

Recommended system image: Ubuntu 18.04 (note that you don't need to select Automatically install GPU driver on the backend.)

Other information: Beijing Zone 5, 1 Mbps public network bandwidth, and 100 GB system disk, which can be selected as needed.

Installing CUDA Driver/Toolkit

Install the DEB package from the official website

Download CUDA Toolkit 10.2 from NVIDIA's official website.

https://developer.nvidia.com/cuda-downloads

Select the download method based on your environment. Here, DEB package installation is selected as shown below:

Run the following command as prompted:

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/cuda-ubuntu1804.pin sudo mv cuda-ubuntu1804.pin /etc/apt/preferences.d/cuda-repository-pin-600 sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/7fa2af80.pub sudo add-apt-repository "deb http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/ /" sudo apt-get update sudo apt-get -y install cuda

You can see that the official APT repository source of NVIDIA is installed in the system and apt install cuda is executed. Note that the last step of installation takes about five minutes and may be interrupted due to network and other issues, which can be fixed after a retry or two.

Note: The server needs to be restarted here.

Then how to know what is installed and verify the installation?

Verify GPU driver installation - view the device information

The NVIDIA GPU driver is a kernel module supporting CUDA programming. In the above steps, the driver is installed in the form of Dynamic Kernel Module Support (DKMS). This type of kernel module is not in the kernel source tree, but it can be automatically recompiled every time the kernel is updated and upgraded to generate a new initramfs. In addition, it is dynamically loaded as the system starts. In short, the driver only needs to be installed once, which is very convenient.

As can be seen, the NVIDIA instead of Nouveau driver is loaded.

How to Design a Proper Marketing Email Template with Tencent Cloud’s Simple Email Service

Denize Chan — Tue, 23 Aug 2022 03:58:05 +0000

The content is of great importance to a marketing email, as it directly affects the deliverability, click rate, and conversion rate. The following are some of our tips for writing a marketing email:

1. Create an eye-catching subject line

Of the over six billion email accounts in the world, 80% of them only read the subject line, and the rest 20% read the body. That's why the subject line matters.

A subject line should be created in friendly language. Do not make the recipients feel that they are forced or persuaded to buy something, in which case they may report the email as spam.
Include the primary keyword in the first three words and the secondary keyword in the last three words in the subject line. This works well for customer acquisition with a long, seemingly endless list.
A proper subject should be neither too long nor too short. You'd better limit it to ten words and put the most important words at the beginning.
Create a witty subject that includes hot news or internet buzzwords in a tailored and pleasing manner.

2. Create valuable email content

The quality of an email determines whether the recipients are willing to know about or even buy the product.

Pay attention to readability, as email marketing is also content marketing, so users' reading habits should be taken into full consideration.
You should test and adjust the email template format. Simple Email Service | Tencent Cloud allows you to preview and adjust the format when creating a template.
You can create images or text with hyperlinks, which are light-loaded and easy to open, making user interaction easier.
Use HTML emails instead of embedding text inside an image, as it often happens that an image cannot be displayed due to ISP filtering, poor network condition or other issues.
Images should be proportionate to text.
You can tailor emails for different types of customers to quickly understand their preferences and win them over.
Promote your products and services at a festival or under a special theme to guide purchase decisions. Simple Email Service | Tencent Cloud enables you to reach customers from over 200 countries and regions.
Craft a marketing email with branding elements. After all, an email is used to build your brand and achieve a high conversion rate.

Find out more at: https://www.tencentcloud.com/dynamic/insights/sample-article/100329

Integrate In-App Chat Module to Your Flutter APP with Tencent Cloud IM in 6 Steps

Denize Chan — Wed, 17 Aug 2022 08:19:50 +0000

Abstract
By the end of this tutorial, you will be able to use Tencent Cloud IM TUIKit to integrate the Chat module to Flutter APP. Tencent Cloud IM Chat is more capable than this, check more information here!

What is Tencent Cloud IM In-App Chat for Flutter？
Tencent Cloud IM provides Chat API for apps on Flutter. It integrates diverse chat capabilities such as one-to-one chat, group chat, chat room, and system notification into its SDKs.
Moreover, its TUIkit library contains complex UI components and relative business logic, helps you integrate In-App chat to your Flutter App easily and quickly.
Choosing Tencent Cloud IM can bring you and your customers closer together.

The Solutions of Integrating Tencent Cloud IM Chat for Flutter
There are three solutions to integrate Tencent Cloud IM Chat to your Flutter apps, including modifying the DEMO, using TUIKit, and invoke the SDK API directly.

Solution & Scenario

Chat DEMO: IM DEMO is a complete chat app. The code isopen source. If you need to implement a similar scene, you can do secondary development based on it. Here is the DEMO.

TUIKit library with UI components and business logic: TUIKit library provides universal UI components, such as conversation list, chat , and contact list, etc. You can quickly build the In-App chat module with your actual business needs based on it. It is recommended to use as priority.

Invoke SDK API and self-implementing UI: If the UI of TUIKit cannot meet your business needs, or you need more customization, this solution could be your option.

This tutorial will introduce how to implement the In-App Chat module with the second solution, TUIKit.

Environment Requirements
Platform & Version
Flutter: Flutter 2.8.1 or later.
Android: Android Studio 3.5 or later; API 21 (Android 5.0) or late for apps.
iOS: Xcode 11.0 or later. Ensure that your project has a valid developer signature.

Prerequisites

You have signed up for a Tencent Cloud account and completed identity verification.
Created a Chat application, and get the SDKAppID. Ref: Creating and Upgrading an Application | Tencent Cloud

Start Integration
Step 1: Create two accounts for testing
Log in to the IM console.
Select Auxiliary Tools > UserSig Generation and Verification on the left sidebar. Generate two pairs of "UserID" and the corresponding "UserSig", and copy the "key" information.
Tips: You may create "user1" and "user2" here.

Step 2: Load TUIKit library for Flutter
It's unnecessary to install the IM SDK manually, as TUIKit also convers it.
Please execute this command in Terminal on your Flutter project.

flutter pub add tim_ui_kit

Step 3: Initialize and log in
Initialize
Initialize the TUIKit after you app starts.
Get the instance of TUIKit first by "TIMUIKitCore.getInstance()", followed by initializing it, "init()", with your "sdkAppID".

/// main.dart
import 'package:tim_ui_kit/tim_ui_kit.dart';

final CoreServicesImpl _coreInstance = TIMUIKitCore.getInstance();
@override
void initState() {
_coreInstance.init(
sdkAppID: 0, // Replace 0 with the SDKAppID of your IM application
loglevel: LogLevelEnum.V2TIM_LOG_DEBUG,
listener: V2TimSDKListener());
super.initState();
}
}

Now, you can log in one of the testing accounts, generated on Step 1, to start the IM module.
Log in by "_coreInstance.login" .

import 'package:tim_ui_kit/tim_ui_kit.dart';

final CoreServicesImpl _coreInstance = TIMUIKitCore.getInstance();
_coreInstance.login(userID: userID, userSig: userSig);

Caveat: Importing UserSig to your application is ONLY for Debugging purposes and cannot be applied for the Release version. Before publishing your app, you should generate your UserSig from your server. Refers to: Generating UserSig | Tencent Cloud

Step 4: Implementing conversation list page
You can take the conversation (channel) list page as the homepage of your Chat module, covering the conversation with all users and groups that have chat records.

You can create a "Conversation" class, with "TIMUIKitConversation" on its "body", to render the conversation list.
The only parameter you need to provide at least is "onTapItem" callback, aimed at navigating to the Chat page for each conversation. The "Chat" class will be introduced in the next step.

import 'package:flutter/material.dart';
import 'package:tim_ui_kit/tim_ui_kit.dart';

class Conversation extends StatelessWidget {
const Conversation({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: const Text(
"Message",
style: TextStyle(color: Colors.black),
),
),
body: TIMUIKitConversation(
onTapItem: (selectedConv) {
Navigator.push(
context,
MaterialPageRoute(
builder: (context) => Chat(
selectedConversation: selectedConv,
),
));
},
),
);
}
}

Step 5: Implementing chat page
The chat page is composed of the main historical message list and a message sending bar at the bottom.

You can create a "Chat" class, with "TIMUIKitChat" on its "body", to render the chat page.
It is recommended to provide a "onTapAvatar" callback function, for navigating to the profile page for current contact, which will be introduced in the next step.

import 'package:flutter/material.dart';
import 'package:tim_ui_kit/tim_ui_kit.dart';

class Chat extends StatelessWidget {
final V2TimConversation selectedConversation;
const Chat({Key? key, required this.selectedConversation}) : super(key: key);
String? getConvID() {
return selectedConversation.type == 1
? selectedConversation.userID
: selectedConversation.groupID;
}
@override
Widget build(BuildContext context) {
return TIMUIKitChat(
conversationID: _getConvID() ?? '', // groupID or UserID
conversationType: selectedConversation.type ?? 1, // Conversation type
conversationShowName: selectedConversation.showName ?? "", // Conversation display name
onTapAvatar: () {
Navigator.push(
context,
MaterialPageRoute(
builder: (context) => UserProfile(userID: userID),
));
}, // Callback for the clicking of the message sender profile photo. This callback can be used with TIMUIKitProfile.
);
}

Step 6: Implementing profile page
This page can show the profile of a specific user and maintain the relationship between the current login user and it.

ere, you can create a "UserProfile" class, with "TIMUIKitProfile" on its "body", to render the profile page.
The only parameter you have to provide at least is "userID", while this component can generate the profile and relationship maintenance page based on the existence of friendship automatically.
TIPS: Please give priority to use "profileWidgetBuilder", to customize some profile widgets, with "profileWidgetsOrder", determine the vertical sequence, if you tend to customize this page. If this method could not meet your business needs, you may consider using "builder" instead.

iimport 'package:flutter/material.dart';
import 'package:tim_ui_kit/tim_ui_kit.dart';

class UserProfile extends StatelessWidget {
final String userID;
const UserProfile({required this.userID, Key? key}) : super(key: key);

@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: const Text(
"Message",
style: TextStyle(color: Colors.black),
),
),
body: TIMUIKitProfile(
userID: widget.userID,
),
);
}
}

Now, your app can send/receive messages, show the conversation list, and deal with the contact friendship.

Futhermore
You can use the following components from TUIKit continually to implement the complete IM function quickly and easily.
[TIMUIKitContact]: The contact list page shows the contacts and friends list of a specific user.
[TIMUIKitGroupProfile]: The group profile page, the integrating is basically the same as "TIMUIKitProfile".
[TIMUIKitGroup]: Lists all the group of the specific user.
[TIMUIKitBlackList]: The list contains blocked users.
[TIMUIKitNewContact]: Lists the new contacts applications by other users.
[TIMUIKitSearch]: The search page supports searching contacts, groups, chat records both globally and in specific conversation.
That's all you need to do to integrate the chat module to your Flutter apps.
Hopefully the In-App chat module can help bring you and your customers closer together.

Find out more at: https://www.tencentcloud.com/dynamic/blogs/sample-article/100304

How to Warm up Your IP Address for Emailing with Tencent Cloud’s Simple Email Service

Denize Chan — Mon, 15 Aug 2022 14:21:09 +0000

We’ve previously explored how to optimize the open rate of your marketing email last time. Let’s examine IP warm-up – a key step for email marketing today.
1. Why is IP warm-up necessary
Warm-up is often talked about in the email industry. It is the warming-up of the sender's IP and domain name, a common practice of starting with a small number of emails before starting bulk emailing. The aim is to introduce your sending practices to ISPs (such as Gmail, Hotmail, and QQ Mail) so that they will recognize your sending quality, which helps you build a positive reputation for your domain name and IP.

If your domain name and IP are not warmed up or have never or barely been used to send emails, sending bulk emails through them will be considered abnormal by the ISP; more often than not, your emails will end up in spam. Therefore, make sure that your IP is warmed up. As long as your IP is trusted by the ISP, you can maintain your reputation even if the number of sent messages greatly fluctuates.

2. How to warm up your IP
Step 1. Set up your identity verification
Before the warm-up, make sure that you have performed SPF, DKIM, MX, and DMARC validation. For more information, visit https://www.tencentcloud.com/document/product/1084/40180. The ISP will have your emails delivered only after the validation.

Step 2. Select your recipients during the warm-up
Warming up an IP is to email a few addresses through the IP and slowly increase the number of emails. It is important that you select the right recipients. Keep a clean list of recipients; that is, avoid emailing invalid addresses. Also, keep the list active, so as to get a good open rate and click rate.

Step 3. Send proper content
Be formal in your content and do not muddle through your warm-up with just an image or a few sentences. The whole warm-up process should be real or real-world-like. For triggered domain names, use content such as [welcome], [notification], and [e-commerce transaction] to guide user interactions (such as clicking links and replying to the email). For bulk emailing domain names, formulate a delicate marketing template, so that the content is less likely to be identified as spam.

Step 4. Determine the send volume and frequency
The warm-up usually takes about a month. Generally speaking, you can start with 1,000–2,000 emails per IP per day and slowly increase the volume. Make sure that the numbers of emails from different ISPs are even as much as possible. Pay attention to the email feedback. The better the feedback, the looser the requirements of ISPs, and the higher the number of emails that can be sent.
During the warm-up, keep a close eye on the delivery, bounce, and spam folder. Stop sending emails as soon as they are found to be blocked and continue the sending of a smaller number of emails the next day.

Stay tuned for our next topic with best practice sharing on marketing email design!

How to Increase Your Marketing Email Open Rate with Tencent Cloud’s Simple Email Service

Denize Chan — Thu, 11 Aug 2022 06:53:00 +0000

The email open rate is of great concern to EDM marketers as well as one of the most crucial metrics for evaluating the effectiveness of their marketing. Check out the essential guidelines to enhance the open rate of your marketing email!

1. Find the optimum send time
23.63% of the emails are opened within the first hour after delivery, after which the open rate slumps as time goes by. Therefore, it is important to understand the habits of your recipients, as emails sent to them when they are using a computer or mobile phone are more likely to be opened.

2. Use the right sender's name and address
The sender's name and address matter, as they tell the recipients who sent the email. Statistics have shown that 73% of email recipients decide whether to open an email based on the sender's name.

3. Create an appealing email subject line
A survey by a data research agency has shown that 69% of email recipients decide whether to open an email based on the subject line. Choose a subject that is relevant to your offering. This can make recipients feel connected and confident.
Add the name, city, or other variables of your recipients to the subject line to draw their attention. This can be easily done with Tencent Cloud Simple Email Service (SES), which allows adding variables during bulk emailing. For more information, see https://www.tencentcloud.com/products/ses.

4. Perform A/B testing
A/B testing helps you figure out a better email design by comparing the test results. For example, to determine the best email subject line, you can randomly split your recipients into two groups and email them in two different ways of A and B.

5. Determine the appropriate send frequency
You can query the data about your previous bulk email sends and group your recipients by email open frequency. Then you will have a high-frequency group and a low-frequency group. You can email the former frequently but the latter less frequently.

For more details, please visit: https://www.tencentcloud.com/dynamic/blogs/sample-article/100320
Our next topic will focus on how to warn up your IP address for emailing. Stay tuned!

Tencent Cloud Lighthouse Instance Just Right for You

Denize Chan — Tue, 09 Aug 2022 03:31:44 +0000

1. What is Tencent Cloud Lighthouse

A Tencent Cloud Lighthouse instance is just as easy to create, network-isolated, and stable as a Tencent Cloud CVM (Cloud Virtual Machine) instance. In addition, it offers differentiated yet targeted capabilities for SMEs and individual developers, such as ease of mastery with fewer concepts/parameters and more developer/application-friendly features.

2. Ease of Mastery with Fewer Concepts
Lighthouse is designed with fewer concepts than CVM for you to master it more effortlessly. Furthermore, its technical implementation is transparently simplified to just two core parameters: application environment and instance bundle. The former is delivered as application and system images, while the latter includes the bundle type and fee information and internally encapsulates a diversity of CVM concepts, including AZ, model, VPC, bandwidth, and data transfer plan.

3. More Developer/Application-Friendly Features
Lighthouse is inherently designed and developed to be closer to applications and developers. Unlike CVM, it is more about application deployment rather than resource creation; therefore, you can always select an appropriate image first and then configure resource parameters, easily and quickly.
Lighthouse works well with various mainstream applications that can be swiftly created and managed. For SMEs and individual developers, it offers a selection of popular application images, such as WordPress, LAMP, Node.js, and ASP.NET.

4. Virtualization and Quick Creation
Based on Tencent Cloud VStation's powerful capabilities of centrally scheduling and managing heterogeneous resources (KVM, bare metal, microVM, etc.), Lighthouse features fast and smart scheduling and high reliability, especially when it comes to large-scale clusters. As Lighthouse is delivered mainly through application images, Tencent Cloud CBS snapshotting can be readily used to create a Lighthouse instance in seconds when a snapshot rollback is triggered.

Tencent Cloud IM：Chat API For Real-Time In-App Communication

Denize Chan — Wed, 03 Aug 2022 02:30:00 +0000

What is Tencent Cloud IM？
**Tencent Cloud IM（ Instant Messaging ）provides Chat API for apps and websites. IM integrates diverse chat capabilities such as one-to-one chat, group chat, chat room, and system notification into its SDKs and UIkit components for various platforms to help you develop your business quickly.

What can you do with Tencent IM？

1. Chat in-App
- IM provides chat API for apps and websites, supporting several message types such as text, emojis, images, short audio, and short videos, which can increase user activity.
- IM supports various group types such as private groups, public groups, and chat rooms, which meet the requirements for specific group chat scenarios and diversified social interaction techniques. https://intl.cloud.tencent.com/document/product/1047/45914?lang=en&pg=&from=dev

2. Interactive Live Streaming
- IM supports chatting through on-screen comments.
- IM supports special messages such as giving “likes”, gifts, and rewards by using custom messages.
- IM provides audio/video chat rooms with no user count limits and enables smooth chat in rooms with millions of users.

3. Chat in-Game
- IM supports diverse in-game message types such as text, emoji, image, short audio, and short video, which can stimulate players’ activity and increase their participation rate.
- IM has global access points and cache nodes in the Asia Pacific, North America, Europe, Middle East, Africa, and Latin America, which implement nearby access and ensure the quality of communication for players.
- In addition to group profile photo, group nickname, group description, group member profile, and group member nickname, IM also supports a maximum of 20 custom fields for the differentiated display of in-game roles. https://intl.cloud.tencent.com/document/product/1047/41656?from=dev https://intl.cloud.tencent.com/document/product/1047/45908?from=dev

4. More Scenarios
IM is also applicable in various scenarios including online education, healthcare, customer service, meeting. For more scenarios, please see
https://intl.cloud.tencent.com/products/im?lang=en&pg=&from=dev

Why Tencent Cloud IM？

1. Expert in chat SDK service
Tencent is the first and largest developer of chat service in mainland China. QQ and Weiixin, both developed by Tencent, have 1.8 billion monthly active users. Tencent has 23 years of experience in chat development. https://intl.cloud.tencent.com/document/product/1047/33515https://intl.cloud.tencent.com/products/im?lang=en&pg=&from=dev

2. Independent IDC and global access
IM has independent data storage nodes in Singapore, Germany, India and South Korea as well as 2100+ global access points and cache nodes in the Asia Pacific, North America, Europe, Middle East, Africa, and Latin America to achieve worldwide reach. These nodes enable messages to be delivered globally in 200ms on average.

3. Easy and Quick Integration
You can run the demo in just ten minutes. By implementing the UI features based on TUIKit and calling the corresponding APIs of the IM SDK, you can build your own IM application in just one day. https://intl.cloud.tencent.com/document/product/1047/45914?from=dev

4. Comprehensive API platform
IM API platform covers a comprehensive range, including iOS, Android, Web, Unity, Unreal Engine, C, Flutter, and Electron. https://intl.cloud.tencent.com/document/product/1047/34552?from=dev

Reliable technical support
Product details
Constant exchange of ideas Telegram group: https://t.me/tencent_imsdk Discord group: https://discord.gg/8EmN2ma25W

Do you know about Tencent Cloud?

Denize Chan — Wed, 03 Aug 2022 02:16:00 +0000

Tencent Cloud is the cloud business of global technology company Tencent with headquarters in Shenzhen, China. It provides users and businesses around the world with stable and cloud products and services, leveraging technological advancements such as cloud computing, big data analytics, AI, IoT and network security.

Tencent Cloud is a service that meets the needs of industries across the board, including the fields of education, finance, healthcare, gaming, media and entertainment, property, retail, travel and transportation. It also strives to help overseas businesses enter the China market through its China Connect solution and help Chinese enterprises to go global.

Tencent Cloud currently operates 70 availability zones in 26 geographical regions around the world, providing a strong infrastructure network that enables enterprises to expand across the globe.

Tencent Cloud offers over 400 cloud products & solutions to support enterprise digital transformation and is particularly strong in terms of audio & video, game and financial services solutions, as well as database solutions and security performance. It is also recognized by many top global analyst firms, including Gartner, IDC, Forrester, Frost & Sullivan and more.

Find out more at https://www.tencentcloud.com/