TalkerClient

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

const client = new TalkerClient({
  userAuthToken: string,    // Required: From backend
  userId: string,           // Required: From backend (filters own broadcasts)
  a_username: string,       // Required: From backend
  a_password: string,       // Required: From backend
  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('room_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('room_participant_live_status', (event) => {
  console.log(`User ${event.participantId} is ${event.live ? 'live' : 'not live'}`);
});

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

// Send file
await talker.sendMessage('channel-id', {
  file: fileInput.files[0],
  description: 'Photo from today',
});

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

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