Learn more about developing new modules in Parallelix and how they work in a common bundle
How it Works?
Parallelix uses a modular system in order to provide a single API for different platforms. In essence, each module is a wrapper over the official API or SDK.
The Parallelix client connects modules specified in the configuration by loading additional JS scripts;
After initializing the libraries, it sorts them by priority and calls the module on each one
After the required platform is found - its initialization method is called and the client becomes ready to work, providing the required methods with a unified interface
If no platform has been connected, or the application was launched on an unknown platform, the default web module will be connected. Therefore, it is important that it is located in the folder with your modules and is available for connection.
Now let's take a look at the structure of the module.
Module Structure
All modules are stored in the directory of your site, which is specified in the Parallelix configuration. From there they will be connected by name.
It is important to respect the naming of your module:
parallelix.YOUR_MODULE_NAME.js
for example:
parallelix.vk.js
All modules are inherited from the base virtual class ParallelixWrapper. Thus, the methods supported by a module can be described, while the rest will cause an exception.
Let's understand the class structure of your new module:
// Your Parallelix module extends basic virtual ParallelixWrapper
class ParallelixMyModule extends ParallelixWrapper {
// This constructor used at module initialization from Parallelix main class
// instance = Parallelix main class instance
// options = Platform-specific options object from Parallelix config
constructor(instance, options = {}) {
const defaultOptions = {
// Your Default Options
};
// Extend Default options by constructor options
let extendedOptions = {...defaultOptions, ...options};
super(instance, extendedOptions);
this.options = extendedOptions;
// Add Platform Instance (Required!)
this.platform = instance;
// Initialization Flag
this.isInitialized = false;
// API or SDK Client Instance (for Example vkBridge object)
this.invoker = null;
// Add Event Handlers
this.OnError = (options?.OnError && typeof options?.OnError === "function") ? options.OnError : (error) => {
console.error(`Parallelix Web Wrapper Error: ${error.message}`);
};
this.OnInitialized = (options?.OnInitialized && typeof options?.OnInitialized === "function") ? options.OnInitialized : (data) => {
console.log(`Parallelix Web Wrapper Initialized`);
};
}
/**
* Get Module Priority for Platform Detection
* @returns {number} from 0 to 999
*/
get Priority(){
return 1;
}
/**
* Check if this module is for current platform
* @returns {boolean}
*/
IsCurrentPlatform(){
// Here you can determine platform
return true;
}
/**
* Initialize Your Platform SDK
*/
Initialize(){
self.invoker = self; // Put here Your Platform-specific SDK
self.isInitialized = true; // Initialization Flag
self.OnInitialized({}); // Call Initialization Ends Handler
self.HandleEvents(); // Handle All events from platform-specific SDK
}
/**
* Handle All Web Events
*/
HandleEvents(){
let self = this;
// Check if your module is initialized
if(!self.isInitialized) {
onError(new Error("My Module is not initialized"));
return;
}
// Subscribe to Web App Events
window.addEventListener("message", (event) => {
if(!event.data) return;
const { type, data } = event.data;
self.GetEventListener(type)?.(data);
});
}
// *****
// Other Methods Implementation
// *****
}
// It is important to use the same identifier for the object as in the module file name.
Parallelix._platformClasses["YOUR_MODULE_NAME"] = ParallelixMyModule;
Platform Detection
When discovering a platform, your module must check for certain attributes that a Web application can use to realize that it should currently be using your module.
Also, don't forget to prioritize your module check via the Priority() field. The minimum priority is 0, the maximum is 999.
