Class InteropBroker

https://developers.openfin.co/of-docs/docs/enable-color-linking

The Interop Broker is responsible for keeping track of the Interop state of the Platform, and for directing messages to the proper locations.

There are 2 ways to inject custom functionality into the Interop Broker:

1. Configuration

At the moment, you can configure the default context groups for the Interop Broker without having to override it. To do so, include the interopBrokerConfiguration contextGroups option in your platform options in your manifest. This is the preferred method.

{
     "runtime": {
         "arguments": "--v=1 --inspect",
         "version": "alpha-v19"
     },
     "platform": {
         "uuid": "platform_customization_local",
         "applicationIcon": "https://openfin.github.io/golden-prototype/favicon.ico",
         "autoShow": false,
         "providerUrl": "http://localhost:5555/provider.html",
         "interopBrokerConfiguration": {
             "contextGroups": [
                 {
                     "id": "green",
                     "displayMetadata": {
                         "color": "#00CC88",
                         "name": "green"
                     }
                 },
                 {
                     "id": "purple",
                     "displayMetadata": {
                         "color": "#8C61FF",
                         "name": "purple"
                     }
                 },
             ]
         }
     }
}

By default the Interop Broker logs all actions to the console. You can disable this by using the logging option in interopBrokerConfiguration:

{
     "runtime": {
         "arguments": "--v=1 --inspect",
         "version": "alpha-v19"
     },
     "platform": {
         "uuid": "platform_customization_local",
         "applicationIcon": "https://openfin.github.io/golden-prototype/favicon.ico",
         "autoShow": false,
         "providerUrl": "http://localhost:5555/provider.html",
            "interopBrokerConfiguration": {
              "logging": {
                  "beforeAction": {
                      "enabled": false
                  },
                  "afterAction": {
                      "enabled": false
                  }
              }
            }
     }
}

2. Overriding

Similarly to how [Platform Overriding]https://developers.openfin.co/docs/platform-customization#section-customizing-platform-behavior works, you can override functions in the Interop Broker in fin.Platform.init. An example of that is shown below. Overriding isConnectionAuthorized and isActionAuthorized will allow you to control allowed connections and allowed actions.

However, if there is custom functionality you wish to include in the Interop Broker, please let us know. We would like to provide better configuration options so that you don't have to continually maintain your own override code.

fin.Platform.init({
    overrideCallback: async (Provider) => {
        class Override extends Provider {
            async getSnapshot() {
                console.log('before getSnapshot')
                const snapshot = await super.getSnapshot();
                console.log('after getSnapshot')
                return snapshot;
            }

            async applySnapshot({ snapshot, options }) {
                console.log('before applySnapshot')
                const originalPromise = super.applySnapshot({ snapshot, options });
                console.log('after applySnapshot')

                return originalPromise;
            }
        };
        return new Override();
    },
    interopOverride: async (InteropBroker) => {
        class Override extends InteropBroker {
            async joinContextGroup(channelName = 'default', target) {
                console.log('before super joinContextGroup')
                super.joinContextGroup(channelName, target);
                console.log('after super joinContextGroup')
            }
        }

      return new Override();
  }
});

Hideconstructor

Hierarchy

Base
- InteropBroker

Index

Constructors

constructor

Properties

wire

Accessors

Constructors

constructor

new InteropBroker(wire: Transport<EntityType>, getProvider: (() => Promise<OpenFin.ChannelProvider>), options?: any): OpenFin.InteropBroker
Parameters
- wire: Transport<EntityType>
- getProvider: (() => Promise<OpenFin.ChannelProvider>)
  - - (): Promise<OpenFin.ChannelProvider>
    - Returns Promise<OpenFin.ChannelProvider>
- Optional options: any
Returns OpenFin.InteropBroker

Overrides Base.constructor

Properties

wire

wire: Transport<EntityType>

Accessors

me

get me(): Identity
Returns Identity

Inherited from Base.me

Methods

addClientToContextGroup

addClientToContextGroup(addClientToContextGroupOptions: {
contextGroupId: string;
}, clientIdentity: ClientIdentity): Promise<void>
Helper function for InteropBroker.joinContextGroup. Does the work of actually adding the client to the Context Group. Used by Platform Windows.

