User Command

// manifest.json
screens : [
  {
    "name": {Menu name in Task Editor module is used},
    "id": {pip-screen-component-id}
    "messageFilters": [
      {
        "action": "com.dart.module.taskeditor.action.USER_COMMAND",
        "category": "dart.message.category.PIP_SCREEN"
      }
    ]
  }
],

services : [
  {
    "name": {Service component name},
    "id": {service-component-id(should be same as pip-screen-component-id)}
    "messageFilters": [
      {
        "action": "com.dart.module.taskeditor.action.USER_COMMAND",
        "category": "dart.message.category.SERVICE"
      }
    ]
  }
]

const message = new Message({action:"com.dart.module.taskeditor.action.USER_COMMAND", category: Context.CATEGORY_PIP_SCREEN});
const packageManager = this.moduleContext.getSystemManager(Context.MODULE_PACKAGE_MANAGER) as IModulePackageManager;
const resolveInfos = packageManager.queryModuleScreenInfo(message);
// Compose the sub menu of 'User Command' by using resolveInfos information

class PipScreenForTaskEditor extends ModuleScreen { 
  componentDidMount() {
    // 1. At PiPScreen mount point, when saveData exists in message, UI initialization proceeds
    if (this.message && this.message.data.hasOwnProperty("savedData")) {
      const version = this.message.data["savedVersion"];
      const data = this.message.data["savedData"];
    }
  }
}

readonly handleOnClickMenu = (packageName: string) => { // packageName of User Command module that User selected
  // 1. Initialization of message obejct for PiPScreen execution of selected User Command module
  const message = new Message({action:"com.dart.module.taskeditor.action.USER_COMMAND", category: Context.CATEGORY_PIP_SCREEN, packageName});

  // 2. When loading the saved data to the screen, add data to message.data
  // const { data, version } = db.query(...);
  // message.data = { savedVersion: version, savedData: data};

  // 3. Request for execution and binding of PiPScreen
  const screenManager = this.moduleContext.getSystemManager(Context.MODULE_SCREEN_MANAGER) as IModuleScreenManager;
  screenManager.bindPipModuleScreen(message, this.refCotnainer.current, this.binder)
    .then(result => {
      if (!result) {
        // Exception handling is required on binding failure
      }
  });
}

