@stream-io/video-client 1.44.6-beta.0 → 1.45.0

package/dist/src/Call.d.ts

@@ -162,7 +162,7 @@ export declare class Call {
     /**
      * A flag indicating whether the call was created by the current user.
      */
-    get isCreatedByMe(): boolean | "" | undefined;
+    get isCreatedByMe(): boolean;
     /**
      * Update from the call response from the "call.ring" event
      * @internal

package/dist/src/coordinator/connection/types.d.ts

@@ -3,6 +3,7 @@ import { ConnectedEvent, UserRequest, VideoEvent } from '../../gen/coordinator';
 import { AllSfuEvents } from '../../rtc';
 import type { ConfigureLoggersOptions, LogLevel } from '@stream-io/logger';
 import type { DevicePersistenceOptions } from '../../devices/devicePersistence';
+import { InputDeviceStatus } from '../../devices';
 export type UR = Record<string, unknown>;
 export type User = (Omit<UserRequest, 'role'> & {
     type?: 'authenticated';
@@ -79,7 +80,27 @@ export type MicCaptureReportEvent = {
      */
     label?: string;
 };
-export type StreamVideoEvent = (VideoEvent | NetworkChangedEvent | ConnectionChangedEvent | TransportChangedEvent | ConnectionRecoveredEvent | MicCaptureReportEvent) & {
+export type DeviceDisconnectedEvent = {
+    type: 'device.disconnected';
+    call_cid: string;
+    /**
+     * The device status at the time it was disconnected.
+     */
+    status: InputDeviceStatus;
+    /**
+     * The disconnected device ID.
+     */
+    deviceId: string;
+    /**
+     * The human-readable label of the disconnected device.
+     */
+    label?: string;
+    /**
+     * The disconnected device kind.
+     */
+    kind: MediaDeviceKind;
+};
+export type StreamVideoEvent = (VideoEvent | NetworkChangedEvent | ConnectionChangedEvent | TransportChangedEvent | ConnectionRecoveredEvent | MicCaptureReportEvent | DeviceDisconnectedEvent) & {
     received_at?: string | Date;
 };
 export type StreamCallEvent = Extract<StreamVideoEvent, {

package/dist/src/devices/DeviceManager.d.ts

@@ -104,6 +104,7 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     private get mediaDeviceKind();
     private handleDisconnectedOrReplacedDevices;
     protected findDevice(devices: MediaDeviceInfo[], deviceId: string): MediaDeviceInfo | undefined;
+    private dispatchDeviceDisconnectedEvent;
     private persistPreference;
     protected applyPersistedPreferences(enabledInCallType: boolean): Promise<boolean>;
     private applyMutedState;

package/dist/src/types.d.ts

@@ -5,7 +5,6 @@ import type { RejectReason, StreamClientOptions, TokenProvider, User } from './c
 import type { Comparator } from './sorting';
 import type { StreamVideoWriteableStateStore } from './store';
 import { AxiosError } from 'axios';
-import type { Call } from './Call';
 export type StreamReaction = Pick<ReactionResponse, 'type' | 'emoji_code' | 'custom'>;
 export declare enum VisibilityState {
     UNKNOWN = "UNKNOWN",
@@ -317,53 +316,22 @@ export type StartCallRecordingFnType = {
     (request: StartRecordingRequest): Promise<StartRecordingResponse>;
     (request: StartRecordingRequest, type: CallRecordingType): Promise<StartRecordingResponse>;
 };
-type StreamRNVideoSDKCallManagerRingingParams = {
-    isRingingTypeCall: boolean;
-};
-type StreamRNVideoSDKCallManagerSetupParams = StreamRNVideoSDKCallManagerRingingParams & {
-    defaultDevice: AudioSettingsRequestDefaultDeviceEnum;
-};
-type StreamRNVideoSDKEndCallReason = 
-/** Call ended by the local user (e.g., hanging up). */
-'local'
-/** Call ended by the remote party, or outgoing call was not answered. */
- | 'remote'
-/** Call was rejected/declined by the user. */
- | 'rejected'
-/** Remote party was busy. */
- | 'busy'
-/** Call was answered on another device. */
- | 'answeredElsewhere'
-/** No response to an incoming call. */
- | 'missed'
-/** Call failed due to an error (e.g., network issue). */
- | 'error'
-/** Call was canceled before the remote party could answer. */
- | 'canceled'
-/** Call restricted (e.g., airplane mode, dialing restrictions). */
- | 'restricted'
-/** Unknown or unspecified disconnect reason. */
- | 'unknown';
-type StreamRNVideoSDKCallingX = {
-    joinCall: (call: Call, activeCalls: Call[]) => Promise<void>;
-    endCall: (call: Call, reason?: StreamRNVideoSDKEndCallReason) => Promise<void>;
-    registerOutgoingCall: (call: Call) => Promise<void>;
-};
 export type StreamRNVideoSDKGlobals = {
-    callingX: StreamRNVideoSDKCallingX;
     callManager: {
         /**
          * Sets up the in call manager.
          */
-        setup({ defaultDevice, isRingingTypeCall, }: StreamRNVideoSDKCallManagerSetupParams): void;
+        setup({ defaultDevice, }: {
+            defaultDevice: AudioSettingsRequestDefaultDeviceEnum;
+        }): void;
         /**
          * Starts the in call manager.
          */
-        start({ isRingingTypeCall, }: StreamRNVideoSDKCallManagerRingingParams): void;
+        start(): void;
         /**
          * Stops the in call manager.
          */
-        stop({ isRingingTypeCall }: StreamRNVideoSDKCallManagerRingingParams): void;
+        stop(): void;
     };
     permissions: {
         /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.44.6-beta.0",
+  "version": "1.45.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/Call.ts

@@ -421,7 +421,6 @@ export class Call {
         const currentUserId = this.currentUserId;
         if (currentUserId && blockedUserIds.includes(currentUserId)) {
           this.logger.info('Leaving call because of being blocked');
-          globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'restricted');
           await this.leave({ message: 'user blocked' }).catch((err) => {
             this.logger.error('Error leaving call after being blocked', err);
           });
@@ -466,10 +465,6 @@ export class Call {
           (isAcceptedElsewhere || isRejectedByMe) &&
           !hasPending(this.joinLeaveConcurrencyTag)
         ) {
-          globalThis.streamRNVideoSDK?.callingX?.endCall(
-            this,
-            isAcceptedElsewhere ? 'answeredElsewhere' : 'rejected',
-          );
           this.leave().catch(() => {
             this.logger.error(
               'Could not leave a call that was accepted or rejected elsewhere',
@@ -485,10 +480,6 @@ export class Call {
     const receiver_id = this.clientStore.connectedUser?.id;
     const ended_at = callSession?.ended_at;
     const created_by_id = this.state.createdBy?.id;
-
-    if (this.currentUserId && created_by_id === this.currentUserId) {
-      globalThis.streamRNVideoSDK?.callingX?.registerOutgoingCall(this);
-    }
     const rejected_by = callSession?.rejected_by;
     const accepted_by = callSession?.accepted_by;
     let leaveCallIdle = false;
@@ -645,30 +636,16 @@ export class Call {
 
       if (callingState === CallingState.RINGING && reject !== false) {
         if (reject) {
-          const reasonToEndCallReason = {
-            timeout: 'missed',
-            cancel: 'canceled',
-            busy: 'busy',
-            decline: 'rejected',
-          } as const;
-          const rejectReason = reason ?? 'decline';
-          const endCallReason =
-            reasonToEndCallReason[
-              rejectReason as keyof typeof reasonToEndCallReason
-            ] ?? 'rejected';
-          globalThis.streamRNVideoSDK?.callingX?.endCall(this, endCallReason);
-          await this.reject(rejectReason);
+          await this.reject(reason ?? 'decline');
         } else {
           // if reject was undefined, we still have to cancel the call automatically
           // when I am the creator and everyone else left the call
           const hasOtherParticipants = this.state.remoteParticipants.length > 0;
           if (this.isCreatedByMe && !hasOtherParticipants) {
-            globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'canceled');
             await this.reject('cancel');
           }
         }
       }
-      globalThis.streamRNVideoSDK?.callingX?.endCall(this);
 
       this.statsReporter?.stop();
       this.statsReporter = undefined;
@@ -703,9 +680,7 @@ export class Call {
       this.cancelAutoDrop();
       this.clientStore.unregisterCall(this);
 
-      globalThis.streamRNVideoSDK?.callManager.stop({
-        isRingingTypeCall: this.ringing,
-      });
+      globalThis.streamRNVideoSDK?.callManager.stop();
 
       this.camera.dispose();
       this.microphone.dispose();
@@ -745,9 +720,7 @@ export class Call {
    * A flag indicating whether the call was created by the current user.
    */
   get isCreatedByMe() {
-    return (
-      this.currentUserId && this.state.createdBy?.id === this.currentUserId
-    );
+    return this.state.createdBy?.id === this.currentUserId;
   }
 
   /**
@@ -793,7 +766,6 @@ export class Call {
     video?: boolean;
   }): Promise<GetCallResponse> => {
     await this.setup();
-
     const response = await this.streamClient.get<GetCallResponse>(
       this.streamClientBasePath,
       params,
@@ -833,7 +805,6 @@ export class Call {
    */
   getOrCreate = async (data?: GetOrCreateCallRequest) => {
     await this.setup();
-
     const response = await this.streamClient.post<
       GetOrCreateCallResponse,
       GetOrCreateCallRequest
@@ -959,73 +930,60 @@ export class Call {
     joinResponseTimeout?: number;
     rpcRequestTimeout?: number;
   } = {}): Promise<void> => {
+    await this.setup();
     const callingState = this.state.callingState;
 
     if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
       throw new Error(`Illegal State: call.join() shall be called only once`);
     }
 
-    if (data?.ring) {
-      this.ringingSubject.next(true);
-    }
-    const callingX = globalThis.streamRNVideoSDK?.callingX;
-    if (callingX) {
-      // for Android/iOS, we need to start the call in the callingx library as soon as possible
-      await callingX.joinCall(this, this.clientStore.calls);
-    }
-
-    await this.setup();
-
     this.joinResponseTimeout = joinResponseTimeout;
     this.rpcRequestTimeout = rpcRequestTimeout;
+
     // we will count the number of join failures per SFU.
     // once the number of failures reaches 2, we will piggyback on the `migrating_from`
     // field to force the coordinator to provide us another SFU
     const sfuJoinFailures = new Map<string, number>();
     const joinData: JoinCallData = data;
     maxJoinRetries = Math.max(maxJoinRetries, 1);
-    try {
-      for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
-        try {
-          this.logger.trace(`Joining call (${attempt})`, this.cid);
-          await this.doJoin(data);
-          delete joinData.migrating_from;
-          delete joinData.migrating_from_list;
-          break;
-        } catch (err) {
-          this.logger.warn(`Failed to join call (${attempt})`, this.cid);
-          if (
-            (err instanceof ErrorFromResponse && err.unrecoverable) ||
-            (err instanceof SfuJoinError && err.unrecoverable)
-          ) {
-            // if the error is unrecoverable, we should not retry as that signals
-            // that connectivity is good, but the coordinator doesn't allow the user
-            // to join the call due to some reason (e.g., ended call, expired token...)
-            throw err;
-          }
+    for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
+      try {
+        this.logger.trace(`Joining call (${attempt})`, this.cid);
+        await this.doJoin(data);
+        delete joinData.migrating_from;
+        delete joinData.migrating_from_list;
+        break;
+      } catch (err) {
+        this.logger.warn(`Failed to join call (${attempt})`, this.cid);
+        if (
+          (err instanceof ErrorFromResponse && err.unrecoverable) ||
+          (err instanceof SfuJoinError && err.unrecoverable)
+        ) {
+          // if the error is unrecoverable, we should not retry as that signals
+          // that connectivity is good, but the coordinator doesn't allow the user
+          // to join the call due to some reason (e.g., ended call, expired token...)
+          throw err;
+        }
 
-          // immediately switch to a different SFU in case of recoverable join error
-          const switchSfu =
-            err instanceof SfuJoinError &&
-            SfuJoinError.isJoinErrorCode(err.errorEvent);
-
-          const sfuId = this.credentials?.server.edge_name || '';
-          const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
-          sfuJoinFailures.set(sfuId, failures);
-          if (switchSfu || failures >= 2) {
-            joinData.migrating_from = sfuId;
-            joinData.migrating_from_list = Array.from(sfuJoinFailures.keys());
-          }
+        // immediately switch to a different SFU in case of recoverable join error
+        const switchSfu =
+          err instanceof SfuJoinError &&
+          SfuJoinError.isJoinErrorCode(err.errorEvent);
+
+        const sfuId = this.credentials?.server.edge_name || '';
+        const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
+        sfuJoinFailures.set(sfuId, failures);
+        if (switchSfu || failures >= 2) {
+          joinData.migrating_from = sfuId;
+          joinData.migrating_from_list = Array.from(sfuJoinFailures.keys());
+        }
 
-          if (attempt === maxJoinRetries - 1) {
-            throw err;
-          }
+        if (attempt === maxJoinRetries - 1) {
+          throw err;
         }
-        await sleep(retryInterval(attempt));
       }
-    } catch (error) {
-      callingX?.endCall(this, 'error');
-      throw error;
+
+      await sleep(retryInterval(attempt));
     }
   };
 
@@ -1208,9 +1166,7 @@ export class Call {
     // re-apply them on later reconnections or server-side data fetches
     if (!this.deviceSettingsAppliedOnce && this.state.settings) {
       await this.applyDeviceConfig(this.state.settings, true, false);
-      globalThis.streamRNVideoSDK?.callManager.start({
-        isRingingTypeCall: this.ringing,
-      });
+      globalThis.streamRNVideoSDK?.callManager.start();
       this.deviceSettingsAppliedOnce = true;
     }
 
@@ -1755,7 +1711,6 @@ export class Call {
       if (SfuJoinError.isJoinErrorCode(e)) return;
       if (strategy === WebsocketReconnectStrategy.UNSPECIFIED) return;
       if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
-        globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'error');
         this.leave({ message: 'SFU instructed to disconnect' }).catch((err) => {
           this.logger.warn(`Can't leave call after disconnect request`, err);
         });

package/src/coordinator/connection/types.ts

@@ -3,6 +3,7 @@ import { ConnectedEvent, UserRequest, VideoEvent } from '../../gen/coordinator';
 import { AllSfuEvents } from '../../rtc';
 import type { ConfigureLoggersOptions, LogLevel } from '@stream-io/logger';
 import type { DevicePersistenceOptions } from '../../devices/devicePersistence';
+import { InputDeviceStatus } from '../../devices';
 
 export type UR = Record<string, unknown>;
 
@@ -126,6 +127,27 @@ export type MicCaptureReportEvent = {
   label?: string;
 };
 
+export type DeviceDisconnectedEvent = {
+  type: 'device.disconnected';
+  call_cid: string;
+  /**
+   * The device status at the time it was disconnected.
+   */
+  status: InputDeviceStatus;
+  /**
+   * The disconnected device ID.
+   */
+  deviceId: string;
+  /**
+   * The human-readable label of the disconnected device.
+   */
+  label?: string;
+  /**
+   * The disconnected device kind.
+   */
+  kind: MediaDeviceKind;
+};
+
 export type StreamVideoEvent = (
   | VideoEvent
   | NetworkChangedEvent
@@ -133,6 +155,7 @@ export type StreamVideoEvent = (
   | TransportChangedEvent
   | ConnectionRecoveredEvent
   | MicCaptureReportEvent
+  | DeviceDisconnectedEvent
 ) & { received_at?: string | Date };
 
 // TODO: we should use WSCallEvent here but that needs fixing

package/src/devices/DeviceManager.ts

@@ -1,5 +1,6 @@
 import { combineLatest, firstValueFrom, Observable, pairwise } from 'rxjs';
 import { Call } from '../Call';
+import type { DeviceDisconnectedEvent } from '../coordinator/connection/types';
 import { TrackPublishOptions } from '../rtc';
 import { CallingState } from '../store';
 import { createSubscription, getCurrentValue } from '../store/rxUtils';
@@ -13,6 +14,7 @@ import { ScopedLogger, videoLoggerSystem } from '../logger';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { deviceIds$ } from './devices';
 import {
+  hasPending,
   settled,
   withCancellation,
   withoutConcurrency,
@@ -543,6 +545,7 @@ export abstract class DeviceManager<
             }
 
             if (isDeviceDisconnected) {
+              this.dispatchDeviceDisconnectedEvent(prevDevice!);
               await this.disable();
               await this.select(undefined);
             }
@@ -553,7 +556,7 @@ export abstract class DeviceManager<
               ) {
                 await this.enable();
                 this.isTrackStoppedDueToTrackEnd = false;
-              } else {
+              } else if (!hasPending(this.statusChangeConcurrencyTag)) {
                 await this.applySettingsToStream();
               }
             }
@@ -573,6 +576,22 @@ export abstract class DeviceManager<
     return devices.find((d) => d.deviceId === deviceId && d.kind === kind);
   }
 
+  private dispatchDeviceDisconnectedEvent(device: MediaDeviceInfo) {
+    const event: DeviceDisconnectedEvent = {
+      type: 'device.disconnected',
+      call_cid: this.call.cid,
+      status: this.isTrackStoppedDueToTrackEnd
+        ? this.state.prevStatus
+        : this.state.status,
+      deviceId: device.deviceId,
+      label: device.label,
+      kind: device.kind,
+    };
+
+    this.call.tracer.trace('device.disconnected', event);
+    this.call.streamClient.dispatchEvent(event);
+  }
+
   private persistPreference(
     selectedDevice: string | undefined,
     status: InputDeviceStatus,

package/src/devices/SpeakerManager.ts

@@ -85,7 +85,6 @@ export class SpeakerManager {
       this.defaultDevice = defaultDevice;
       globalThis.streamRNVideoSDK?.callManager.setup({
         defaultDevice,
-        isRingingTypeCall: this.call.ringing,
       });
     }
   }

package/src/devices/__tests__/DeviceManager.test.ts

@@ -380,6 +380,14 @@ describe('Device Manager', () => {
 
     expect(manager.state.selectedDevice).toBe(undefined);
     expect(manager.state.status).toBe('disabled');
+    expect(manager['call'].streamClient.dispatchEvent).toHaveBeenCalledWith({
+      type: 'device.disconnected',
+      call_cid: manager['call'].cid,
+      status: 'enabled',
+      deviceId: device.deviceId,
+      label: device.label,
+      kind: device.kind,
+    });
 
     vi.useRealTimers();
   });

package/src/devices/__tests__/mocks.ts

@@ -95,9 +95,13 @@ export const mockCall = (): Partial<Call> => {
     }),
   );
   return {
+    cid: 'default:test-call',
     state: callState,
     publish: vi.fn(),
     stopPublish: vi.fn(),
+    streamClient: fromPartial({
+      dispatchEvent: vi.fn(),
+    }),
     notifyNoiseCancellationStarting: vi.fn().mockResolvedValue(undefined),
     notifyNoiseCancellationStopped: vi.fn().mockResolvedValue(undefined),
     tracer: new Tracer('tests'),

package/src/events/call.ts

@@ -69,7 +69,6 @@ export const watchCallRejected = (call: Call) => {
     } else {
       if (rejectedBy[eventCall.created_by.id]) {
         call.logger.info('call creator rejected, leaving call');
-        globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
         await call.leave({ message: 'ring: creator rejected' });
       }
     }
@@ -81,7 +80,6 @@ export const watchCallRejected = (call: Call) => {
  */
 export const watchCallEnded = (call: Call) => {
   return function onCallEnded() {
-    globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
     const { callingState } = call.state;
     if (
       callingState !== CallingState.IDLE &&
@@ -115,7 +113,6 @@ export const watchSfuCallEnded = (call: Call) => {
       // update the call state to reflect the call has ended.
       call.state.setEndedAt(new Date());
       const reason = CallEndedReason[e.reason];
-      globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
       await call.leave({ message: `callEnded received: ${reason}` });
     } catch (err) {
       call.logger.error(

package/src/helpers/AudioBindingsWatchdog.ts

@@ -3,6 +3,7 @@ import { CallingState, CallState } from '../store';
 import { createSubscription } from '../store/rxUtils';
 import { videoLoggerSystem } from '../logger';
 import { Tracer } from '../stats';
+import { TrackType } from '../gen/video/sfu/models/models';
 
 const toBindingKey = (
   sessionId: string,
@@ -91,12 +92,23 @@ export class AudioBindingsWatchdog {
       const danglingUserIds: string[] = [];
       for (const p of this.state.participants) {
         if (p.isLocalParticipant) continue;
-        const { audioStream, screenShareAudioStream, sessionId, userId } = p;
-        if (audioStream && !this.bindings.has(toBindingKey(sessionId))) {
+        const {
+          audioStream,
+          screenShareAudioStream,
+          sessionId,
+          userId,
+          publishedTracks,
+        } = p;
+        if (
+          audioStream &&
+          publishedTracks.includes(TrackType.AUDIO) &&
+          !this.bindings.has(toBindingKey(sessionId))
+        ) {
           danglingUserIds.push(userId);
         }
         if (
           screenShareAudioStream &&
+          publishedTracks.includes(TrackType.SCREEN_SHARE_AUDIO) &&
           !this.bindings.has(toBindingKey(sessionId, 'screenShareAudioTrack'))
         ) {
           danglingUserIds.push(userId);

package/src/helpers/__tests__/AudioBindingsWatchdog.test.ts

@@ -11,6 +11,7 @@ import { StreamClient } from '../../coordinator/connection/client';
 import { CallingState, StreamVideoWriteableStateStore } from '../../store';
 import { noopComparator } from '../../sorting';
 import { fromPartial } from '@total-typescript/shoehorn';
+import { TrackType } from '../../gen/video/sfu/models/models';
 
 describe('AudioBindingsWatchdog', () => {
   let watchdog: AudioBindingsWatchdog;
@@ -44,12 +45,17 @@ describe('AudioBindingsWatchdog', () => {
       screenShareAudioStream?: MediaStream;
     },
   ) => {
+    const publishedTracks = [];
+    if (streams?.audioStream) publishedTracks.push(TrackType.AUDIO);
+    if (streams?.screenShareAudioStream) {
+      publishedTracks.push(TrackType.SCREEN_SHARE_AUDIO);
+    }
     call.state.updateOrAddParticipant(
       sessionId,
       fromPartial({
         userId,
         sessionId,
-        publishedTracks: [],
+        publishedTracks,
         ...streams,
       }),
     );
@@ -233,6 +239,26 @@ describe('AudioBindingsWatchdog', () => {
     expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('user-1'));
   });
 
+  it('should not warn when audioStream exists but audio is not published', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    call.state.updateOrAddParticipant(
+      'session-1',
+      fromPartial({
+        userId: 'user-1',
+        sessionId: 'session-1',
+        publishedTracks: [],
+        audioStream: new MediaStream(),
+      }),
+    );
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
   it('should not warn when screenShareAudio element is bound', () => {
     // @ts-expect-error private property
     const warnSpy = vi.spyOn(watchdog.logger, 'warn');

package/src/store/stateStore.ts

@@ -42,7 +42,7 @@ export class StreamVideoWriteableStateStore {
    * The currently connected user.
    */
   get connectedUser(): OwnUserResponse | undefined {
-    return this.connectedUserSubject.getValue();
+    return RxUtils.getCurrentValue(this.connectedUserSubject);
   }
 
   /**