Returns
Parameters
- addClientToContextGroupOptions: {
  contextGroupId: string;
  }
  
  Contains the contextGroupId
  - contextGroupId: string
- clientIdentity: ClientIdentity
  
  Identity of the client sender.
Returns Promise<void>

applySnapshot

applySnapshot(snapshot: Snapshot, options: ApplySnapshotOptions): void
Parameters
- snapshot: Snapshot
- options: ApplySnapshotOptions
Returns void

clientDisconnected

clientDisconnected(clientIdentity: ClientIdentity): Promise<void>
Provides the identity of any Interop Client that disconnects from the Interop Broker. It is meant to be overriden.

Returns

Tutorial
interop.clientDisconnected
Parameters
- clientIdentity: ClientIdentity
Returns Promise<void>

contextHandlerRegistered

contextHandlerRegistered(__namedParameters: {
contextType: undefined | string;
handlerId: string;
}, clientIdentity: ClientIdentity): void
Parameters
- __namedParameters: {
  contextType: undefined | string;
  handlerId: string;
  }
  - contextType: undefined | string
  - handlerId: string
- clientIdentity: ClientIdentity
Returns void

decorateSnapshot

decorateSnapshot(snapshot: Snapshot): Snapshot
Parameters
- snapshot: Snapshot
Returns Snapshot

fdc3HandleFindInstances

fdc3HandleFindInstances(app: AppIdentifier, clientIdentity: ClientIdentity): Promise<unknown>
Responsible for resolving the fdc3.findInstances call. Must be overridden
Parameters
- app: AppIdentifier
  
  AppIdentifier that was passed to fdc3.findInstances
- clientIdentity: ClientIdentity
  
  Identity of the Client making the request.
Returns Promise<unknown>

fdc3HandleGetAppMetadata

fdc3HandleGetAppMetadata(app: AppIdentifier, clientIdentity: ClientIdentity): Promise<unknown>
Responsible for resolving the fdc3.getAppMetadata call. Must be overridden
Parameters
- app: AppIdentifier
  
  AppIdentifier that was passed to fdc3.getAppMetadata
- clientIdentity: ClientIdentity
  
  Identity of the Client making the request.
Returns Promise<unknown>

fdc3HandleGetInfo

fdc3HandleGetInfo(payload: {
fdc3Version: string;
}, clientIdentity: ClientIdentity): Promise<unknown>
Responsible for resolving fdc3.getInfo for FDC3 2.0 Would need to return the optionalFeatures and appMetadata for the ImplementationMetadata ImplementationMetadata. Must be overridden.

Returns
Parameters
- payload: {
  fdc3Version: string;
  }
  - fdc3Version: string
- clientIdentity: ClientIdentity
Returns Promise<unknown>

fdc3HandleOpen

fdc3HandleOpen(fdc3OpenOptions: {
app: TargetApp | AppIdentifier;
context: Context;
}, clientIdentity: ClientIdentity): Promise<void | AppIdentifier>
Responsible for resolving an fdc3.open call. Must be overridden.
Parameters
- fdc3OpenOptions: {
  app: TargetApp | AppIdentifier;
  context: Context;
  }
  
  fdc3.open options
  - app: TargetApp | AppIdentifier
  - context: Context
- clientIdentity: ClientIdentity
  
  Identity of the Client making the request.
Returns Promise<void | AppIdentifier>

getAllClientInfo

getAllClientInfo(): Promise<ClientInfo[]>
Returns an array of info for each Interop Client connected to the Interop Broker.

FDC3 2.0: Use the endpointId in the ClientInfo as the instanceId when generating an AppIdentifier.

Returns

Tutorial
interop.getAllClientInfo

Returns Promise<ClientInfo[]>

getAllClientsInContextGroup

getAllClientsInContextGroup(getAllClientsInContextGroupOptions: {
contextGroupId: string;
}): ClientIdentity[]
Gets all clients for a context group. Used by Platform Windows.

Returns
Parameters
- getAllClientsInContextGroupOptions: {
  contextGroupId: string;
  }
  
  Contains contextGroupId, the context group you wish to get clients for.
  - contextGroupId: string
Returns ClientIdentity[]

getContextGroupStates

getContextGroupStates(): ContextGroupStates
Returns ContextGroupStates

getContextGroups

