Sariska is a powerful and versatile platform that empowers to build innovative applications across a wide range of platforms, from IoT to Web to VR and beyond. Our integrated cross-platform SDK, coupled with our comprehensive APIs, provides the tools you need to create seamless and engaging user experiences.

Key Features

• Integrated Platform: Sariska's media transport layer seamlessly connects devices across various platforms, enabling hassle-free development for IoT, Web, VR, and more.

• Unified Development: Our unified SDK facilitates single-click deployment and debugging, streamlining the development process for cross-platform applications.

• Unparalleled Efficiency: Sariska delivers high-quality, low-latency media transport even in remote locations and on low-end devices, allowing you to scale to millions of users without compromising performance.

Getting Started

Embark on your Sariska journey, select your preferred programming language and dive right in. With just a few lines of code, integrate our services into your application within minutes. Our platform provides a comprehensive suite of APIs, SDKs, and helper tools to simplify the process.

Integration Process

1. Sign up: Create an account.

2. Authenticate: Obtain your API key.

3. Build: Integrate the SDK into your application.

To access, modify private information, or create any meaningful interaction with the Sariska API requires proper authentication. This is achieved through API keys, which are associated with your account. When making requests to the Sariska API, your application will need to provide an access token, which is used to identify the user. Each request your application sends to Sariska must also include an authorization token, which serves as a verification of your identity.

API Keys

API keys are always visible in your account dashboard. If you are not logged in, randomly generated API keys will be included in code examples. Replace these with your own API keys to ensure your application is using the correct credentials.

ID Tokens

Authentication in Sariska is handled using ID tokens, which are in JSON Web Token (JWT) format. ID tokens contain information that helps Sariska identify you as a user and confirms that you are authorized to access and modify information.

Protecting API Keys and Tokens

Your Sariska API keys are directly linked to your account and must be authorized before they can be used to make requests on your behalf.

• Never share your API keys with anyone you don't trust. This includes friends, family, and even co-workers.

• Store your API keys in a secure place. Don't write them down on paper or save them in a file that is easily accessible.

• Monitor your API usage regularly. This will help you to identify any unauthorized activity.

Regenerating API Keys

If you believe your API keys or tokens have been compromised, you should regenerate them immediately from the admin dashboard.

Granting Access to API Keys

Only grant access to API keys to those who need them. Do not include them in any version control systems you may be using.

Revoking API Keys

You can revoke API keys at any time if you no longer need them or suspect they have been compromised. You can also edit API keys to change their level of access.

Sariska enables seamless access to development tools around messaging, real-time video, audio, streaming, and interactive capabilities across platforms and devices. With this, we aim to build a new communication layer for a world that is centered around mixed reality such that digital and physical identities can coincide naturally.

From communication to streaming to interactivity, Sariska offers a comprehensive tech stack to build everything from tiny applications to endless worlds through simple, fast, and secure APIs and SDKs helping you to get from development to launch in a week.

Some of the core features we think you might be interested in are:

• Simplicity: Unified, easy-to-understand, and integrated SDKs, help you get live with your application in less than a day.

• Flexibility: Complete control over the features and development with fully modular components to make your application as lightweight as possible.

• Adaptive Relay: Real-time video and audio quality switching accounting for bandwidth and device capabilities with edge case handling delivering the best experience.

• Transparency: Real-time visibility from usage to bugs with powerful backend logging allows for fully dynamic pricing and error anticipation.

If you are new to Sariska, the following documentation can help you get started:

• On how to obtain an API Key

• Integrating RTM(Real Time Messaging), Media, and Interactive services into your own code

• Code samples to get you up and running in no time

Build things you love and enjoy. You bring creativity. We bring you tools that deliver high-quality performance every time.

If this is your first time using our APIs, please check out our getting started guide. If you already have your API key, our code samples could help you refine the results.

Real-time messaging (RTM) has become an integral part of modern communication, enabling seamless and instantaneous interactions between individuals and groups. Sariska's Real-Time Messaging API provides a powerful and versatile platform for incorporating RTM capabilities into your applications and systems.

At the core of Sariska RTM is the utilization of the Erlang programming language, renowned for its concurrency model, process isolation, and fault-tolerant design. Erlang's capabilities make it an ideal foundation for real-time messaging systems, ensuring high availability and reliability even in the face of unexpected failures. Erlang's process isolation strengthens the system's resilience by preventing the failure of one component from affecting others. Additionally, Erlang's unique hot reload capabilities allow for seamless updates and modifications to the system without interruption, ensuring continuous operation.

Sariska RTM's architecture is not only robust but also distributed, allowing for scalable and efficient communication across a network of interconnected nodes. This distributed nature enhances its ability to handle large volumes of traffic seamlessly.

Key Features

• Real-time communication: Deliver messages to users in real time, fostering continuous engagement and interaction.

• Scalable architecture: Handle millions of connected clients simultaneously, ensuring seamless communication even at large scale.

• Flexible channel management: Create and manage channels to organize and categorize messages effectively.

• Multi-platform support: Integrate RTM functionality into web, mobile, and game development environments.

One of the standout features of Sariska RTM is its integration with Phoenix Channels. Phoenix, built on top of the Erlang ecosystem, leverages the power of Erlang's concurrency, process isolation, and fault-tolerance to facilitate soft real-time communication among millions of connected clients. This makes Phoenix Channels an essential component of Sariska RTM, enabling the efficient and scalable exchange of messages between users and applications.

Use Cases

Sariska's Real-Time Messaging API caters to a wide range of applications, including:

• Chat rooms and messaging apps: Build real-time chat features for personal and professional communication.

• Breaking news and alerts: Deliver real-time notifications for urgent updates and critical events.

• Real-time tracking: Monitor the movement of objects, vehicles, or participants in real time.

• Multiplayer game interactions: Facilitate real-time communication and synchronization in multiplayer games.

• IoT device monitoring and control: Receive real-time sensor data and send control commands to IoT devices.

• Browser notifications: Notify users of page updates or changes in web applications.

API Structure and Terminology

Channel

Channels are a way to organize and manage real-time communication between clients and a server in Socket.IO. They allow you to send and receive events to specific groups of clients, and they can be used to create a variety of applications, such as chat rooms, multiplayer games, and collaborative editing tools.

Channel Prefix

Each channel name starts with a prefix that determines the message serialization format and persistence behavior.

chat: Use this prefix for persisting messages to the database. This prefix requires a fixed schema and is ideal for chat applications.

 channel = socket.channel("chat:room123");

rtc: Use this prefix for scenarios where message persistence is not necessary. This prefix allows sending arbitrary JSON data, making it suitable for events in multiplayer games, IoT applications, and others.

