ajaxter-chat 3.0.16 → 3.1.0

package/src/hooks/useWebRTC.ts

@@ -1,130 +1,165 @@
 import { useState, useRef, useCallback, useEffect } from 'react';
 import { CallSession, CallState, ChatUser } from '../types';
 
+export interface UseWebRTCOptions {
+  onOfferReady?: (offer: RTCSessionDescriptionInit, toUid: string, callId: string) => void;
+  onAnswerReady?: (answer: RTCSessionDescriptionInit, toUid: string, callId: string) => void;
+  onIceCandidateReady?: (candidate: RTCIceCandidateInit, toUid: string) => void;
+  onCallEnded?: (callId: string, toUid?: string) => void;
+}
+
 const ICE_SERVERS: RTCIceServer[] = [
   { urls: 'stun:stun.l.google.com:19302' },
   { urls: 'stun:stun1.l.google.com:19302' },
 ];
 
-export function useWebRTC() {
+export function useWebRTC(opts: UseWebRTCOptions = {}) {
+  const { onOfferReady, onAnswerReady, onIceCandidateReady, onCallEnded } = opts;
+
   const [session, setSession] = useState<CallSession>({
-    state:     'idle',
-    peer:      null,
-    startedAt: null,
-    isMuted:   false,
+    state:      'idle',
+    peer:       null,
+    startedAt:  null,
+    isMuted:    false,
     isCameraOn: false,
   });
 
-  const pcRef         = useRef<RTCPeerConnection | null>(null);
-  const localStream   = useRef<MediaStream | null>(null);
-  const localVideoRef = useRef<HTMLVideoElement | null>(null);
+  const pcRef          = useRef<RTCPeerConnection | null>(null);
+  const localStream    = useRef<MediaStream | null>(null);
+  const localVideoRef  = useRef<HTMLVideoElement | null>(null);
   const remoteVideoRef = useRef<HTMLVideoElement | null>(null);
+  const currentCallId  = useRef<string | null>(null);
+  const peerUidRef     = useRef<string | null>(null);
 
-  const updateSession = (patch: Partial<CallSession>) =>
-    setSession(prev => ({ ...prev, ...patch }));
-
-  /** Start an outgoing call */
-  const startCall = useCallback(async (peer: ChatUser, withVideo = false) => {
-    updateSession({ state: 'calling', peer });
-
-    const stream = await navigator.mediaDevices.getUserMedia({
-      audio: true,
-      video: withVideo,
-    });
-    localStream.current = stream;
-    if (localVideoRef.current) localVideoRef.current.srcObject = stream;
+  const updateSession = useCallback((patch: Partial<CallSession>) =>
+    setSession(prev => ({ ...prev, ...patch })), []);
 
+  const buildPc = useCallback((peer: ChatUser) => {
     const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
     pcRef.current = pc;
-
-    stream.getTracks().forEach(t => pc.addTrack(t, stream));
+    peerUidRef.current = peer.uid;
 
     pc.ontrack = e => {
       if (remoteVideoRef.current) remoteVideoRef.current.srcObject = e.streams[0];
-      updateSession({ state: 'connected', startedAt: new Date(), isCameraOn: withVideo });
+      updateSession({ state: 'connected', startedAt: new Date() });
     };
 
     pc.onicecandidate = e => {
-      if (e.candidate) {
-        // TODO: socket.emit('ice-candidate', { candidate: e.candidate, to: peer.uid });
-        console.log('[WebRTC] ICE candidate ready — send via signalling:', e.candidate);
+      if (e.candidate && peerUidRef.current) {
+        onIceCandidateReady?.(e.candidate.toJSON(), peerUidRef.current);
       }
     };
 
-    const offer = await pc.createOffer();
-    await pc.setLocalDescription(offer);
-    // TODO: socket.emit('call-offer', { offer, to: peer.uid, from: 'me' });
-    console.log('[WebRTC] Offer created — send via signalling server:', offer);
-  }, []);
+    pc.onconnectionstatechange = () => {
+      if (pc.connectionState === 'failed' || pc.connectionState === 'disconnected') {
+        updateSession({ state: 'ended' });
+        setTimeout(() => updateSession({ state: 'idle' }), 1800);
+      }
+    };
+
+    return pc;
+  }, [onIceCandidateReady, updateSession]);
+
+  const startCall = useCallback(async (peer: ChatUser, withVideo = false) => {
+    const callId = `call_${Date.now()}`;
+    currentCallId.current = callId;
+    updateSession({ state: 'calling', peer });
+
+    let stream: MediaStream;
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: withVideo });
+    } catch (err) {
+      console.error('[WebRTC] getUserMedia failed:', err);
+      updateSession({ state: 'idle' });
+      return;
+    }
+    localStream.current = stream;
+    if (localVideoRef.current) localVideoRef.current.srcObject = stream;
+
+    const pc = buildPc(peer);
+    stream.getTracks().forEach(t => pc.addTrack(t, stream));
+
+    try {
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      onOfferReady?.(offer, peer.uid, callId);
+      updateSession({ isCameraOn: withVideo });
+    } catch (err) {
+      console.error('[WebRTC] createOffer failed:', err);
+    }
+  }, [buildPc, onOfferReady, updateSession]);
 