getContextGroups(): readonly ContextGroupInfo[]
Returns the Interop-Broker-defined context groups available for an entity to join. Because this function is used in the rest of the Interop Broker to fetch the Context Groups, overriding this allows you to customize the Context Groups for the Interop Broker. However, we recommend customizing the context groups through configuration instead. Used by Platform Windows.

Returns

Returns readonly ContextGroupInfo[]

getCurrentContext

getCurrentContext(getCurrentContextOptions: {
contextType: string;
}, clientIdentity: ClientIdentity): undefined | Context
Get current context for a client subscribed to a Context Group.

Returns
Parameters
- getCurrentContextOptions: {
  contextType: string;
  }
  - contextType: string
- clientIdentity: ClientIdentity
  
  Identity of the client sender.
Returns undefined | Context

getInfoForContextGroup

getInfoForContextGroup(getInfoForContextGroupOptions: {
contextGroupId: string;
}): undefined | ContextGroupInfo
Gets display info for a context group Used by Platform Windows.

Returns
Parameters
- getInfoForContextGroupOptions: {
  contextGroupId: string;
  }
  
  Contains contextGroupId, the context group you wish to get display info for.
  - contextGroupId: string
Returns undefined | ContextGroupInfo

handleFiredIntent

handleFiredIntent(intent: Intent<IntentMetadata<any>>, clientIdentity: ClientIdentity): Promise<unknown>
Responsible for launching of applications that can handle a given intent, and delegation of intents to those applications. Must be overridden.

Returns

Tutorial
interop.handleFiredIntent
Parameters
- intent: Intent<IntentMetadata<any>>
  
  The combination of an action and a context that is passed to an application for resolution.
- clientIdentity: ClientIdentity
  
  Identity of the Client making the request.
Returns Promise<unknown>

handleFiredIntentForContext

handleFiredIntentForContext(contextForIntent: ContextForIntent<any>, clientIdentity: ClientIdentity): Promise<unknown>
Responsible for resolving an Intent based on a specific Context. Must be overridden.

Returns

Tutorial
interop.handleFiredIntentForContext
Parameters
- contextForIntent: ContextForIntent<any>
  
  Data passed between entities and applications.
- clientIdentity: ClientIdentity
  
  Identity of the Client making the request.
Returns Promise<unknown>

handleInfoForIntent

handleInfoForIntent(options: InfoForIntentOptions<IntentMetadata<any>>, clientIdentity: ClientIdentity): Promise<unknown>
Responsible for returning information on a particular Intent. Must be overridden.

Returns

Tutorial
interop.handleInfoForIntent
Parameters
- options: InfoForIntentOptions<IntentMetadata<any>>
- clientIdentity: ClientIdentity
  
  Identity of the Client making the request.
Returns Promise<unknown>

handleInfoForIntentsByContext

handleInfoForIntentsByContext(context: Context | FindIntentsByContextOptions<IntentMetadata<any>>, clientIdentity: ClientIdentity): Promise<unknown>
Responsible for returning information on which Intents are meant to handle a specific Context. Must be overridden.

Returns

Tutorial
interop.handleInfoForIntentsByContext
Parameters
- context: Context | FindIntentsByContextOptions<IntentMetadata<any>>
  
  Data passed between entities and applications.
- clientIdentity: ClientIdentity
  
  Identity of the Client making the request.
Returns Promise<unknown>

handleJoinSessionContextGroup

handleJoinSessionContextGroup(__namedParameters: {
sessionContextGroupId: string;
}, clientIdentity: ClientIdentity): {
hasConflict: boolean;
}
Parameters
- __namedParameters: {
  sessionContextGroupId: string;
  }
  - sessionContextGroupId: string
- clientIdentity: ClientIdentity
Returns {
hasConflict: boolean;
}
- hasConflict: boolean

intentHandlerRegistered

intentHandlerRegistered(payload: any, clientIdentity: ClientIdentity): Promise<void>
Parameters
- payload: any
- clientIdentity: ClientIdentity
Returns Promise<void>

invokeContextHandler

invokeContextHandler(clientIdentity: ClientIdentity, handlerId: string, context: Context): Promise<void>
This function is called by the Interop Broker whenever a Context handler would fire. For FDC3 2.0 you would need to override this function and add the contextMetadata as part of the Context object. Then would you need to call super.invokeContextHandler passing it this new Context object along with the clientIdentity and handlerId

