TalkerClient

import { TalkerClient } from '@talker-network/talker-sdk';

const client = new TalkerClient({
  userAuthToken: string,    // Required: From TalkerAdmin
  userId: string,           // Required: From TalkerAdmin (filters own broadcasts)
  a_username: string,       // Required: From TalkerAdmin
  a_password: string,       // Required: From TalkerAdmin
  baseUrl?: string,         // Optional: API base URL
  socketUrl?: string,       // Optional: Socket.IO URL
  loggerConfig?: {          // Optional: Logger configuration
    level?: LogLevel,       // DEBUG, INFO, WARN, ERROR, OFF
    enableConsole?: boolean,
    customHandler?: (entry: LogEntry) => void,
  },
});

// Check connection status
const { connected, status } = talker.getConnectionStatus();
// status: 'connected' | 'connecting' | 'disconnected'

// Check if ready for PTT
if (talker.isFullyConnected()) {
  console.log('Ready to talk!');
}

// Force reconnection
const success = await talker.reconnect();

// Disconnect when done
await talker.disconnect();

interface StartTalkingResult {
  success: boolean;
  code: 'success' | 'already_talking' | 'not_connected' | 'no_user_id' | 'channel_busy' | 'error';
  message: string;
}

// PTT flow with deterministic handling
const result = await talker.startTalking('channel-id');

if (!result.success) {
  switch (result.code) {
    case 'not_connected':
      // Show "Connecting..." UI, retry after connection_change event
      break;
    case 'channel_busy':
      // Someone else is talking on this channel
      showToast('Channel is busy. Please wait...');
      break;
    case 'no_user_id':
      // Developer error - userId not provided
      console.error(result.message);
      break;
    case 'error':
      // Show error to user
      alert(result.message);
      break;
  }
}

// Release button
await talker.stopTalking();

// Volume control
talker.setVolume(0.8);

// Mute speaker
talker.setSpeakerEnabled(false);

// Mute microphone
talker.setMicrophoneEnabled(false);

// Get mic level for UI visualization
const level = talker.getAudioLevel();

// Unlock audio on iOS/Safari (call on user interaction)
document.addEventListener('click', () => {
  talker.unlockAudio();
}, { once: true });

// List and select devices
const microphones = await talker.getAudioInputDevices();
await talker.setAudioInputDevice(microphones[1].deviceId);

const speakers = await talker.getAudioOutputDevices();
await talker.setAudioOutputDevice(speakers[0].deviceId);

// Pause incoming broadcasts while user is busy
talker.pauseQueue();

// Later, resume
talker.resumeQueue();

// Need immediate silence
talker.stopPlaybackAndPause();

// Check queue status
console.log(`${talker.getPlaybackQueueLength()} broadcasts waiting`);

// Get current broadcast
const playing = talker.getCurrentlyPlaying();
if (playing) {
  console.log(`Now playing from ${playing.senderName}`);
}

// Go live in a channel (available for real-time audio)
await talker.goLive('channel-id');

// Check your live status
if (talker.isLive('channel-id')) {
  console.log('You are live and can send/receive audio');
}

// Drop from live (no longer available for real-time audio)
await talker.dropFromLive('channel-id');

// Listen for channel live status changes
talker.on('channel_live_status', (event) => {
  // Channel goes live when first participant goes live
  // Channel drops from live when last participant drops
  console.log(`Channel ${event.channelId} is ${event.live ? 'live' : 'not live'}`);
});

// Listen for participant live status changes
talker.on('channel_participant_live_status', (event) => {
  console.log(`User ${event.participantMobileNo} is ${event.live ? 'live' : 'not live'}`);
});

// Access raw incoming audio
talker.on('audio_received', (pcmData: ArrayBuffer) => {
  const samples = new Int16Array(pcmData);

  // Example: Audio visualization
  let sum = 0;
  for (let i = 0; i < samples.length; i++) {
    sum += Math.abs(samples[i]);
  }
  const level = sum / samples.length / 32768;
  updateWaveform(level);
});

// Example: Recording to WAV
const audioChunks: Int16Array[] = [];

talker.on('broadcast_start', () => {
  audioChunks.length = 0; // Clear previous
});

talker.on('audio_received', (pcmData: ArrayBuffer) => {
  audioChunks.push(new Int16Array(pcmData));
});

talker.on('broadcast_end', () => {
  const wavBlob = createWavFile(audioChunks, 16000);
  saveRecording(wavBlob);
});

// Example: Speech-to-text integration
talker.on('audio_received', (pcmData: ArrayBuffer) => {
  speechRecognizer.feedAudio(pcmData);
});

// Send text message
await talker.sendMessage('channel-id', { text: 'Hello team!' });

// Send image with caption
await talker.sendMessage('channel-id', {
  file: imageFile,            // File or Blob (image/* detected automatically)
  description: 'Photo from today',
});

// Send document
await talker.sendMessage('channel-id', {
  file: documentFile,         // Non-image files sent as 'document'
});

// Listen for incoming messages
talker.on('message', (event) => {
  const { senderId, description, attachments, sentAt } = event.message;
  if (attachments?.images) {
    console.log('Image URLs:', attachments.images);
  }
  if (description) {
    console.log('Text:', description);
  }
});

// Subscribe to an event
const handler = (event) => console.log(event);
talker.on('broadcast_start', handler);

// Unsubscribe
talker.off('broadcast_start', handler);