private channel: IModuleChannel | null = null;
// 4. binder Initializaion
readonly binder: IModuleComponentBinder = {
  onBound: (packageName: string, componentId: string, channel: IModuleChannel) => {
    // Check whether the channel of binded User Command module component provides the event this Task Editor module needs
    if (!channel.containsOnAnotherSide(["get_current_data"]) {
      // Exception handling is needed on required event absence
    }
  }
}

class PipScreenForTaskEditor extends ModuleScreen {
  onBind(message: Message, channel: IModuleChannel): boolean {
      ...
      // 1. Event Registration for receiving "get_current_data" event from Task Editor module
      channel.receive("get_current_data", () => {
          const data: Record<string, any> = {};

          // 2. Add data entered in PiPScreen to data object
          // data["..."] = ...;

          // 3. Deliver it to Task Editor module
          channel.send("get_current_data", data);
      });
      ...
      return true;
  }
}

getDataFromUserCommand = (channel: IModuleChannel, resolveInfo: IModuleResolveInfo) => {
  // 1. Event registration for receiving "get_current_data" response event from User Command
  channel.receive("get_current_data", (data?: Record<string, any>) => {
    if (data) {
      // 3-1. Version information of User Command module
      const version = resolveInfo.packageInfo.version;
      const packageName = resolveInfo.packageInfo.packageName;

      // 3-2. Save data and version information delivered from User Command module
      const db.insert/update(packageName, version, data);
    }
  });

  // 2. "get_current_data" event request to User Command module
  channel.send("get_current_data");
}

class ServiceForTaskEditor extends ModuleService {
  onBind(message: Message, channel: IModuleChannel): boolean {
      ...
      // 1-1. Event registration for receiving "req_to_save_commands_def_as_sub_program" event from Task Editor module
      channel.receive("req_to_save_commands_def_as_sub_program", ({programName: string}) => {
          // 1-2. Generate Commands Definition for User Command execution
          const program = `
          from DRCF import *
          def pick(j1, j2, j3, ...):
              movej(posj(j1, j2, j3, ...), ...)
              ...
          
          def releaes(j1, j2, j3, ...):
              movej(posj(j1, j2, j3, ...), ...)
              ...
          `;

          const programManager = this.moduleContext.getSystemManager(Context.PROGRAM_MANAGER) as IProgramManager;
          programManager.saveSubProgram(PROGRAM_SAVE_MODE.SAVE, programName, program)
            .then(result => {
                // 1-3. Delivers the information on sub program saving result to Task Editor
                channel.send("req_to_save_commands_def_as_sub_program", result);
            });
      });

      // 2-1. Event registration for receiving "gen_command_call" event from Task Editor module
      channel.receive("gen_command_call", ({componentId: string, data: Record<string, any>}) => {
          // 2-2. About the appropriate Command for 'componentId', generates Command Function Call create command based on the data (user input) (The function must be existing on Command Definition registered at 1.2)
          const result = "..."; // i.e.) pick(10,20,30, ...);
          
          // // i.e) result sample with return variable 
          // // global_pos = pick(10,20,30,…)
          // const result = {
          //        command: "pick(10,20,30,…)',
          //        variableName: "global_pos"
          //      }
          
          // // i.e) result sample when it fail to generate DRL code. 
          // const result = {
          //        validity: false
          //      }
          
          // 2-3. Deliver result (string)
          channel.send("gen_command_call", result);
      });
      ...
      return true;
  }
}

private bindToUserCommandService = (packageName: string) => {
  // 1. Define Message to bind with Service Component of target User Command module
  const message = new Message({action:"com.dart.module.taskeditor.action.USER_COMMAND", category: Context.CATEGORY_SERVICE, packageName });
 
  // 2. Binding request via IModuleServiceManager
  const serviceManager = this.moduleContext.getSystemManager(Context.MODULE_SERVICE_MANAGER);
  serviceManager.bindModuleService(message, this.binder)
    .then(result => {
      if (!result) {
        // Exception handling is required on binding failure
      } else if (!channel.containsOnAnotherSide(["req_to_save_commands_def_as_sub_program", "gen_command_call"]) {
        // Exception handling is needed on event absence Task Editor module requires
      } else {
        // do something
      }
  });
}

private channel: IModuleChannel | null = null;
private binder: IModuleComponentBinder = {
   onBound: (packageName: string, componentId: string, channel: IModuleChannel) => {
      this.channel = channel
  },
  onUnbound(packageName: string, componentId: string): void {
      this.channel = null;
  }
}

// When running task, request to register the function definition file on User Commands which are used in the Task, as Sub Program directly to the Controller with User Command module
private reqToSaveCommandDefAsSubProgram = (channel: IModuleComponentBinder, commandModulePackageName: string, componentId: string) => {
  // 3. Event register for receiving "gen_drl_function_definition" response from User Command module
  const subProgramName = `${commandModulePackageName.replaceAll(".", "_")}_commands`;
  channel.receive("req_to_save_commands_def_as_sub_program", (result: boolean) => {
    if (result) {
       // 5-1. If User Commands successes to save sub program, add DRL command that loads the sub program from the top of the task of Task Editor
       // i.e.) Statements such as "xxxCommands = sub_program_run("subProgramName"")" must be added on the top of the DRL program data
    } else {
       // 5-2. Handling exceptions that prevent DRL execution due to the User Command issue
    }
  });
  
  // 4. "req_to_save_dommands_def_as_sub_program" event request to User Command module
  channel.send("req_to_save_commands_def_as_sub_program", {programName: subProgramName});
}

// When running task, adding Function Call statement is needed for operation of each User Command (Required for each User Command added within the task)
private generateDrlFunctionCall = (channel: IModuleComponentBinder, componentId: string, data: Record<string, any>) => {

  // 6. Event registration for receiving "gen_command_call" response from User Command module
  channel.receive("gen_command_call", (cmdCallFunc: string | null) => {
    if (cmdCallFunc) {
      // 8. Add call syntax by combining cmdCallFunc value delivered from User Command module and variable value loaded Command program of 5-1
      // i.e.) Assuming cmdCallFunc is 'pick(10, 20, 30, ...)', DRL syntax xxxCommands.pick(10, 20, 30, ...) must be added
    } else {
      5-2. Handling exception occurred by Command Call Function generation failure of User Command
    }
  });

  // 7. "gen_command_call" event request to User Command module
  channel.send("gen_drl_function_call", {componentId: componentId, data: data});
}