Subscribe to Channel via WebSocket

npm install @zcatalyst/datastreams

    com.zoho.catalyst
    datastreams
    LATEST

pip install zcatalyst-sdk

const { DataStreamsWebSocket } = require('@zcatalyst/datastreams');

const socket = new DataStreamsWebSocket({
    url: token.url,
    zuid: token.wss_id,
    key: token.key,
    enableLogging: true  // Optional: enable debug logging
});

import com.zc.component.datastream.ZCDatastream;
import com.zc.component.datastream.beans.ZCDataStreamsConfig;
import com.zc.component.datastream.websocket.ZCDataStreamsWebSocket;

ZCDatastream datastream = ZCDatastream.getInstance();

ZCDataStreamsConfig config = new ZCDataStreamsConfig(
    tokenResponse.getUrl(),
    tokenResponse.getWssId(),
    tokenResponse.getKey(),
    false  // enableLogging
);

ZCDataStreamsWebSocket socket = datastream.createWebSocketClient(config);

from zcatalyst_sdk.datastreams.websocket_client import DataStreamsWebSocket
from zcatalyst_sdk.types.datastreams import DataStreamsConfig

config = DataStreamsConfig(
    url=token["url"],
    zuid=token["wss-id"],
    key=token["key"],
    enable_logging=True
)

socket = DataStreamsWebSocket(config=config)

// Listen for connection opened
socket.on('open', () => {
    console.log('Connected! Subscribing to channel...');
    
    // Subscribe with your chosen subscriber type
    socket.subscribe('0');  // Live events only
    // socket.subscribe('-1');  // Earliest available
    // socket.subscribe('-2');  // Resume
    // socket.subscribe('16965000000027481');  // From specific streaming ID
});

// Listen for incoming messages
socket.on('message', (event) => {
    console.log('Received:', event.data);
    console.log('Streaming ID:', event.streamingId);
    
    // Process your message here
    // ...
    
    // CRITICAL: Always send acknowledgement to receive next message
    socket.sendAck();
});

// Listen for errors
socket.on('error', (err) => {
    console.error('Error:', err.code, err.message);
});

// Listen for connection closed
socket.on('close', () => {
    console.log('Connection closed');
});

import com.zc.component.datastream.websocket.ZCDataStreamsEventListener;
import com.zc.component.datastream.beans.ZCCustomEvent;
import com.zc.component.datastream.beans.ZCDataStreamMessageEvent;

socket.addEventListener(new ZCDataStreamsEventListener() {
    @Override
    public void onOpen(ZCCustomEvent event) {
        System.out.println("Connected! Subscribing to channel...");
        
        // Subscribe with your chosen subscriber type
        socket.subscribe("0");  // Live events only
        // socket.subscribe("-1");  // Earliest available
        // socket.subscribe("-2");  // Resume
    }
    
    @Override
    public void onMessage(ZCDataStreamMessageEvent event) {
        System.out.println("Received: " + event.getData());
        System.out.println("Streaming ID: " + event.getStreamingId());
        
        // Process your message here
        // ...
        
        // CRITICAL: Always send acknowledgement to receive next message
        socket.sendAck();
    }
    
    @Override
    public void onError(ZCCustomEvent event) {
        System.err.println("Error: " + event.getMessage());
    }
    
    @Override
    public void onClose(ZCCustomEvent event) {
        System.out.println("Connection closed");
    }
    
    @Override
    public void onPong(ZCCustomEvent event) {
        // Keep-alive pong received
    }
});

def on_open(event):
    print("Connected! Subscribing to channel...")
    
    # Subscribe with your chosen subscriber type
    socket.subscribe("0")  # Live events only
    # socket.subscribe("-1")  # Earliest available
    # socket.subscribe("-2")  # Resume

def on_message(event):
    print("Received:", event.data)
    print("Streaming ID:", event.streaming_id)
    
    # Process your message here
    # ...
    
    # CRITICAL: Always send acknowledgement to receive next message
    socket.send_ack()

def on_error(event):
    print("Error:", event.code, event.message)

def on_close(event):
    print("Connection closed")

# Register event listeners
socket.set_on_open(on_open)
socket.set_on_message(on_message)
socket.set_on_error(on_error)
socket.set_on_close(on_close)

# Connect (Python requires explicit connect call)
socket.connect()

// Unsubscribe: ends the session. Generate a new token pair to subscribe again.
socket.unsubscribe();

// Or disconnect only: reconnect later and resume with subscribe type "-2".
socket.close();

// Unsubscribe: ends the session. Generate a new token pair to subscribe again.
socket.unsubscribe();

// Or disconnect only: reconnect later and resume with subscribe type "-2".
socket.close();

# Unsubscribe: ends the session. Generate a new token pair to subscribe again.
socket.unsubscribe()

# Or disconnect only: reconnect later and resume with subscribe type "-2".
socket.close()