channel = socket.channel("rtc:room123");

sariska: Use this prefix for performance-critical applications that utilize Flatbuffers as the serialization format and do not require message persistence. This prefix provides zero-copy serialization/deserialization, significantly enhancing performance.

channel = socket.channel("sariska:room123");

API Endpoints

Establishing a Socket Connection

To establish a socket connection for real-time messaging, use the following URL:

wss://api.sariska.io/api/v1/messaging/websocket

Connection with Flatbuffers as a Serializer

For performance-critical applications, consider using Flatbuffers, which offers near-zero serialization/deserialization time compared to JSON on both the device and server ends. Flatbuffers is particularly well-suited for use with mmap (or streaming), as it requires only a portion of the buffer to be in memory. Access speed is comparable to raw struct access, with only one additional indirection (a Vtable) to accommodate format evolution and optional fields. For more details, refer to the Flatbuffers documentation.

To establish a connection for real-time messaging (RTM) with Flatbuffers enabled, use the following URL:

wss://api.sariska.io/api/v1/messaging/websocket/serializer

Platform Support

Sariska's real-time messaging SDK offers versatile cross-platform communication across browsers, Android, iOS, Mac, Windows, Linux, and gaming consoles.

• Server-side Phoenix Channel Implementations: Server-side implementations for Phoenix channels facilitate seamless message exchange from the server.

• Unity Integration: Integration with the Unity game engine enables bidirectional messaging within Unity's cross-platform environment.

• Godot Integration: Integration with the Godot game engine ensures bidirectional messaging within Godot's open-source ecosystem.

Sariska provides a JavaScript API and easy-to-integrate SDKs for web, mobile, front-end, and cloud infrastructure to add real-time features in your applications.

Key Features:

• Real-time messaging for in-app chats and instant messaging

• Support for various JavaScript frameworks (Vanilla, React, Angular, Vue, Electron, React Native)

• Easy installation using NPM or CDN

• Socket creation and management

• Channel creation, joining, and leaving

• Sending messages, poll votes, and message replies

• Presence management (track: typing, joining and leaving users)

• History management (fetching chat history and specific messages)

Installation

Step 1 : Install the Phoenix Library

Install the Phoenix library by running the following command in your project directory using NPM.

npm install phoenix

Alternatively, install the Phoenix library by adding the following script to your website's HTML <head> tag for seamless API access.

<script src="https://sdk.sariska.io/bundle.messaging.js"></script>

Step 2 : Create Socket

Establish a WebSocket connection to the Sariska server to join channels, receive events, and send messages.

