Send your first message

Sendbird Chat SDK for Flutter is a development kit that enables an easy and fast integration of standard chat features into client apps. On the client-side implementation, you can initialize and configure the chat with minimal effort. On the server-side, Sendbird ensures reliable infra-management services for your chat within the app.

If you are looking to build an app with chat features, we recommend you build a client app on top of our sample app. If you already have an app and you are looking to add chat to it, proceed with this guide to integrate chat into your app. This guide walks you through installing the Chat SDK in your app, creating a channel, and sending your first message to the channel.

Note: To learn how to integrate Sendbird Chat SDK for Flutter with a third-party UI plugin, see our Flutter chat tutorial.

The minimum requirements for Chat SDK for Flutter are the following.

• Xcode 9 or later
• Android studio 4.4 or later
• Dart 2.12.0 or later
• Flutter 2.0.0 or later

Note: The Sendbird server supports Transport Layer Security (TLS) from versions 1.0 up to 1.3. For example, in the server regions where TLS 1.3 isn't available, lower versions from 1.0 to 1.2 will be sequentially supported for secure data transmission.

Before installing Sendbird Chat SDK, you need to create a Sendbird application on Sendbird Dashboard, which comprises everything required in a chat service including users, messages, and channels. You need the Application ID of your Sendbird application from the dashboard when initializing the Chat SDK.

1. Go to Sendbird Dashboard and create an account. If you already have a Sendbird account, sign into your account.

2. Create a new application by clicking Create + at the bottom right of your screen.

3. Enter a name for your application. Choose a Product Type and Region. Then, click Confirm.

4. Click the application you just created under Applications. You will see the application's Application ID which you will need when initializing the Chat SDK.

Each Sendbird application can be integrated with a single client app. Within the same application, users can communicate with each other across all platforms, whether they are on mobile devices or on the web.

Sendbird provides various access control options when using the Chat SDK. By default, the following attributes are turned on to avoid unexpected errors when creating sample apps and sending your first message:

• Allow retrieving user list
• Allow updating user metadata
• Allow creating open channels
• Allow creating group channels

However, this may grant access to unwanted data or operations, leading to potential security concerns. To manage your access control settings, you can turn on or off each option in Settings > Application > Security > Access control list on Sendbird Dashboard.

To send a message in a client app, you should install, build, and configure an in-app chat using Sendbird Chat SDK, which can be installed through pub.dev.

Create a dependency and add the following code to your package's pubspec.yaml file.

dependencies:
    sendbird_sdk: ^3.1.15

Install packages from the command line.

$ flutter pub get

You can run the following import statement to start using all classes and methods.

import 'package:sendbird_sdk/sendbird_sdk.dart'

Now, initialize the Chat SDK in the app to allow the SDK to respond to changes in the connection status of Flutter client apps. Initialization requires your Sendbird application's Application ID, which can be found on Sendbird Dashboard.

// Initialize the SendbirdSdk instance to use APIs in your app.

final sendbird = SendbirdSdk(appId: APP_ID);

Note: The constructor of a SendbirdSdk instance must be called across a client app at least once. We recommend that you initialize the Chat SDK in main.dart and use its variable across your application.

You need a user in order to send a message to a channel. You can either create a user on our dashboard or you can use a unique ID that hasn't been taken by any of your Sendbird application users. In the latter case, a new user is automatically created in your Sendbird application before being connected.

To learn about using an access token to authenticate a user, see the authentication page.

// USER_ID should be a unique string to your Sendbird application.

try {
    final user = await sendbird.connect("USER_ID");
    // The user is connected to the Sendbird server.
} catch (e) {
    // Handle error.
}

Create an open channel using the following code. Open channels are where all users in your Sendbird application can easily participate without an invitation. When creating an open channel, you should pass the OpenChannelParams class as a parameter.

try {
    final openChannel = await OpenChannel.createChannel(OpenChannelParams());
    // An open channel is successfully created.
    // You can get the open channel's data from the result object.
} catch (e) {
    // Handle error.
}

Note: You can also create a group channel to send a message. To learn more, see create a channel.

Enter the open channel to send and receive messages.

// CHANNEL_URL below can be retrieved using openChannel.channelUrl.

try {
    final openChannel = await OpenChannel.getChannel(CHANNEL_URL);
    // Call the instance method of the result object in the openChannel parameter of the callback method.
    await openChannel.enter();
    // The current user successfully enters the open channel as a participant,
    // and can chat with other users in the channel using APIs.
} catch (e) {
    // Handle error.
}

Finally, send a message to the channel. To learn more about the types of messages you can send, see the message page.

try {
    final params = UserMessageParams(message: MESSAGE)
        ..data = DATA
        ..customType = CUSTOM_TYPE;

    final preMessage = openChannel.sendUserMessage(params, onCompleted: (msg, error) {
        // The message is successfully sent to the channel.
        // The current user can receive messages from other users
        // through the onMessageReceived() method in event handlers.
    });
} catch (e) {
    // Handle error.
}

Add the onMessageReceived() channel event handler using the addChannelHandler() method so that you can receive the message you just sent to the channel. You can also see the message on the dashboard.

class MyClass with ChannelEventHandler {
    // Add this class through sendbird.addChannelEventHandler(UNIQUE_HANDLER_ID, this).

    @override
    void onMessageReceived(BaseChannel channel, BaseMessage message) {
        // Receive a new message.
    }
}