Channel API

async function makeProvider() {
  // entity creates a channel and becomes the channelProvider
  const providerBus = await fin.InterApplicationBus.Channel.create('channelName');

  providerBus.onConnection((identity, payload) => {
    // can reject a connection here by throwing an error
    console.log('Client connection request identity: ', JSON.stringify(identity));
    console.log('Client connection request payload: ', JSON.stringify(payload));
  });

  providerBus.register('topic', (payload, identity) => {
    // register a callback for a 'topic' to which clients can dispatch an action
    console.log('Action dispatched by client: ', JSON.stringify(identity));
    console.log('Payload sent in dispatch: ', JSON.stringify(payload));
  });
}

static async void MakeProvider()
  {
    var fin = GetRuntime();

    var providerBus = fin.InterApplicationBus.Channel.CreateProvider("channelName");
    await providerBus.OpenAsync();
    
    providerBus.Opened += (identity, payload) =>
    {
      Console.WriteLine("Client connection request identity: ", identity?.ToString());
      Console.WriteLine("Client connection request payload: ", payload?.ToString());
    };
    
    providerBus.RegisterTopic<Object>("topic", (payload, client) =>
    {
      Console.WriteLine("Action dispatched by client: ", client.RemoteEndpoint);
      Console.WriteLine("Payload sent in dispatch: ", payload?.ToString());
    });
  }

public void makeProvider() {
  desktopConnection.getChannel(CHANNEL_NAME).createAsync().thenAccept(provider -> {
    provider.addProviderListener(new ChannelProviderListener() {
      @Override
      public void onClientConnect(ChannelClientConnectEvent connectionEvent) throws Exception {
        logger.info(String.format("provider receives client connect event from %s ", connectionEvent.getUuid()));
        JSONObject payload = (JSONObject) connectionEvent.getPayload();
        if (payload != null) {
          String name = payload.optString("name");
          if ("badguy".equals(name)) {
              // throw exception here to reject the connection
              throw new Exception("stay out");
          }
        }
      }
      @Override
      public void onClientDisconnect(ChannelClientConnectEvent connectionEvent) {
        logger.info(String.format("provider receives channel disconnect event from %s ", connectionEvent.getUuid()));
      }
    });
      
    provider.register("topic", new ChannelAction() {
      @Override
      public JSONObject invoke(String action, Object payload, JSONObject senderIdentity) {
        logger.info(String.format("provider processing action %s, payload=%s", action, payload.toString()));
        JSONObject obj = new JSONObject();
        obj.put("response", "123");
        return obj;
      }
    });
  });
}

async function makeClient(channelName) {
  // A payload can be sent along with channel connection requests to help with authentication
  const connectPayload = { payload: 'token' };

  // If the channel has been created this request will be sent to the provider.  If not, the
  // promise will not be resolved or rejected until the channel has been created. 
  const clientBus = await fin.InterApplicationBus.Channel.connect('channelName', connectPayload);

  clientBus.onDisconnection(channelInfo => {
    // handle the channel lifecycle here - we can connect again which will return a promise
    // that will resolve if/when the channel is re-created.
    makeClient(channelInfo.channelName);
  })

  clientBus.register('topic', (payload, identity) => {
    // register a callback for a topic to which the channel provider can dispatch an action
    console.log('Action dispatched by provider: ', JSON.stringify(identity));
    console.log('Payload sent in dispatch: ', JSON.stringify(payload));
    return {
        echo: payload
    };
  });
}

static async void MakeClient()
  {
    var fin = GetRuntime();

    var opts = new ChannelConnectOptions("channelName")
    {
      // A payload can be sent along with channel connection requests to help with authentication
      Payload = "token"
    };

    var clientBus = fin.InterApplicationBus.Channel.CreateClient(opts);
    // If the channel has been created this request will be sent to the provider.  If not, the
    // promise will not be resolved or rejected until the channel has been created.
    await clientBus.ConnectAsync();


    clientBus.Closed += (identity, payload) =>
    {
      // handle the channel lifecycle here - we could attempt re-open a closed channel
      // or clean up after it, or else write to logs
      Console.WriteLine("Channel closed by: ", identity);
      Console.WriteLine("Channel closed payload: ", payload);
    };
    
    // register a callback for a topic to which the channel provider can dispatch an action
    clientBus.RegisterTopic<Object>("topic", (payload) =>
    {
      Console.WriteLine("Payload sent in dispatch: ", payload);
    });
  }

public void MakeClient() {
  JSONObject payload = new JSONObject();
  payload.put("name", "java example");
  desktopConnection.getChannel(CHANNEL_NAME).connectAsync(payload).thenAccept(client -> {
    client.register("event", new ChannelAction() {
      @Override
      public JSONObject invoke(String action, Object payload, JSONObject senderIdentity) {
          logger.info("channel event {}", action);
          return null;
      }
    });

    client.register("topic", new ChannelAction() {
      @Override
      public Object invoke(String action, Object payload, JSONObject jsonObject) {
          logger.info(String.format("provider processing action %s, payload=%s", action, payload.toString()));
          return null;
      }
    });
  });
}

// previously created channelBus here could be a client or provider
channelBus.register('topic1', (payload, identity) => {
  // register a callback for a given topic to which the sender can dispatch an action
  const somePayload = someAction(payload, identity);
  // The return value will be returned as a payload in response to the sender
  return somePayload;
});

channelBus.setDefaultAction((topic, payload, senderIdentity) => {
  // register a callback for topics that do not have a registered action
  return 'Dispatch will now resolve with this payload instead of reject on sender side.';
});

