BasicDesktopAgent.ts

import { AppIdentifier, AppMetadata, ContextHandler, DesktopAgent, EventHandler, FDC3EventTypes, ImplementationMetadata, IntentHandler, IntentResolution, Listener } from "@kite9/fdc3-standard";
import { ChannelSupport } from "./channels/ChannelSupport";
import { AppSupport } from "./apps/AppSupport";
import { IntentSupport } from "./intents/IntentSupport";
import { HandshakeSupport } from "./handshake/HandshakeSupport";
import { Connectable } from "@kite9/fdc3-standard";
import { Context } from "@kite9/fdc3-context";

/**
 * This splits out the functionality of the desktop agent into 
 * app, channels and intents concerns.
 */
export class BasicDesktopAgent implements DesktopAgent, Connectable {

    readonly handshake: HandshakeSupport
    readonly channels: ChannelSupport
    readonly intents: IntentSupport
    readonly apps: AppSupport
    readonly connectables: Connectable[]

    constructor(handshake: HandshakeSupport, channels: ChannelSupport, intents: IntentSupport, apps: AppSupport, connectables: Connectable[]) {
        this.handshake = handshake
        this.intents = intents
        this.channels = channels
        this.apps = apps
        this.connectables = connectables
    }

    async addEventListener(type: FDC3EventTypes | null, handler: EventHandler): Promise<Listener> {
        switch (type) {
            case "userChannelChanged": return this.channels.addChannelChangedEventHandler(handler);
            default:
                throw new Error("UnknownEventType")
        }
    }

    async getInfo(): Promise<ImplementationMetadata> {
        return this.handshake.getImplementationMetadata()
    }

    async broadcast(context: Context): Promise<void> {
        const channel = await this.channels.getUserChannel()
        if (channel) {
            return channel.broadcast(context)
        } else {
            return Promise.resolve();
        }
    }

    async addContextListener(context: ContextHandler | string | null, handler?: ContextHandler): Promise<Listener> {
        const theHandler: ContextHandler = handler ? handler : (context as ContextHandler)
        const theContextType: string | null = context && handler ? (context as string) : null
        return this.channels.addContextListener(theHandler, theContextType)
    }

    getUserChannels() {
        return this.channels.getUserChannels()
    }

    getSystemChannels() {
        return this.channels.getUserChannels()
    }

    getOrCreateChannel(channelId: string) {
        return this.channels.getOrCreate(channelId)
    }

    createPrivateChannel() {
        return this.channels.createPrivateChannel()
    }

    leaveCurrentChannel() {
        return this.channels.leaveUserChannel()
    }

    joinUserChannel(channelId: string) {
        return this.channels.joinUserChannel(channelId)
    }

    joinChannel(channelId: string) {
        return this.channels.joinUserChannel(channelId)
    }

    getCurrentChannel() {
        return this.channels.getUserChannel();
    }

    findIntent(intent: string, context: Context, resultType: string | undefined) {
        return this.intents.findIntent(intent, context, resultType)
    }

    findIntentsByContext(context: Context) {
        return this.intents.findIntentsByContext(context)
    }

    private ensureAppId(app?: any): AppIdentifier | undefined {
        if (typeof app === "string") {
            return {
                appId: app
            }
        } else if (app?.appId) {
            return app as AppIdentifier
        } else {
            return undefined;
        }
    }

    raiseIntent(intent: string, context: Context, app?: any) {
        return this.intents.raiseIntent(intent, context, this.ensureAppId(app))
    }

    addIntentListener(intent: string, handler: IntentHandler) {
        return this.intents.addIntentListener(intent, handler)
    }

    raiseIntentForContext(context: Context, app?: any): Promise<IntentResolution> {
        return this.intents.raiseIntentForContext(context, this.ensureAppId(app))
    }

    open(app: any, context?: Context | undefined) {
        return this.apps.open(this.ensureAppId(app)!, context)
    }

    findInstances(app: AppIdentifier) {
        return this.apps.findInstances(app)
    }

    getAppMetadata(app: AppIdentifier): Promise<AppMetadata> {
        return this.apps.getAppMetadata(app);
    }

    async disconnect(): Promise<void> {
        await Promise.all(this.connectables.map(c => c.disconnect()))
    }

    async connect(): Promise<void> {
        await Promise.all(this.connectables.map(c => c.connect()))
    }
}