Returns

Tutorial
interopBroker.invokeContextHandler
Parameters
- clientIdentity: ClientIdentity
- handlerId: string
- context: Context
Returns Promise<void>

invokeIntentHandler

invokeIntentHandler(clientIdentity: ClientIdentity, handlerId: string, intent: Intent<IntentMetadata<any>>): Promise<void>
This function is called by the Interop Broker whenever an Intent handler would fire. For FDC3 2.0 you would need to override this function and add the contextMetadata as part of the Context object inside the Intent object. Then would you need to call super.invokeIntentHandler passing it this new Intent object along with the clientIdentity and handlerId

Returns

Tutorial
interopBroker.invokeIntentHandler
Parameters
- clientIdentity: ClientIdentity
- handlerId: string
- intent: Intent<IntentMetadata<any>>
Returns Promise<void>

isActionAuthorized

isActionAuthorized(_action: string, _payload: any, _identity: ClientIdentity): boolean | Promise<boolean>
Called before every action to check if this entity should be allowed to take the action. Return false to prevent the action
Parameters
- _action: string
  
  the string action to authorize in camel case
- _payload: any
  
  the data being sent for this action
- _identity: ClientIdentity
  
  the connection attempting to dispatch this action
Returns boolean | Promise<boolean>

isConnectionAuthorized

isConnectionAuthorized(_id: Identity, _connectionPayload?: any): boolean | Promise<boolean>
Can be used to completely prevent a connection. Return false to prevent connections. Allows all connections by default.
Parameters
- _id: Identity
  
  the identity tryinc to connect
- Optional _connectionPayload: any
  
  optional payload to use in custom implementations, will be undefined by default
Returns boolean | Promise<boolean>

joinContextGroup

joinContextGroup(joinContextGroupOptions: {
contextGroupId: string;
target?: Identity | ClientIdentity;
}, senderIdentity: ClientIdentity): Promise<void>
Join all connections at the given identity (or just one if endpointId provided) to context group contextGroupId. If no target is specified, it adds the sender to the context group. joinContextGroup is responsible for checking connections at the incoming identity. It calls InteropBroker.addClientToContextGroup to actually group the client. Used by Platform Windows.

Returns
Parameters
- joinContextGroupOptions: {
  contextGroupId: string;
  target?: Identity | ClientIdentity;
  }
  
  Id of the Context Group and identity of the entity to join to the group.
  - contextGroupId: string
  - Optional target?: Identity | ClientIdentity
- senderIdentity: ClientIdentity
  
  Identity of the client sender.
Returns Promise<void>

rehydrateContextGroupStates

rehydrateContextGroupStates(incomingContextGroupStates: ContextGroupStates): void
Parameters
- incomingContextGroupStates: ContextGroupStates
Returns void

removeClientFromContextGroup

removeClientFromContextGroup(clientIdentity: ClientIdentity): Promise<void>
Helper function for InteropBroker.removeFromContextGroup. Does the work of actually removing the client from the Context Group. Used by Platform Windows.

Returns

Property
Identity of the client sender.
Parameters
- clientIdentity: ClientIdentity
Returns Promise<void>

removeContextHandler

removeContextHandler(__namedParameters: {
handlerId: string;
}, clientIdentity: ClientIdentity): void
Parameters
- __namedParameters: {
  handlerId: string;
  }
  - handlerId: string
- clientIdentity: ClientIdentity
Returns void

removeFromContextGroup

removeFromContextGroup(removeFromContextGroupOptions: {
target: Identity;
}, senderIdentity: ClientIdentity): Promise<void>
Removes the specified target from a context group. If no target is specified, it removes the sender from their context group. removeFromContextGroup is responsible for checking connections at the incoming identity. It calls InteropBroker.removeClientFromContextGroup to actually ungroup the client. Used by Platform Windows.

Returns
Parameters
- removeFromContextGroupOptions: {
  target: Identity;
  }
  
  Contains the target identity to remove.
  - target: Identity
- senderIdentity: ClientIdentity
  
  Identity of the client sender.
Returns Promise<void>

setContext

setContext(setContextOptions: {
context: Context;
}, clientIdentity: ClientIdentity): void
Sets a context for the context group of the incoming current entity.

Returns
Parameters
- setContextOptions: {
  context: Context;
  }
  
  New context to set.
  - context: Context
