@senspark/sfs2x/src/DefaultBridge.ts

utility library for smartfox server

import { Bridge } from "./Bridge";
import { EventDispatcher } from "./EventDispatcher";
import { EventDispatcherImpl } from "./EventDispatcherImpl";
import { RequestHandler } from "./RequestHandler";
import { RequestHandlerImpl } from "./RequestHandlerImpl";

export class DefaultBridge implements Bridge {
    private initialized = false;
    private client?: SFS2X.SmartFox;
    private _eventDispatcher?: EventDispatcher;
    private _requestHandler?: RequestHandler;

    public get eventDispatcher(): EventDispatcher {
        if (this._eventDispatcher) {
            return this._eventDispatcher;
        }
        // Dummy event dispatcher.
        return {
            addListener: () => false,
            removeListener: () => false,
            destroy(): void { },
        };
    }

    public get requestHandler(): RequestHandler {
        if (this._requestHandler) {
            return this._requestHandler;
        }
        // Dummy request handler.
        return {
            sendRequest: async () => new SFS2X.SFSObject(),
            destroy(): void { },
        };
    }

    public get userId(): string {
        if (this.client) {
            if (this.client.mySelf) {
                return this.client.mySelf.name;
            }
            throw new Error('Not logged in');
        }
        throw new Error('Not initialized');
    }

    public initialize(host: string, port: number, zone: string): void {
        if (this.initialized) {
            return;
        }
        this.initialized = true;
        this.client = new SFS2X.SmartFox({
            host,
            port,
            zone,
            useSSL: false,
            debug: true,
        });
        this._eventDispatcher = new EventDispatcherImpl(this.client);
        this._requestHandler = new RequestHandlerImpl(this.eventDispatcher, this.client);
    }

    public get isConnected(): boolean {
        if (!this.initialized) {
            return false;
        }
        return !!this.client && this.client.isConnected;
    }

    public get isLoggedIn(): boolean {
        if (!this.initialized) {
            return false;
        }
        if (!this.isConnected) {
            return false;
        }
        return !!this.client && !!this.client.mySelf;
    }

    public connect(): void {
        if (!this.initialized) {
            return;
        }
        this.client && this.client.connect();
    }

    public disconnect(): void {
        if (!this.initialized) {
            return;
        }
        this.client && this.client.disconnect();
    }

    public logIn(userId: string, zone: string, version: number): void {
        const params = new SFS2X.SFSObject();
        params.putUtfString('userId', userId);
        params.putInt('version', version);
        const request = new SFS2X.LoginRequest('', '', params, zone);
        this.client && this.client.send(request);
    }

    public logOut(): void {
        const request = new SFS2X.LogoutRequest();
        this.client && this.client.send(request);
    }

    public destroy(): void {
        if (this.initialized) {
            this.client = undefined;
            this.eventDispatcher.destroy();
            this.requestHandler.destroy();
            this._eventDispatcher = undefined;
            this._requestHandler = undefined;
        }
    }
}