const socket = new Socket("wss://api.sariska.io/api/v1/messaging/websocket", {token: "your-token"});
// Handles socket opening event
socket.onOpen = () => {
  console.log("Socket opened");
};
// Handles socket closing event
socket.onClose = () => {
  console.log("Connection dropped");
// Handles socket error events
socket.onError = () => {
  console.error("There was an error with the connection");
};

// Open connection to the server
socket.connect();

Disconnect Socket

Close the WebSocket connection to the Sariska server. This will terminate all active channels and prevent further communication with the server.

// Close connection to the server
socket.disconnect();

Step 3 : Create Channel

Channels cannot be created directly; instead, they are created through the socket object by calling socket.channel(topic) with the topic of the channel. The topic is a string that identifies the channel, and it can be any string you like.

Channel Prefix

Each channel name starts with a prefix that determines the message serialization format and persistence behavior.

chat: Use this prefix for persisting messages to the database. This prefix requires a fixed schema and is ideal for chat applications.

 let channel = socket.channel("chat:room123");

rtc: Use this prefix for scenarios where message persistence is not necessary. This prefix allows sending arbitrary JSON data, making it suitable for events in multiplayer games, IoT applications, and others.

let channel = socket.channel("rtc:room123");

sariska: Use this prefix for performance-critical applications that utilize Flatbuffers as the serialization format and do not require message persistence. This prefix provides zero-copy serialization/deserialization, significantly enhancing performance.

let channel = socket.channel("sariska:room123");

Handle Errors

When an error occurs on the channel, the onError callback is triggered. The callback receives the error information in payload, if available.

channel.onError( () => console.log("There was an error!") )

Close Channel

When the channel is closed, the onClose callback is invoked. This signifies that the communication on the channel has ended and no further data can be exchanged.

channel.onClose( () => console.log("Channel Closed") )

Step 4 : Join and Leave Channel

To join a channel, call the join() method on the channel object. The join() method returns a promise that resolves when the client has successfully joined the channel. When sending data, you can utilize the .receive() hook to monitor the status of the outgoing push message.

// Join the channel
channel.join()
    .receive("ok", ()=>console.log("Channel joined"))
    .receive("error", ()=>console.log("Failed to join"))
    .receive("timeout", () => console.log("Encountering network connectivity problems. Waiting for the connection to stabilize."))
    
// Leave the channel
channel.leave();

Channel User Joined

channel.on("user_joined", (payload) => {
  // Extract user and room information from the payload
  const user = payload.user;
  const room = payload.room;

  // Log the user and room details to the console
  console.log(user);
  console.log(room);
});

Channel New Message

channel.on("new_message", (message) => {
  // Log the received message to the console
  console.log(message);
});

Send Message

Once you've established a connection to a channel, you can start sending messages to other connected clients. To send a message, use the push() method on the channel object.

channel.push("new_message", {
   content: "Hi, From nick"
})

Send Message Reply

// Push a new message reply to the channel
channel.push("new_message_reply", {
   content: "How is the Weather today?",
   message_id: 1
})

Channel Poll Vote

channel.on("new_vote", (vote) => {
  // Log the received vote to the console
  console.log(vote);
});

Attach Media Files to Chat Messages

Attaching media files to chat messages involves obtaining a presigned URL, uploading the file to the presigned URL, and then sending the file information to the chat server.

Obtain a Presigned URL

To obtain a presigned URL, make a POST request to the API endpoint. The request payload should be empty, and the Authorization header should contain your bearer token.

let responseBody;
// Construct the request payload
const payload = {
    method: "POST",
    headers: {Authorizaton: "Bearer your-token"}
};
// Send the POST request to the API endpoint
const response = await fetch("https://api.sariska.io/api/v1/misc/get-presigned", payload);
// Check for successful response
if (response.ok) {
   responseBody = await response.json();
}

Upload the File

After obtaining the presigned URL, the file can be uploaded to the URL using the PUT method.

const file = event.target.files[0];
const signedUrl  = responseBody.presignedUrl;
const headers = {
   "ACL": "public-read",
   "Content-Disposition": "attachment"
}
await fetch(signedUrl, { 
   method: 'PUT',
   body: file, headers
   })

Chat History

Retrieve the chat history using two methods:

1. By Subscribing to Events

• Subscribe to the archived_message event to receive the last 1000 messages in reverse chronological order.

channel.on("archived_message", (messages)=> {
    // Handle received messages 
});

• Subscribe to the archived_message_count event to get the total number of messages in the chat history.

channel.on("archived_message_count", (payload)=> {
    const { page: { count } } = payload;
    // Log the received count of total messages to the console
    console.log(count);
});

• To retrieve a list of messages in the chat history, trigger the archived_message event to obtain the messages. Specify the size parameter to determine the number of messages you wish to fetch, and set the offset parameter as the starting index of the messages and group_by_day to group messages by day.

channel.push("archived_message", { page: { size: 100, offset: 0, group_by_day: false }});        

• To receive the total count of messages at any given time, initiate the archived_message_count trigger and subscribe to the corresponding event by listening for archived_message_count.

channel.push("archived_message_count");

1. Using the Messages API

Make a GET request to the API endpoint to fetch the chat history for a specific room.

const fetchChatHistory = async () => {
  // Construct the request payload
  const payload = {
    method: "GET",
    headers: { Authorizaton: "Bearer your-token" }
  };
  // Send the POST request to the API endpoint
  const response = await fetch("https://api.sariska.io/api/v1/messaging/rooms/{room_name}/messages", payload);
  // Check for successful response
  if (response.ok) {
  // Return the chat history data
    return await response.json();
  }
}

Fetch Specific Message

Retrieve any specific message from a room. It takes the room ID and message ID as parameters and sends a GET request to the Sariska API to fetch the specified message.

const fetchSpecificMessage = async () => {
  // Construct the request payload
  const payload = {
    method: "GET",
    headers: { Authorizaton: "Bearer your-token" }
  };
  // Send the GET request to the API endpoint
  const response = await fetch("https://api.sariska.io/api/v1/messaging/rooms/{room_name}/messages/{message_id}", payload);
  // Check for successful response
  if (response.ok) {
  // Return the specific message
    return await response.json();
  }
}

Delete Chat History

Delete chat history for a specific room.

Delete Single or Multiple Messages

const EmptyChat = async () => {
  // Construct the request payload
  const payload = {
    method: "DELETE",
    headers: { Authorizaton: "Bearer your-token" },
    body: JSON.stringify({
      message_ids: [message_id_1, message_id_2, ...],
      is_empty: false
    })
  };
  // Send the DELETE request to the API endpoint
  const response = await fetch("https://api.sariska.io/api/v1/messaging/rooms/{room_name}/messages", payload);
  // Check for successful response
  if (response.ok) {
    return await response.json();
  }
}

Delete All Chats

const EmptyChat = async () => {
  // Construct the request payload
  const payload = {
    method: "DELETE",
    headers: {Authorizaton: "Bearer your-token"},
    body: JSON.stringify({
      message_ids: [],
      is_empty: true
    })
  };
  // Send the DELETE request to the API endpoint
  const response = await fetch("https://api.sariska.io/api/v1/messaging/rooms/{room_name}/messages", payload);
  // Check for successful response
  if (response.ok) {
    return await response.json();
  }
}

Presence

The Presence object facilitates real-time synchronization of presence information between the server and the client, enabling the detection of user join and leave events.

Create a Presence Instance

To establish presence synchronization, instantiate a Presence object and provide the channel to track presence lifecycle events:

let channel = socket.channel("chat:room123")
let presence = Presence(channel)

State Synchronization

Utilize the presence.onSync callback to respond to state changes initiated by the server. For instance, to dynamically render the user list upon every list modification, implement the following:

presence.onSync(() => {
  myRenderUsersFunction(presence.list());
})

Handle Individual Join and Leave Events

The presence.onJoin and presence.onLeave callbacks allow for handling individual user join and leave events. Here is an instance:

let presence = new Presence(channel)

// Detect if the user has joined for the first time or from another tab/device
presence.onJoin((id, current, newPres) => {
  if(!current){
    console.log("User has joined for the first time", newPres)
  } else {
    console.log("User additional presence", newPres)
  }
})

// Detect if the user has left all tabs/devices, or is still present
presence.onLeave((id, current, leftPres) => {
  if(current.metas.length === 0){
    console.log("User has left from all devices", leftPres);
  } else {
    console.log("User left from a device", leftPres);
  }
})

// Receive presence data from server
presence.onSync(() => {
  presence.list(); // List of users
})

Retrieve Presence Information

The presence.list(by:) method retrieves a list of presence information based on the local metadata state. By default, it returns the entire presence metadata. Alternatively, a listBy function can be provided to filter the metadata for each presence.

For instance, if a user is online from multiple devices, each with a metadata status of "online," but their status is set to "away" on another device, the application might prefer to display the "away" status in the UI.

The following example defines a listBy function that prioritizes the first metadata registered for each user, representing the first tab or device they used to connect:

let listBy = (id, { metas: [first, ...rest] }) => {
  // Increment the presence count for the user
  first.count = rest.length + 1
  // Set the user ID for the presence metadata
  first.id = id
  // Return the prioritized presence metadata
  return first
}
// Retrieve a list of online users based on the prioritized presence metadata
let onlineUsers = presence.list(listBy) 

User Typing

Send information about a user who is typing. This information can be used to update the chat interface, such as displaying a "user is typing" indicator next to the user's name.

Send User Typing Event

When a user starts typing, the following code sends a typing event to other peers.

channel.push('user_typing', { typing: true })

Receive User Typing Event

Other peers in the chat can listen for the typing event on the same channel.

channel.on("user_typing", (typing_response) => {
     console.log(typing_response);
});

For detailed real-time messaging API's, refer to Phoenix documentation.

For detailed management of chat and room APIs, refer to Sariska Swagger documentation.

Sariska utilizes JSON Web Tokens (JWTs) to securely authenticate users and devices. JWTs are a standardized, structured, and self-contained method for conveying information between clients as JSON objects. They serve as a mechanism for asserting claims exchanged between two parties. In the context of a JWT, a claim is a declaration about a company or user, accompanied by additional metadata about the token itself. The payload, which is maintained in JSON format, contains a set of claims. JWTs are digitally signed and encrypted for enhanced security.

Sariska generates these tokens on its servers. A single token can be used to access all Sariska services.

async function fetchToken () {
   const payload = {
       method: "POST",
       headers: {
           'Content-Type': 'application/json"
       },
       body: JSON.stringify({
            apiKey: "{your-api-key}",
            user: {  // optional
                id: "ytyVgh",
                name: "Nick",
                email: "nick@gmail.com",
                avatar: "https://some-storage-location/nick.jpg",
                moderator: true
                // If participant is moderator set to true, otherwise leave blank.
                // Sariska will automatically appoint the first participant as moderator if the moderator leaves.
            }
       })
   };

   try {
       const response = await fetch("https://api.sariska.io/api/v1/misc/generate-token", payload);
       if (response.ok) {
          const json = await response.json();
          const token = json.token;
          return token;
       }
   } catch (error) {
      console.log(error);
   }
}
await fetchToken();

import 'dart:convert' as convert;
import 'package:http/http.dart' as http

String fetchToken() async {
  final body = {
    user: {
      // optional
      id: "ytyVgh",
      name: "Nick",
      email: "nick@gmail.com",
      avatar: "https://some-storage-location/nick.jpg",
      moderator: true
      // If participant is moderator set to true, otherwise leave blank.
      // Sariska will automatically appoint the first participant as moderator if the moderator leaves.
    },
    apiKey: "{your-api-key}"
  };

  var url = 'https://api.sariska.io/api/v1/misc/generate-token';
  final response = await http.post(url,
      headers: {"Content-Type": "application/json"}, body: body);
  if (response.statusCode == 200) {
    // If the server did return a 200 OK response,
    // then parse the JSON.
    var body = jsonDecode(response.body);
    return body['token'];
  } else {
    // If the server did not return a 200 OK response,
    // then throw an exception.
    throw Exception('Failed to load data');
  }
}


await fetchToken();

let json: [String: Any] = ["apiKey": "{your-api-key}"]

let body = try? JSONSerialization.data(withJSONObject: json)

guard let url = URL(string: "https://api.sariska.io/api/v1/misc/generate-token") else {
    fatalError("URL could not be reached")
}

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.httpBody = body
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue("application/json", forHTTPHeaderField: "Accept")
let session = URLSession.shared

let task = session.dataTask(with: request){
    (data, response, error) in
    if let data = data {
        if let token = String(data: data, encoding: String.Encoding.utf8){
            print(token)
        }
    }else{
        print(error ?? "Error with data in URLSession task")
    }
}

task.resume()

import org.phoenixframework.Channel
import org.phoenixframework.Socket
import okhttp3.*
import java.io.IOException

class PostForm {
   private val client = OkHttpClient()
   
   fun run(): Response {
      val formBody = FormBody.Builder().add("apiKey", "{your-api-key}").build()
      val request = Request.Builder()
        .url("https://api.sariska.io/api/v1/misc/generate-token").post(formBody)
        .addHeader("Accept", "application/json")
        .build()
    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code ${response.code()}")
      return response
    }
  }

fun main() {
  PostForm().run()
}

import android.annotation.TargetApi;
import android.os.Build;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.IOException;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class Utils {

    @TargetApi(Build.VERSION_CODES.KITKAT)

    public static String fetchToken() throws IOException {
        OkHttpClient client = new OkHttpClient();  
        
        final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
        String url = "https://api.sariska.io/api/v1/misc/generate-token";
        String json = "{\"apiKey\":\"{your-api-key}\"," +
                "\"user\":{\"id\":\"112233\"," +
                "\"name\":\"testUser\"," +
                "\"email\":\"test.user@sariska.io\"," +
                "\"moderator\":\"true\"," +
                "\"avatar\":\"null\"}}";

        RequestBody body = RequestBody.create(JSON, json);
        
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .addHeader("Content-Type", "application/json")
                .build();
                
        try(Response response = client.newCall(request).execute()){
            String responseString = response.body().string();
            responseString = "[" + responseString + "]";
            JSONArray array = new JSONArray(responseString);
            String finalResponse = null;
            for(int i=0; i < array.length(); i++) {
                JSONObject object = array.getJSONObject(i);
                finalResponse = object.getString("token");
            }
            return finalResponse;
        } catch (JSONException e) {
            e.printStackTrace();
            return null;
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.IO;
using System.Text;
using UnityEngine;

public class GenerateToken
{
    public static Token GetToken(string RoomName)
    {
        HttpWebRequest request;
        string data = "{\"apiKey\":\"{your-api-key}\"," +
                "\"user\":{\"id\":\"99266\"," +
                "\"name\":\"SpiderMan\"," +
                "\"email\":\"farfromhome@spideysense.com\"," +
                "\"avatar\":\"null\"}}";
        byte[] dataBytes = Encoding.UTF8.GetBytes(data);
        Debug.Log("Creating request");
        request = (HttpWebRequest)(WebRequest.Create("https://api.sariska.io/api/v1/misc/generate-token"));
        Debug.Log(request);
        Debug.Log("Done Creating request");
        request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
        request.ContentLength = dataBytes.Length;
        request.ContentType = "application/json";
        request.Method = "POST";
        using (Stream requestBody = request.GetRequestStream())
        {
            requestBody.Write(dataBytes, 0, dataBytes.Length);
        }
        HttpWebResponse response = (HttpWebResponse)request.GetResponse();
        Debug.Log(response.StatusCode + "Response Code");
        StreamReader reader = new StreamReader(response.GetResponseStream());
        string json = reader.ReadToEnd();
        return JsonUtility.FromJson<Token>(json);
    }
}

Sariska provides a Swift API and easy-to-integrate SDKs for building real-time features into your iOS, macOS, watchOS, and tvOS applications. Easily add in-app chats, instant messaging, and other real-time functionalities to your apps.

Key Features:

• Real-time messaging for in-app chats and instant messaging

• Easy installation using Cocoa Pods or Carthage

• Socket creation and management

• Channel creation, joining, and leaving

• Sending messages, poll votes, and message replies

• Presence management (track: typing, joining and leaving users)

• History management (fetching chat history and specific messages)

Installation

Step 1 : Install the Phoenix Client

Using Cocoa Pods

• To install SwiftPhoenixClient using CocoaPods, add the following line to your Podfile:

pod "SwiftPhoenixClient", '~> 2.0'

• If you are using RxSwift extensions, add the following line to your Podfile:

pod "SwiftPhoenixClient/RxSwift", '~> 2.0'

• If your version requirements require iOS 13 and below, add the following line to your Podfile:

pod "SwiftPhoenixClient/Starscream", '~> 2.0'

Using Carthage

To install SwiftPhoenixClient using Carthage, add the following line to your Cartfile:

github "davidstump/SwiftPhoenixClient" ~> 2.0

Step 2 : Create Socket

To establish a connection with Sariska's real-time messaging platform, you'll need to create a socket instance. This socket will handle joining channels, receiving events, and sending messages.

let token = {your-token}

let socket = Socket("wss://api.sariska.io/api/v1/messaging/websocket", { token: token })
/// Handles socket opening event
socket.onOpen { print("Socket Opened") }
/// Handles socket closing event
socket.onClose { print("Socket Closed") }
/// Handles socket error events
socket.onError { (error) in print("Socket Error", error) }

/// Enables logging for socket events
socket.logger = { message in print("LOG:", message) }

/// Opens connection to the server
socket.connect()

Disconnect Socket

Close the WebSocket connection to the Sariska server. This will terminate all active channels and prevent further communication with the server.

/// Close connection to the server
socket.disconnect()

/// Removes all event callback hooks, such as 'onOpen' and onClose
socket.releaseCallback()

Step 3 : Create Channel

Channels cannot be created directly; instead, they are created through the socket object by calling socket.channel(topic) with the topic of the channel. The topic is a string that identifies the channel, and it can be any string you like.

Channel Prefix

Each channel name starts with a prefix that determines the message serialization format and persistence behavior.

chat: Use this prefix for persisting messages to the database. This prefix requires a fixed schema and is ideal for chat applications.

 let channel = socket.channel("chat:room123");

rtc: Use this prefix for scenarios where message persistence is not necessary. This prefix allows sending arbitrary JSON data, making it suitable for events in multiplayer games, IoT applications, and others.

let channel = socket.channel("rtc:room123");

sariska: Use this prefix for performance-critical applications that utilize Flatbuffers as the serialization format and do not require message persistence. This prefix provides zero-copy serialization/deserialization, significantly enhancing performance.

let channel = socket.channel("sariska:room123");

Handle Errors

When an error occurs on the channel, the onError callback is triggered. The callback receives the error information in payload, if available.

channel.onError { (payload) in print("Error: ", payload) }

Close Channel

When the channel is closed, the onClose callback is invoked. This signifies that the communication on the channel has ended and no further data can be exchanged.

channel.onClose { (payload) in print("Channel Closed") }

Step 4 : Join and Leave Channel

To join a channel, call the join() method on the channel object. The join() method returns a promise that resolves when the client has successfully joined the channel. When sending data, you can utilize the .receive() hook to monitor the status of the outgoing push message.

/// Join the Channel
channel.join()
    .receive("ok") { message in print("Channel Joined", message.payload) }
    .receive("error") { message in print("Failed to join", message.payload) }

/// Leave the Channel
channel.leave()

Channel User Joined

/// Subscribe to the "new_user" event, when new user join the room
channel.on("new_user") { [weak self] (message) in
    /// Extract the username from the message payload
    let username = message.payload["username"] as? String
    /// Print a message indicating that the new user has joined the room
    print("\(username) has joined the room!")
}

Channel New Message

channel.on("new_msg") { [weak self] (message) in
    /// Extract the payload from the message
    let payload = message.payload
    /// Extract the content from the payload
    let content = payload["content"] as? String
    /// Extract the username from the payload
    let username = payload["username"] as? String
    /// Print the message to the console
    print("\(username) sent the message: \(content)")
}

Send Message

Once you've established a connection to a channel, you can start sending messages to other connected clients. To send a message, use the push() method on the channel object.

channel
    /// Send a message with payload
    .push("new_messgage", payload: ["body": "message body"])
    /// Receive a response message
    .receive("ok", handler: { (payload) in
    print("Message Sent")
    })

Send Message Reply

channel
    /// Send a message with payload
    .push("new_messgage_reply", payload: ["body": "message body"])
    /// Receive a response message
    .receive("ok", handler: { (payload) in
    print("Message Sent")
    })

Channel Poll Vote

let pollOptions = ["Option 1", "Option 2", "Option 3"]
/// Build the payload with the poll question, content type, and options
let payload: [String: Any] = [
    "content": "poll question?",
    "content_type": "poll",
    "options": pollOptions
]

/// Send the new_vote event with the payload
channel
    .push("new_vote", payload: payload)
    .receive("ok", handler: { (payload) in
        print("Poll Vote Sent")
    })

Attach Media Files to Chat Messages

Attaching media files to chat messages involves obtaining a presigned URL, uploading the file to the presigned URL, and then sending the file information to the chat server.

Obtain a Presigned URL

To obtain a presigned URL, make a POST request to the API endpoint. The request payload should be empty, and the Authorization header should contain your bearer token. The bearer token authenticates the request and returns a URL that can be used to upload content.

import Foundation

func getPresignedURL() async throws -> URL {
    let url = URL(string: "https://api.sariska.io/api/v1/misc/get-presigned")!
    var request = URLRequest(url: url)
    /// Set the HTTP method to `POST`
    request.httpMethod = "POST"
    /// Add bearer token to the Authorization header
    request.setValue("Bearer your-token", forHTTPHeaderField: "Authorization")

    let (data, _) = try await URLSession.shared.data(from: request)
    let responseBody = try JSONDecoder().decode(ResponseBody.self, from: data)
    return URL(string: responseBody.presignedUrl)!
}

Upload the File

After obtaining the presigned URL, the file can be uploaded to the URL using the PUT method.

func uploadFile(fileURL: URL) async throws {
    /// Retrieve the pre-signed URL for uploading the file
    let presignedURL = try await getPresignedURL()
    /// Read the contents of the file into a `Data` object
    let fileData = try Data(contentsOf: fileURL)
    
    /// Create a `URLRequest` object with the pre-signed URL
    var request = URLRequest(url: presignedURL)
    /// Set the HTTP method to `PUT`
    request.httpMethod = "PUT"
    /// Set the ACL header to "public-read" to make the file publicly accessible
    request.setValue("public-read", forHTTPHeaderField: "ACL")
    /// Set the Content-Disposition header to "attachment" to indicate that the response is a file attachment
    request.setValue("attachment", forHTTPHeaderField: "Content-Disposition")
    
    /// Upload the file data using the `URLSession` object
    try await URLSession.shared.upload(for: request, from: fileData)
}

/// Codable struct to represent the response body
struct ResponseBody: Codable {
    let presignedUrl: String
}

let fileURL = /// URL to the file you want to upload
do {
    try await uploadFile(fileURL: fileURL)
    print("File uploaded successfully.")
} catch {
    print("Error uploading file: \(error)")
}

Chat History

Retrieve the chat history using two methods:

1. By Subscribing to Events

• Subscribe to the archived_message event to receive the last 1000 archived messages in reverse chronological order.

channel.on("archived_message") { (payload) in
    if let messages = payload["messages"] as? [String: Any] {
        /// Print the received messages
        print("Received archived messages: \(messages)")
    }
}

• Subscribe to the archived_message_count event to get the total number of messages in the chat history.

channel.on("archived_message_count") { (payload) in
    if let page = payload["page"] as? [String: Any],
       let count = page["count"] as? Int {
        /// Print the received message count
        print("Total message count: \(count)")
    }
}

• To retrieve a list of messages in the chat history, trigger the archived_message event to obtain the messages. Specify the size parameter to determine the number of messages you wish to fetch, and set the offset parameter as the starting index of the messages and group_by_day to group messages by day.

channel.push("archived_message", payload: ["page": ["offset": 20, "size": 20, "group_by_day": false ]])

• To receive the total count of messages at any given time, initiate the archived_message_count trigger and subscribe to the corresponding event by listening for archived_message_count.

channel.push("archived_message_count")

1. Using the Messages API

Make a GET request to the API endpoint to fetch the chat history for a specific room.

func fetchChatHistory(completion: @escaping (Result<[String: Any], Error>) -> Void) {
    /// Construct the request URL
    let url = URL(string: "https://api.sariska.io/api/v1/messaging/rooms/{room_name}/messages")!
    
    /// Modify the request to use the GET method
    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.addValue("Bearer your-token", forHTTPHeaderField: "Authorization")

    /// Send the GET request to the API endpoint
    URLSession.shared.dataTask(with: request) { (data, response, error) in
        /// Check for errors
        if let error = error {
            completion(.failure(error))
            return
        }

        /// Check for successful response
        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
            let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
            let errorMessage = "Failed with status code \(statusCode)"
            let error = NSError(domain: "APIError", code: statusCode, userInfo: [NSLocalizedDescriptionKey: errorMessage])
            completion(.failure(error))
            return
        }

        /// Parse the response data
        do {
            if let data = data {
                let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
                completion(.success(json ?? [:]))
            } else {
                completion(.success([:]))
            }
        } catch {
            completion(.failure(error))
        }
    }.resume()
}

fetchChatHistory { result in
    switch result {
    case .success(let chatHistory):
        print("Chat history: \(chatHistory)")
    case .failure(let error):
        print("Error fetching chat history: \(error)")
    }
}

Fetch Specific Message

Retrieve any specific message from a room. It takes the room ID and message ID as parameters and sends a GET request to the Sariska API to fetch the specified message.

func fetchSpecificMessage(messageID: String, completion: @escaping (Result<[String: Any], Error>) -> Void) {
    /// Construct the request URL
    let urlString = "https://api.sariska.io/api/v1/messaging/rooms/{room_name}/messages/\(messageID)"
    guard let url = URL(string: urlString) else {
        completion(.failure(NSError(domain: "InvalidURL", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"])))
        return
    }

    /// Construct the request
    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.addValue("Bearer your-token", forHTTPHeaderField: "Authorization")

    /// Send the GET request to the API endpoint
    URLSession.shared.dataTask(with: request) { (data, response, error) in
        // Check for errors
        if let error = error {
            completion(.failure(error))
            return
        }

        /// Check for successful response
        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
            let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
            let errorMessage = "Failed with status code \(statusCode)"
            let error = NSError(domain: "APIError", code: statusCode, userInfo: [NSLocalizedDescriptionKey: errorMessage])
            completion(.failure(error))
            return
        }

        /// Parse the response data
        do {
            if let data = data {
                let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
                completion(.success(json ?? [:]))
            } else {
                completion(.success([:]))
            }
        } catch {
            completion(.failure(error))
        }
    }.resume()
}

let messageId = "your-message-id"
fetchSpecificMessage(messageID: messageId) { result in
    switch result {
    case .success(let specificMessage):
        print("Specific message: \(specificMessage)")
    case .failure(let error):
        print("Error fetching specific message: \(error)")
    }
}

Presence

The Presence object facilitates real-time synchronization of presence information between the server and the client, enabling the detection of user join and leave events.

Create a Presence Instance

To establish presence synchronization, instantiate a Presence object and provide the channel to track presence lifecycle events:

let channel = socket.channel("some:topic")
let presence = Presence(channel)

Custom Event Options

By default, the Presence object uses built-in events for syncing state changes. However, you can configure the Presence object to use custom events instead. This allows you to better integrate with your existing application logic.

let options = Options(events: [.state: "my_state", .diff: "my_diff"])
let presence = Presence(channel, opts: options)

State Synchronization

The presence.onSync callback triggers whenever the server updates the presence list. This allows you to update your UI based on the latest presence information, such as dynamically generating a user list.

presence.onSync { renderUsers(presence.list()) }

Handle Individual Join and Leave Events

To handle individual join and leave events, use the presence.onJoin and presence.onLeave callbacks. These provide information about the user and their presence state. Here is an instance:

let presence = Presence(channel)

/// Detect if the user has joined for the first time or from another tab/device
presence.onJoin { [weak self] (key, current, newPres) in
  if let cur = current {
    print("user additional presence", cur)
  } else {
    print("user entered for the first time", newPres)
  }
}

/// Detect if the user has left all tabs/devices, or is still present
presence.onLeave { [weak self] (key, current, leftPres) in
  if current["metas"]?.isEmpty == true {
    print("user has left from all devices", leftPres)
  } else {
    print("user left from a device", current)
  }
}

/// Receive presence data from server
presence.onSync { renderUsers(presence.list()) }

Retrieve Presence Information

The presence.list(by:) method retrieves a list of presence information based on the local metadata state. By default, it returns the entire presence metadata. Alternatively, a listBy function can be provided to filter the metadata for each presence.

For instance, if a user is online from multiple devices, each with a metadata status of "online," but their status is set to "away" on another device, the application might prefer to display the "away" status in the UI.

The following example defines a listBy function that prioritizes the first metadata registered for each user, representing the first tab or device they used to connect:

let listBy: (String, Presence.Map) -> Presence.Meta = { id, pres in
  let first = pres["metas"]!.first!
  first["count"] = pres["metas"]!.count
  /// Set the user ID for the presence metadata
  first["id"] = id
  /// Return the prioritized presence metadata
  return first
}
/// Retrieve a list of online users based on the prioritized presence metadata
let onlineUsers = presence.list(by: listBy)

User Typing

Send information about a user who is typing. This information can be used to update the chat interface, such as displaying a "user is typing" indicator next to the user's name.

Send User Typing Event

When a user starts typing, the following code sends a typing event to other peers.

channel.push("user_typing", payload: ["typing": true ])

Receive User Typing Event

Other peers in the chat can listen for the typing event on the same channel.

channel.on("user_typing") { [weak self] (typing_response) in 
    print("\(typing_response)!")
}

Handle Automatic Retain Cycle

The Sariska client library offers an optional API to automatically manage retain cycles for event hooks, simplifying your code and preventing memory leaks.

How it works:

• Each event hook has a corresponding delegate*(to:) method.

• This method takes a reference to an owner object and passes it back to the event hook.

• When the owner object is deinitialized, the associated event hook is automatically dereferenced, preventing retain cycles.

Benefits:

• Cleaner API: Eliminates the need for [weak self] capture lists, making your code more concise and readable.

• Reduced memory leaks: Automatic retain cycle management ensures efficient memory usage and avoids potential crashes.

/// Manual approach
socket.onOpen { [weak self] self?.addMessage("Socket Opened") }

/// Automatic approach
socket.delegateOnOpen(to: self) { (self) in self.addMessage("Socket Opened") }

/// Manual approach
channel.on("new_user") { [weak self] (message) in self?.handle(message) }

/// Automatic approach
channel.delegateOn("new:msg", to: self) { (self, message) in self.handle(message) }

/// Manual approach
channel.join().receive("ok") { [weak self] self?.onJoined() }

/// Automatic approach
channel.join().delegateReceive("ok", to: self, callback: { (self, message) in self.onJoined() }

For detailed real-time messaging API's, refer to Phoenix documentation.

For detailed management of chat and room APIs, refer to Sariska Swagger documentation.

Introduction

The growing network of broadband connections, paired with the arrival of 4G and now 5G services, has provided a unique opportunity to look beyond the bandwidth savings model for video conferencing, and rather focus on optimizing the cost of media delivery through intelligent systems over standard configurations.

From communication to streaming to interactivity, SARISKA offers a comprehensive tech stack to build everything from tiny applications to endless worlds through simple, fast, and secure APIs and SDKs helping you to get from development to launch in a week.

Scaling

Jitsi’s architecture allows for dynamic scaling in real time. In addition to being powerful and optimized, JVBs are built to scale, which makes them more dynamic for media transport.

Scaling the audio/video conferencing architecture is made easier with the usage of Jisti Videobridges due to the separation of the signaling layer from the transport layer.

Live Streaming

Sariska lets you also live-stream your video conference. Sariska addresses the challenges of concurrent streaming and latency by using a media server called SRS (Simple Realtime Server), which is a simple, high-efficiency, and real-time video server supporting RTMP/WebRTC/HLS/DASH/HTTP-FLV/SRT protocols.

SRS is used as a real-time media delivery server on top of our video conferencing architecture. This enables you to push your streams through multiple outlets in a single click with simulcast-enabled live streaming and reach your audience across every platform.

STUN/TURN Servers

If you are using Sariska then media is routed through the Jitsi Video bridge. If you have your own WebRTC set up and you need only stun/turn servers for NAT Traversal. Please check out the details below.

SARISKA also provides DNS-based load balanced turn servers, DNS-based load balancing is a specific type of load balancing that uses the DNS to distribute traffic across several servers. It does this by providing different IP addresses in response to DNS queries which are highly available and available to near your location.

you can fetch usernames and passwords to use with turn servers.

A TURN server is a media relay/proxy that allows peers to exchange UDP or TCP media traffic whenever one or both parties are behind NAT.

with UDP:

with TCP:

The STUN server allows clients to find out their public address, the type of NAT they are behind, and the Internet side port associated by the NAT with a particular local port

Welcome to the Awesome Chat API documentation! This API offers a robust set of endpoints for creating and managing chat platforms. Features include Room Management, Message Handling, Polls, Chat History, Message Replies, Room Role-Based Access Control (RBAC), Admin Moderation, User Management, Attachments, Emojis and Efficient Search Capabilities.

Get started by obtaining your API key and referring to detailed documentation for each endpoint. Ensure proper authentication and authorization for secure integration. Create a dynamic and feature-rich chat platform with the Awesome Chat API!

Sariska provides a Kotlin API and easy-to-integrate SDKs for building real-time features into your android applications. Easily add in-app chats, instant messaging, and other real-time functionalities to your apps.

Key Features:

• Real-time messaging for in-app chats and instant messaging

• Easy installation

• Socket creation and management

• Channel creation, joining, and leaving

• Sending messages, poll votes, and message replies

• Presence management (track: typing, joining and leaving users)

• History management (fetching chat history and specific messages)

Installation

Step 1 : Install the Phoenix Client

JavaPhoenixClient is hosted on MavenCentral. To install it, you'll need to add the following repositories and dependencies to your project's build configuration:

• Repositories

• Dependencies

Step 2 : Create Socket

Establish a WebSocket connection to the Sariska server to join channels, receive events, and send messages.

Disconnect Socket

Close the WebSocket connection to the Sariska server. This will terminate all active channels and prevent further communication with the server.

Step 3 : Create Channel

Channels cannot be created directly; instead, they are created through the socket object by calling socket.channel(topic) with the topic of the channel. The topic is a string that identifies the channel, and it can be any string you like.

Channel Prefix

Each channel name starts with a prefix that determines the message serialization format and persistence behavior.

chat: Use this prefix for persisting messages to the database. This prefix requires a fixed schema and is ideal for chat applications.

rtc: Use this prefix for scenarios where message persistence is not necessary. This prefix allows sending arbitrary JSON data, making it suitable for events in multiplayer games, IoT applications, and others.

sariska: Use this prefix for performance-critical applications that utilize Flatbuffers as the serialization format and do not require message persistence. This prefix provides zero-copy serialization/deserialization, significantly enhancing performance.

Step 4 : Join and Leave Channel

To join a channel, call the join() method on the channel object. The join() method returns a promise that resolves when the client has successfully joined the channel. When sending data, you can utilize the .receive() hook to monitor the status of the outgoing push message.

Channel User Joined

Channel New Message

Send Message

Once you've established a connection to a channel, you can start sending messages to other connected clients. To send a message, use the push() method on the channel object.

Send Message Reply

Channel Poll Vote

Attach Media Files to Chat Messages

Attaching media files to chat messages involves obtaining a presigned URL, uploading the file to the presigned URL, and then sending the file information to the chat server.

Obtain a Presigned URL

To obtain a presigned URL, make a POST request to the API endpoint.

Upload the File

After obtaining the presigned URL, the file can be uploaded to the URL using the PUT method.

Chat History

Retrieve the chat history using two methods:

1. By Subscribing to Events

• Subscribe to the archived_message event to receive the last 1000 messages in reverse chronological order.

• Subscribe to the archived_message_count event to get the total number of messages in the chat history.

• To retrieve a list of messages from the chat history, trigger the archived_message event to obtain the messages. Specify the size parameter to determine the number of messages you wish to fetch, and set the offset parameter as the starting index of the messages.

• To receive the total count of messages at any given time, initiate the archived_message_count trigger and subscribe to the corresponding event by listening for archived_message_count

1. By Using the Messages API

Make a GET request to the API endpoint to fetch the chat history for a specific room.

Fetch Specific Message

Retrieve any specific message from a room. It takes the room ID and message ID as parameters and sends a GET request to the Sariska API to fetch the specified message.

Delete Chat History

Delete chat history for a specific room.

Delete Single or Multiple Messages

Delete All Chats

Presence

The Presence object facilitates real-time synchronization of presence information between the server and the client, enabling the detection of user join and leave events.

Create a Presence Instance

To establish presence synchronization, instantiate a Presence object and provide the channel to track presence lifecycle events:

State Synchronization

Utilize the presence.onSync callback to respond to state changes initiated by the server. For instance, to dynamically render the user list upon every list modification, implement the following:

Handle Individual Join and Leave Events

The presence.onJoin and presence.onLeave callbacks allow for handling individual user join and leave events. Here is an instance:

Retrieve Presence Information

The presence.list(by:) method retrieves a list of presence information based on the local metadata state. By default, it returns the entire presence metadata. Alternatively, a listBy function can be provided to filter the metadata for each presence.

For instance, if a user is online from multiple devices, each with a metadata status of "online," but their status is set to "away" on another device, the application might prefer to display the "away" status in the UI.

The following example defines a listBy function that prioritizes the first metadata registered for each user, representing the first tab or device they used to connect:

User Typing

Send information about a user who is typing. This information can be used to update the chat interface, such as displaying a "user is typing" indicator next to the user's name.

Send User Typing Event

When a user starts typing, the following code sends a typing event to other peers.

Receive User Typing Event

Other peers in the chat can listen for the typing event on the same channel.

Sariska provides a Dart API and easy-to-integrate SDKs for building real-time features into your applications. Easily add in-app chats, instant messaging, and other real-time functionalities to your apps.

Key Features:

• Real-time messaging for in-app chats and instant messaging

• Easy installation

• Socket creation and management

• Channel creation, joining, and leaving

• Sending messages, poll votes, and message replies

• Presence management (track: typing, joining and leaving users)

• History management (fetching chat history and specific messages)

Installation

Step 1 : Install the Phoenix Client

• With Dart

• With Flutter

Step 2 : Create Socket

Establish a WebSocket connection to the Sariska server to join channels, receive events, and send messages.

Disconnect Socket

Close the WebSocket connection to the Sariska server. This will terminate all active channels and prevent further communication with the server.

Step 3 : Create Channel

Channels cannot be created directly; instead, they are created through the socket object by calling socket.channel(topic) with the topic of the channel. The topic is a string that identifies the channel, and it can be any string you like.

Channel Prefix

Each channel name starts with a prefix that determines the message serialization format and persistence behavior.

chat: Use this prefix for persisting messages to the database. This prefix requires a fixed schema and is ideal for chat applications.

rtc: Use this prefix for scenarios where message persistence is not necessary. This prefix allows sending arbitrary JSON data, making it suitable for events in multiplayer games, IoT applications, and others.

sariska: Use this prefix for performance-critical applications that utilize Flatbuffers as the serialization format and do not require message persistence. This prefix provides zero-copy serialization/deserialization, significantly enhancing performance.

Handle Errors

When an error occurs on the channel, the onError callback is triggered. The callback receives the error information in payload, if available.

Close Channel

When the channel is closed, the onClose callback is invoked. This signifies that the communication on the channel has ended and no further data can be exchanged.

Step 4 : Join and Leave Channel

To join a channel, call the join() method on the channel object. The join() method returns a promise that resolves when the client has successfully joined the channel. When sending data, you can utilize the .receive() hook to monitor the status of the outgoing push message.

Channel User Joined

Channel New Message

Handle Message

Receive all events for specialized message processing prior to dispatching to channel-specific callbacks. Ensure the payload is returned, regardless of modification status.

Send Message

Once you've established a connection to a channel, you can start sending messages to other connected clients. To send a message, use the push() method on the channel object.

Send Message Reply

Channel Poll Vote

Attach Media Files to Chat Messages

Attaching media files to chat messages involves obtaining a presigned URL, uploading the file to the presigned URL, and then sending the file information to the chat server.

Install Dependencies

Obtain a Presigned URL

To obtain a presigned URL, make a POST request to the API endpoint. The request payload should be empty, and the Authorization header should contain your bearer token.

Upload the File

After obtaining the presigned URL, the file can be uploaded to the URL using the PUT method.

Chat History

Retrieve the chat history using two methods:

1. By Subscribing to Events

• Subscribe to the archived_message event to receive the last 1000 messages in reverse chronological order.

• Subscribe to the archived_message_count event to get the total number of messages in the chat history.

• To retrieve a list of messages in the chat history, trigger the archived_message event to obtain the messages. Specify the size parameter to determine the number of messages you wish to fetch, and set the offset parameter as the starting index of the messages and group_by_day to group messages by day.

• To receive the total count of messages at any given time, initiate the archived_message_count trigger and subscribe to the corresponding event by listening for archived_message_count.

1. Using the Messages API

Make a GET request to the API endpoint to fetch the chat history for a specific room.

Fetch Specific Message

Retrieve any specific message from a room. It takes the room ID and message ID as parameters and sends a GET request to the Sariska API to fetch the specified message.

Delete Chat History

Delete chat history for a specific room.

Delete Single or Multiple Messages

Delete All Chats

Presence

The Presence object facilitates real-time synchronization of presence information between the server and the client, enabling the detection of user join and leave events.

Create a Presence Instance

To establish presence synchronization, instantiate a Presence object and provide the channel to track presence lifecycle events:

State Synchronization

Utilize the presence.onSync callback to respond to state changes initiated by the server. For instance, to dynamically render the user list upon every list modification, implement the following:

Handle Individual Join and Leave Events

The presence.onJoin and presence.onLeave callbacks allow for handling individual user join and leave events. Here is an instance:

Retrieve Presence Information

The presence.list(by:) method retrieves a list of presence information based on the local metadata state. By default, it returns the entire presence metadata. Alternatively, a listBy function can be provided to filter the metadata for each presence.

For instance, if a user is online from multiple devices, each with a metadata status of "online," but their status is set to "away" on another device, the application might prefer to display the "away" status in the UI.

The following example defines a listBy function that prioritizes the first metadata registered for each user, representing the first tab or device they used to connect:

User Typing

Send information about a user who is typing. This information can be used to update the chat interface, such as displaying a "user is typing" indicator next to the user's name.

Send User Typing Event

When a user starts typing, the following code sends a typing event to other peers.

Receive User Typing Event

Other peers in the chat can listen for the typing event on the same channel.