-  /** Accept an incoming call offer */
   const acceptCall = useCallback(async (
     offer: RTCSessionDescriptionInit,
     peer: ChatUser,
+    callId: string,
     withVideo = false
   ) => {
+    currentCallId.current = callId;
     updateSession({ state: 'connected', peer, startedAt: new Date(), isCameraOn: withVideo });
 
-    const stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: withVideo });
+    let stream: MediaStream;
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: withVideo });
+    } catch (err) {
+      console.error('[WebRTC] getUserMedia failed:', err);
+      return;
+    }
     localStream.current = stream;
     if (localVideoRef.current) localVideoRef.current.srcObject = stream;
 
-    const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
-    pcRef.current = pc;
+    const pc = buildPc(peer);
     stream.getTracks().forEach(t => pc.addTrack(t, stream));
-    pc.ontrack = e => {
-      if (remoteVideoRef.current) remoteVideoRef.current.srcObject = e.streams[0];
-    };
-    pc.onicecandidate = e => {
-      if (e.candidate) {
-        // TODO: socket.emit('ice-candidate', { candidate: e.candidate, to: peer.uid });
-      }
-    };
 
     await pc.setRemoteDescription(offer);
     const answer = await pc.createAnswer();
     await pc.setLocalDescription(answer);
-    // TODO: socket.emit('call-answer', { answer, to: peer.uid });
+    onAnswerReady?.(answer, peer.uid, callId);
+  }, [buildPc, onAnswerReady, updateSession]);
+
+  const addIceCandidate = useCallback(async (candidate: RTCIceCandidateInit) => {
+    try {
+      await pcRef.current?.addIceCandidate(new RTCIceCandidate(candidate));
+    } catch (err) {
+      console.warn('[WebRTC] addIceCandidate failed:', err);
+    }
   }, []);
 
-  /** Hang up */
   const endCall = useCallback(() => {
+    const callId = currentCallId.current;
+    const peerUid = peerUidRef.current ?? undefined;
     localStream.current?.getTracks().forEach(t => t.stop());
     pcRef.current?.close();
     pcRef.current = null;
     localStream.current = null;
+    currentCallId.current = null;
+    if (callId) onCallEnded?.(callId, peerUid);
     updateSession({ state: 'ended', peer: null, startedAt: null });
     setTimeout(() => updateSession({ state: 'idle' }), 1800);
-  }, []);
+  }, [onCallEnded, updateSession]);
 
   const toggleMute = useCallback(() => {
     if (!localStream.current) return;
-    const enabled = !session.isMuted;
-    localStream.current.getAudioTracks().forEach(t => { t.enabled = enabled; });
-    updateSession({ isMuted: !session.isMuted });
-  }, [session.isMuted]);
+    const muted = !session.isMuted;
+    localStream.current.getAudioTracks().forEach(t => { t.enabled = !muted; });
+    updateSession({ isMuted: muted });
+  }, [session.isMuted, updateSession]);
 
   const toggleCamera = useCallback(() => {
     if (!localStream.current) return;
-    const enabled = !session.isCameraOn;
-    localStream.current.getVideoTracks().forEach(t => { t.enabled = enabled; });
-    updateSession({ isCameraOn: enabled });
-  }, [session.isCameraOn]);
+    const on = !session.isCameraOn;
+    localStream.current.getVideoTracks().forEach(t => { t.enabled = on; });
+    updateSession({ isCameraOn: on });
+  }, [session.isCameraOn, updateSession]);
 
-  // Cleanup on unmount
   useEffect(() => () => {
     localStream.current?.getTracks().forEach(t => t.stop());
     pcRef.current?.close();
   }, []);
 
   return {
-    session,
-    localVideoRef,
-    remoteVideoRef,
-    startCall,
-    acceptCall,
-    endCall,
-    toggleMute,
-    toggleCamera,
+    session, localVideoRef, remoteVideoRef,
+    startCall, acceptCall, addIceCandidate, endCall,
+    toggleMute, toggleCamera,
   };
 }

package/src/index.ts

@@ -10,10 +10,12 @@ export { MaintenanceView }    from './components/MaintenanceView';
 export { BottomTabs }         from './components/Tabs/BottomTabs';
 export { EmojiPicker }        from './components/EmojiPicker';
 export { SlideNavMenu }       from './components/SlideNavMenu';
+export { ErrorBoundary }      from './components/ErrorBoundary';
 
 export { useChat }            from './hooks/useChat';
 export { useWebRTC }          from './hooks/useWebRTC';
 export { useRemoteConfig }    from './hooks/useRemoteConfig';
+export { useSocket }          from './hooks/useSocket';
 
 export { shouldShowPrivacyNotice, dismissPrivacyNotice, getPrivacyDismissedAt } from './utils/privacyConsent';
 export { submitReenableRequest } from './utils/reenableRequest';
@@ -31,6 +33,9 @@ export type {
   CallSession, CallState,
   ChatStatus, ChatType, UserType, OnlineStatus,
   Screen, BottomTab, UserListContext, MessageType,
-  LocalEnvConfig,
-  PresenceStatus,
+  LocalEnvConfig, PresenceStatus,
 } from './types';
+
+export type { UseSocketOptions, SocketStatus, SocketMessageAck } from './hooks/useSocket';
+export type { UseChatOptions } from './hooks/useChat';
+export type { UseWebRTCOptions } from './hooks/useWebRTC';