- clientIdentity: ClientIdentity
  
  Identity of the client sender.
Returns void

setIntentTarget

setIntentTarget(intent: Intent<IntentMetadata<any>>, target: Identity): Promise<void>
Should be called in InteropBroker.handleFiredIntent. While handleFiredIntent is responsible for launching applications, setIntentTarget is used to tell the InteropBroker which application should receive the intent when it is ready.

Returns
Parameters
- intent: Intent<IntentMetadata<any>>
  
  The combination of an action and a context that is passed to an application for resolution.
- target: Identity
  
  Identity of the target that will handle the intent.
Returns Promise<void>

updateExistingClients

updateExistingClients(contextGroupStates: ContextGroupStates): void
Parameters
- contextGroupStates: ContextGroupStates
Returns void

`Static` checkContextIntegrity

checkContextIntegrity(context: Context): {
    isValid: true;
} | {
    isValid: false;
    reason: string;
}
Parameters
- context: Context
Returns {
    isValid: true;
} | {
    isValid: false;
    reason: string;
}

`Static` createClosedConstructor

createClosedConstructor(...args: [wire: Transport<EntityType>, getProvider: (() => Promise<OpenFin.ChannelProvider>), options?: any]): (new () => OpenFin.InteropBroker)
Parameters
- Rest ...args: [wire: Transport<EntityType>, getProvider: (() => Promise<OpenFin.ChannelProvider>), options?: any]
Returns (new () => OpenFin.InteropBroker)
- - new (): OpenFin.InteropBroker
  - Returns OpenFin.InteropBroker

`Static` isContextTypeCompatible

isContextTypeCompatible(contextType: string, registeredContextType: undefined | string): boolean
Parameters
- contextType: string
- registeredContextType: undefined | string
Returns boolean

Class InteropBroker

Hideconstructor

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

wire: Transport<EntityType>

getProvider: (() => Promise<OpenFin.ChannelProvider>)

Returns Promise<OpenFin.ChannelProvider>

Optional options: any

Returns OpenFin.InteropBroker

Properties

wire

Accessors

me

Returns Identity

Methods

addClientToContextGroup

Returns

Parameters

addClientToContextGroupOptions: { contextGroupId: string; }

contextGroupId: string

clientIdentity: ClientIdentity

Returns Promise<void>

applySnapshot

Parameters

snapshot: Snapshot

options: ApplySnapshotOptions

Returns void

clientDisconnected

Returns

Tutorial

Parameters

clientIdentity: ClientIdentity

Returns Promise<void>

contextHandlerRegistered

Parameters

__namedParameters: { contextType: undefined | string; handlerId: string; }

contextType: undefined | string

handlerId: string

clientIdentity: ClientIdentity

Returns void

decorateSnapshot

Parameters

snapshot: Snapshot

Returns Snapshot

fdc3HandleFindInstances

Parameters

app: AppIdentifier

clientIdentity: ClientIdentity

Returns Promise<unknown>

fdc3HandleGetAppMetadata

Parameters

app: AppIdentifier

clientIdentity: ClientIdentity

Returns Promise<unknown>

fdc3HandleGetInfo

Returns

Parameters

payload: { fdc3Version: string; }

fdc3Version: string

clientIdentity: ClientIdentity

Returns Promise<unknown>

fdc3HandleOpen

Parameters

fdc3OpenOptions: { app: TargetApp | AppIdentifier; context: Context; }

app: TargetApp | AppIdentifier

context: Context

clientIdentity: ClientIdentity

Returns Promise<void | AppIdentifier>

getAllClientInfo

Returns

Tutorial

Returns Promise<ClientInfo[]>

getAllClientsInContextGroup

`Optional` options: any

addClientToContextGroupOptions: {
contextGroupId: string;
}

__namedParameters: {
contextType: undefined | string;
handlerId: string;
}

payload: {
fdc3Version: string;
}

fdc3OpenOptions: {
app: TargetApp | AppIdentifier;
context: Context;
}

getAllClientsInContextGroupOptions: {
contextGroupId: string;
}

getCurrentContextOptions: {
contextType: string;
}

getInfoForContextGroupOptions: {
contextGroupId: string;
}

__namedParameters: {
sessionContextGroupId: string;
}

Returns {
hasConflict: boolean;
}