Anatomy of a module

While the internal implementation of the modules is quite different, they all share common features. Each type of module has an interface that defines how it interacts with io-asr:

asr_recognizer_if_t for the recognizer module
asrp_module_interface_t for the prompt module
asra_module_interface_t for the audio modules
asr_conversation_if_t for the conversation modules

Each interface includes some or all of the following members:

name (all modules)—the name of the module
version (all modules)—the version of the of libasr-core that the module was built against. The io-asr service checks this version number to ensure that the module is compatible with the current system.
init() (all modules)—a callback function that performs whatever initialization tasks are required to get the module ready to handle requests from io-asr
start() (prompt, audio, recognizer)—a callback function that causes the module to begin performing its particular operation
stop() (all modules)—a callback function that causes the module to stop performing its particular operation
step() (prompt, recognizer), on_asr_step() (conversation)— callback functions that perform actions depending on the current step (asr_step_t) of the recognizer

All modules provide an initialization function that io-asr invokes when the module is loaded. In addition to setting up module-specific data, the initialization function also loads the configuration tree and extracts the confidence threshold that's used to select speech-to-text results from the recognizer. The confidence threshold value is set globally per instance of the io-asr subsystem. This threshold is used frequently; saving it to memory speeds up access since the module won't have to walk the configuration tree each time the threshold is required.

Many of the callback functions in the module interfaces take private module-specific data as an argument (init(), destroy(), start(), stop()). This argument is a void pointer that's usually named module_data. ASR doesn't access this data, so its structure can be whatever is required by the individual module; two modules of the same type might use different module-specific data. This module-specific data structure can be passed to io-asr via the module's connect() function. ASR can then pass it as an argument to the module's callback functions.