// if channelBus is a providerBus, there are three arguments to dispatch
// and the first argument determines which client to target.
const response = await channelBus.dispatch('topic2', 'payload');

// the dispatch method returns a promise that resolves to the return value of the
// register method's listener of the channel counterpart. 
document.querySelector('#someId').innerText = response;

static async void MakeClient()
{
  var fin = GetRuntime();

  var opts = new ChannelConnectOptions("channelName")
  {
    // A payload can be sent along with channel connection requests to help with authentication
    Payload = "token"
  };

  var clientBus = fin.InterApplicationBus.Channel.CreateClient(opts);
  // If the channel has been created this request will be sent to the provider.  If not, the
  // promise will not be resolved or rejected until the channel has been created.
  await clientBus.ConnectAsync();


  clientBus.Closed += (identity, payload) =>
  {
    // handle the channel lifecycle here - we could attempt re-open a closed channel
    // or clean up after it, or else write to logs
    Console.WriteLine("Channel closed by: ", identity);
    Console.WriteLine("Channel closed payload: ", payload);
  };
  
  // register a callback for a topic to which the channel provider can dispatch an action
  clientBus.RegisterTopic<Object>("topic", (payload) =>
  {
    Console.WriteLine("Payload sent in dispatch: ", payload);
  });
}

/**
     * Create a provider that supports "getValue", "increment" and "incrementBy n" actions
     */
    public void createChannelProvider() {

        // Create the channel provider.
        desktopConnection.getChannel(CHANNEL_NAME).createAsync().thenAccept(provider -> {
            provider.addProviderListener(new ChannelProviderListener() {

                // Create the onChannelConnect event handler.
                @Override
                public void onClientConnect(ChannelClientConnectEvent connectionEvent) throws Exception {

                    // Add a line to the log file to identify the UUID of the caller.
                    logger.info(String.format("provider receives client connect event from %s ", connectionEvent.getUuid()));

                    // Extract the JSON payload.
                    JSONObject payload = (JSONObject) connectionEvent.getPayload();

                    // If the "name" element of the payload says the client is invalid, reject the request.
                    if (payload != null) {
                        String name = payload.optString("name");
                        if ("Invalid Client".equals(name)) {
                            throw new Exception("request rejected");
                        }
                    }
                }

                // Create the onChannelDisconnect event handler.
                @Override
                public void onClientDisconnect(ChannelClientConnectEvent connectionEvent) {

                    // Add a line to the log file identifying the UUID of the caller.
                    logger.info(String.format("provider receives channel disconnect event from %s ", connectionEvent.getUuid()));
                }
            });

            // The provider was created. Now to register the actions.
            // ------------------------------------------------------

            // This variable is used as the "value" element for the getValue, increment, and incrementBy actions.
            AtomicInteger localInteger = new AtomicInteger(0);

            // Register the "getValue" action.
            // This action will return the value of the localInteger variable.
            provider.register("getValue", new ChannelAction() {

                // This is the logic for the "getValue" action.
                @Override
                public JSONObject invoke(String action, Object payload, JSONObject senderIdentity) {

                    // Write a string to the logfile that shows the requested action and payload.
                    logger.info(String.format("provider processing action %s, payload=%s", action, payload.toString()));

                    // Create a JSON object to return to the channel client.
                    JSONObject obj = new JSONObject();

                    // Set the "value" JSON element to the value of the localInteger variable.
                    obj.put("value", localInteger.get());

                    // Return the JSON object to the channel client.
                    return obj;
                }
            });

            // Register the "increment" action.
            // This action will increment the value of the localInteger variable by one.
            provider.register("increment", new ChannelAction() {

                // This is the logic for the "increment" action.
                @Override
                public JSONObject invoke(String action, Object payload, JSONObject senderIdentity) {

                    // Write a string to the logfile that identifies the action and payload.
                    logger.info(String.format("provider processing action %s, payload=%s", action, payload.toString()));

                    // Create a JSON object to return to the channel client.
                    JSONObject obj = new JSONObject();

                    // Increment localInteger and set the "value" JSON element to the new value of localInteger.
                    obj.put("value", localInteger.incrementAndGet());
                    provider.publish("event", obj, null);

                    // Return the JSON object to the channel client.
                    return obj;
                }
            });

            // Register the "incrementBy" action.
            // This action will increment the value of the localInteger variable by a specified amount.
            provider.register("incrementBy", new ChannelAction() {

                // This is the logic for the "incrementBy" action.
                @Override
                public JSONObject invoke(String action, Object payload, JSONObject senderIdentity) {

                    // Write a string to the logfile that identifies the action and payload.
                    logger.info(String.format("provider processing action %s, payload=%s", action, payload.toString()));

                    // Extract the increment amount (delta) from the payload JSON object.
                    int delta = ((JSONObject)payload).getInt("delta");

                    // Create a new JSON object to return to the channel client.
                    JSONObject obj = new JSONObject();

                    // Increase localInteger by the delta amount and set the "value" JSON element to the new value of localInteger.
                    obj.put("value", localInteger.addAndGet(delta));

                    // Return the new JSON object to the channel client.
                    return obj;
                }
            });
        });
    }

// provider with support for both protocols
const provider = await fin.InterApplicationBus.Channel.create('channelName', { protocols: ['rtc', 'classic'] });

// connect as an rtc client
const rtcClient = await fin.InterApplicationBus.Channel.connect('channelName', { protocols: ['rtc'] });

// connect as a classic client
const classicClient = await fin.InterApplicationBus.Channel.connect('channelName', { protocols: ['classic'] });