[platform/core/api/webapi-plugins.git] / src / ml / js / ml_pipeline.js

/*
 * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

var kPipelineStateChangeListenerNamePrefix = 'MLPipelineStateChangeListener';
var kSinkListenerNamePrefix = 'MLPipelineSinkListener';
var kCustomFilterListenerNamePrefix = 'MLPipelineCustomFilterListener';

//PipelineManager::createPipeline() begin
var ValidPipelineDisposeExceptions = ['NotFoundError', 'NotSupportedError', 'AbortError'];

var nextPipelineId = 1;
function NextPipelineId() {
    return nextPipelineId++;
}

var ValidPipelineManagerCreatePipelineExceptions = [
    'InvalidValuesError',
    'TypeMismatchError',
    'NotSupportedError',
    'SecurityError',
    'AbortError'
];

var CreatePipeline = function() {
    privUtils_.log('Entered PipelineManager.createPipeline()');
    var args = validator_.validateArgs(arguments, [
        {
            name: 'definition',
            type: validator_.Types.STRING
        },
        {
            name: 'listener',
            type: validator_.Types.FUNCTION,
            optional: true,
            nullable: true
        }
    ]);

    if (!args.has.definition) {
        throw new WebAPIException(
            WebAPIException.INVALID_VALUES_ERR,
            'Invalid parameter: pipeline definition is mandatory'
        );
    }

    var pipeline = new Pipeline(NextPipelineId());
    var nativeArgs = {
        id: pipeline._id,
        definition: args.definition
    };

    if (args.listener) {
        nativeArgs.listenerName = kPipelineStateChangeListenerNamePrefix + pipeline._id;
        var stateChangeListener = function(stateObject) {
            args.listener(stateObject.state);
        };
        native_.addListener(nativeArgs.listenerName, stateChangeListener);
    }

    var result = native_.callSync('MLPipelineManagerCreatePipeline', nativeArgs);

    if (native_.isFailure(result)) {
        if (nativeArgs.listenerName) {
            native_.removeListener(nativeArgs.listenerName);
        }
        throw native_.getErrorObjectAndValidate(
            result,
            ValidPipelineManagerCreatePipelineExceptions,
            AbortError
        );
    }

    return pipeline;
};
//PipelineManager::createPipeline() end

//Pipeline::state begin
var ValidPipelineStateExceptions = ['NotSupportedError', 'AbortError'];
var Pipeline = function(id) {
    Object.defineProperties(this, {
        state: {
            enumerable: true,
            get: function() {
                var result = native_.callSync('MLPipelineGetState', {
                    id: id
                });
                if (native_.isFailure(result)) {
                    throw native_.getErrorObjectAndValidate(
                        result,
                        ValidPipelineStateExceptions,
                        AbortError
                    );
                }

                return result.result;
            }
        },
        _id: {
            value: id
        }
    });
};
//Pipeline::state end

//Pipeline::start() begin
var ValidPipelineStartStopExceptions = [
    'NotFoundError',
    'NotSupportedError',
    'AbortError'
];
Pipeline.prototype.start = function() {
    var nativeArgs = {
        id: this._id
    };

    var result = native_.callSync('MLPipelineStart', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidPipelineStartStopExceptions,
            AbortError
        );
    }
};
//Pipeline::start() end

//Pipeline::stop() begin
Pipeline.prototype.stop = function() {
    var nativeArgs = {
        id: this._id
    };

    var result = native_.callSync('MLPipelineStop', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidPipelineStartStopExceptions,
            AbortError
        );
    }
};
//Pipeline::stop() end

//Pipeline::dispose() begin
Pipeline.prototype.dispose = function() {
    var result = native_.callSync('MLPipelineDispose', { id: this._id });

    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidPipelineDisposeExceptions,
            AbortError
        );
    }
};
//Pipeline::dispose() end

//Pipeline::getNodeInfo() begin
var NodeInfo = function(name, pipeline_id) {
    Object.defineProperties(this, {
        name: { enumerable: true, writable: false, value: name },
        _pipeline_id: { value: pipeline_id }
    });
};

var ValidPipelineGetNodeInfoExceptions = [
    'InvalidValuesError',
    'NotFoundError',
    'NotSupportedError',
    'AbortError'
];

Pipeline.prototype.getNodeInfo = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'name',
            type: validator_.Types.STRING
        }
    ]);

    var nativeArgs = {
        id: this._id,
        name: args.name
    };

    var result = native_.callSync('MLPipelineGetNodeInfo', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidPipelineGetNodeInfoExceptions,
            AbortError
        );
    }

    return new NodeInfo(args.name, this._id);
};
//Pipeline::getNodeInfo() end

//Pipeline::getSource() begin
var ValidInputTensorsInfoExceptions = ['NotFoundError', 'AbortError'];
function Source(name, pipeline_id) {
    Object.defineProperties(this, {
        name: {
            enumerable: true,
            value: name
        },
        inputTensorsInfo: {
            get: function() {
                var result = native_.callSync('MLPipelineGetInputTensorsInfo', {
                    id: this._pipeline_id,
                    name: this.name
                });
                if (native_.isFailure(result)) {
                    throw native_.getErrorObjectAndValidate(
                        result,
                        ValidInputTensorsInfoExceptions,
                        AbortError
                    );
                }

                return new TensorsInfo(result.id);
            }
        },
        _pipeline_id: {
            value: pipeline_id
        }
    });
}

var ValidPipelineGetSourceExceptions = [
    'InvalidStateError',
    'InvalidValuesError',
    'NotFoundError',
    'NotSupportedError',
    'AbortError'
];

Pipeline.prototype.getSource = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'name',
            type: validator_.Types.STRING
        }
    ]);

    if (!args.has.name) {
        throw new WebAPIException(
            WebAPIException.INVALID_VALUES_ERR,
            'Invalid parameter: name is mandatory'
        );
    }

    var nativeArgs = {
        id: this._id,
        name: args.name
    };

    var result = native_.callSync('MLPipelineGetSource', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidPipelineGetSourceExceptions,
            AbortError
        );
    }

    return new Source(args.name, this._id);
};
//Pipeline::getSource() end

//Pipeline::getSwitch() begin
function Switch(name, type, pipeline_id) {
    Object.defineProperties(this, {
        name: {
            enumerable: true,
            value: name
        },
        type: {
            enumerable: true,
            value: type
        },
        _pipeline_id: {
            value: pipeline_id
        }
    });
}

var ValidPipelineGetSwitchExceptions = [
    'InvalidStateError',
    'InvalidValuesError',
    'NotFoundError',
    'NotSupportedError',
    'AbortError'
];
Pipeline.prototype.getSwitch = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'name',
            type: validator_.Types.STRING
        }
    ]);

    var nativeArgs = {
        name: args.name,
        id: this._id
    };
    var result = native_.callSync('MLPipelineGetSwitch', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidPipelineGetSwitchExceptions,
            AbortError
        );
    }

    return new Switch(nativeArgs.name, result.type, this._id);
};
//Pipeline::getSwitch() end

//Pipeline::getValve() begin
var ValidValveIsOpenAndSetOpenExceptions = [
    'NotFoundError',
    'NotSupportedError',
    'AbortError'
];
function Valve(name, pipeline_id) {
    Object.defineProperties(this, {
        name: {
            enumerable: true,
            value: name
        },
        _pipeline_id: {
            value: pipeline_id
        },
        isOpen: {
            get: function() {
                var result = native_.callSync('MLPipelineValveIsOpen', {
                    id: this._pipeline_id,
                    name: this.name
                });

                if (native_.isFailure(result)) {
                    throw native_.getErrorObjectAndValidate(
                        result,
                        ValidValveIsOpenAndSetOpenExceptions,
                        AbortError
                    );
                }

                return result.result;
            },
            set: function() {},
            enumerable: true
        }
    });
}

var ValidPipelineGetValveExceptions = [
    'InvalidValuesError',
    'NotFoundError',
    'NotSupportedError',
    'AbortError'
];
Pipeline.prototype.getValve = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'name',
            type: validator_.Types.STRING
        }
    ]);

    var nativeArgs = {
        name: args.name,
        id: this._id
    };

    var result = native_.callSync('MLPipelineGetValve', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidPipelineGetValveExceptions,
            AbortError
        );
    }

    return new Valve(nativeArgs.name, this._id);
};
//Pipeline::getValve() end

//Pipeline::registerSinkListener() begin
var ValidRegisterSinkListenerExceptions = [
    'InvalidValuesError',
    'NotFoundError',
    'NotSupportedError',
    'TypeMismatchError',
    'AbortError'
];
Pipeline.prototype.registerSinkListener = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'name',
            type: validator_.Types.STRING
        },
        {
            name: 'sinkListener',
            type: types_.FUNCTION
        }
    ]);

    var nativeArgs = {
        id: this._id,
        name: args.name,
        listenerName: kSinkListenerNamePrefix + args.name
    };

    var sinkListener = function(msg) {
        var sinkData = new TensorsData(msg.tensorsDataId, msg.tensorsInfoId);
        args.sinkListener(args.name, sinkData);
    };
    native_.addListener(nativeArgs.listenerName, sinkListener);

    var result = native_.callSync('MLPipelineRegisterSinkListener', nativeArgs);
    if (native_.isFailure(result)) {
        native_.removeListener(nativeArgs.listenerName);

        throw native_.getErrorObjectAndValidate(
            result,
            ValidRegisterSinkListenerExceptions,
            AbortError
        );
    }
};
//Pipeline::registerSinkListener() end

//Pipeline::unregisterSinkListener() begin
var ValidUnregisterSinkListenerExceptions = [
    'InvalidValuesError',
    'NotFoundError',
    'NotSupportedError',
    'AbortError'
];
Pipeline.prototype.unregisterSinkListener = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'name',
            type: validator_.Types.STRING
        }
    ]);

    if (!args.has.name) {
        throw new WebAPIException(
            WebAPIException.INVALID_VALUES_ERR,
            'Invalid parameter: sink name is mandatory'
        );
    }

    var nativeArgs = {
        id: this._id,
        name: args.name
    };

    var result = native_.callSync('MLPipelineUnregisterSinkListener', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidUnregisterSinkListenerExceptions,
            AbortError
        );
    }

    var listenerName = kSinkListenerNamePrefix + args.name;
    native_.removeListener(listenerName);
};
//Pipeline::unregisterSinkListener() end

var PropertyType = {
    BOOLEAN: 'BOOLEAN',
    DOUBLE: 'DOUBLE',
    ENUM: 'ENUM',
    INT32: 'INT32',
    INT64: 'INT64',
    UINT32: 'UINT32',
    UINT64: 'UINT64',
    STRING: 'STRING'
};
//NodeInfo::getProperty() begin
var ValidNodeInfoGetPropertyExceptions = [
    'InvalidValuesError',
    'NotFoundError',
    'NotSupportedError',
    'TypeMismatchError',
    'AbortError'
];
NodeInfo.prototype.getProperty = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'name',
            type: validator_.Types.STRING
        },
        {
            name: 'propertyType',
            type: types_.ENUM,
            values: Object.keys(PropertyType)
        }
    ]);

    var nativeArgs = {
        id: this._pipeline_id,
        nodeName: this.name,
        name: args.name,
        type: args.propertyType
    };

    var result = native_.callSync('MLPipelineNodeInfoGetProperty', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidNodeInfoGetPropertyExceptions,
            AbortError
        );
    }

    return result.property;
};
//NodeInfo::getProperty() end

//NodeInfo::setProperty() begin
var ValidNodeInfoSetPropertyExceptions = [
    'InvalidValuesError',
    'NotFoundError',
    'NotSupportedError',
    'TypeMismatchError',
    'AbortError'
];
NodeInfo.prototype.setProperty = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'name',
            type: validator_.Types.STRING
        },
        {
            name: 'propertyType',
            type: types_.ENUM,
            values: Object.keys(PropertyType)
        },
        {
            name: 'property',
            type: types_.SIMPLE_TYPE
        }
    ]);

    var nativeArgs = {
        id: this._pipeline_id,
        nodeName: this.name,
        name: args.name,
        type: args.propertyType,
        property: args.property
    };

    var result = native_.callSync('MLPipelineNodeInfoSetProperty', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidNodeInfoSetPropertyExceptions,
            AbortError
        );
    }
};
//NodeInfo::setProperty() end

//Source::inputData() begin
var ValidSourceInputDataExceptions = [
    'InvalidStateError',
    'NotFoundError',
    'NotSupportedError',
    'AbortError'
];
Source.prototype.inputData = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'data',
            type: types_.PLATFORM_OBJECT,
            values: TensorsData
        }
    ]);

    var nativeArgs = {
        id: this._pipeline_id,
        name: this.name,
        tensorsDataId: args.data._id
    };

    var result = native_.callSync('MLPipelineSourceInputData', nativeArgs);

    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidSourceInputDataExceptions,
            AbortError
        );
    }

    return result.result;
};
//Source::inputData() end

//Switch::getPadList() begin
var ValidSwitchGetPadListExceptions = [
    'InvalidStateError',
    'NotFoundError',
    'NotSupportedError',
    'AbortError'
];
Switch.prototype.getPadList = function() {
    var nativeArgs = {
        name: this.name,
        id: this._pipeline_id
    };

    var result = native_.callSync('MLPipelineSwitchGetPadList', nativeArgs);

    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidSwitchGetPadListExceptions,
            AbortError
        );
    }

    return result.result;
};
//Switch::getPadList() end

//Switch::select() begin
var ValidSwitchSelectExceptions = [
    'InvalidValuesError',
    'NotFoundError',
    'NotSupportedError',
    'AbortError'
];
Switch.prototype.select = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'padName',
            type: validator_.Types.STRING
        }
    ]);

    if (!args.has.padName) {
        throw new WebAPIException(
            WebAPIException.INVALID_VALUES_ERR,
            'Invalid parameter: pad name is mandatory'
        );
    }

    var nativeArgs = {
        id: this._pipeline_id,
        name: this.name,
        padName: args.padName
    };

    var result = native_.callSync('MLPipelineSwitchSelect', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidSwitchSelectExceptions,
            AbortError
        );
    }
};
//Switch::select() end

//Valve::setOpen() begin
Valve.prototype.setOpen = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'open',
            type: validator_.Types.BOOLEAN
        }
    ]);

    if (!args.has.open) {
        throw new WebAPIException(
            WebAPIException.INVALID_VALUES_ERR,
            'Invalid parameter: open is mandatory'
        );
    }

    var nativeArgs = {
        id: this._pipeline_id,
        name: this.name,
        open: args.open
    };

    var result = native_.callSync('MLPipelineValveSetOpen', nativeArgs);
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidValveIsOpenAndSetOpenExceptions,
            AbortError
        );
    }
};
//Valve::setOpen() end
var MachineLearningPipeline = function() {};

MachineLearningPipeline.prototype.createPipeline = CreatePipeline;

//Pipeline::registerCustomFilter() begin
var ValidRegisterCustomFilterExceptions = [
    'InvalidValuesError',
    'NotSupportedError',
    'TypeMismatchError',
    'AbortError'
];

var ValidCustomFilterOutputErrors = ['InvalidValuesError', 'AbortError'];

MachineLearningPipeline.prototype.registerCustomFilter = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'name',
            type: validator_.Types.STRING
        },
        {
            name: 'customFilter',
            type: types_.FUNCTION
        },
        {
            name: 'inputInfo',
            type: types_.PLATFORM_OBJECT,
            values: TensorsInfo
        },
        {
            name: 'outputInfo',
            type: types_.PLATFORM_OBJECT,
            values: TensorsInfo
        },
        {
            name: 'errorCallback',
            type: types_.FUNCTION,
            optional: true,
            nullable: true
        }
    ]);

    var nativeArgs = {
        name: args.name,
        listenerName: kCustomFilterListenerNamePrefix + args.name,
        inputTensorsInfoId: args.inputInfo._id,
        outputTensorsInfoId: args.outputInfo._id
    };

    /*
     * CustomFilter processing has 4 stages (the description below assumes
     * the typical scenario with no errors):
     * 1. (C++; non-main thread) C++ callback is called by the native API with input data.
     * The C++ callback wraps native ml_tensors_data_h handles in TensorsData
     * objects and sends them together with associated TensorsInfo to JS.
     * 2. (JS; main thread) customFilterWrapper is called with the input data from C++
     * as one of its arguments. User-provided callback processes the data.
     * The input/output TensorsData that arrive to JS as CustomFilter arguments
     * are unique in that they:
     * - cannot be disposed, i.e. calling {input, output}.dispose() is no-op
     * - input is immutable, i.e. calling input.setTensorRawData() is no-op
     * output.setTensorRawData() modify the native nnstreamer object directly.
     * 3. (C++; main thread) Sleeping callback thread is notified. If anything
     * goes wrong, C++ function returns an error synchronously to stage 4.
     * 4. (JS; main thread) If C++ returned a success, the operation stops.
     * Otherwise, the error callback provided by the user is called.
     * 5. (C++; non-main thread) C++ callback is woken up and returns the status
     * received from user to pipeline.
     */
    var customFilterWrapper = function(msg) {
        /*
         * Check if stage 1. was successful.
         */
        if (native_.isFailure(msg)) {
            native_.callIfPossible(args.errorCallback, customFilterErrorInJs);
            return;
        }

        var inputData = new TensorsData(
            msg.inputTensorsDataId,
            msg.inputTensorsInfoId,
            false
        );
        var outputData = new TensorsData(
            msg.outputTensorsDataId,
            msg.outputTensorsInfoId,
            false
        );

        /*
         * customFilterErrorInJs records errors caused by the CustomFilter callback
         * provided by the user.
         */
        var customFilterErrorInJs = null;
        var jsResponse = {
            status: -1,
            name: nativeArgs.name,
            requestId: msg.requestId
        };

        try {
            jsResponse.status = converter_.toLong(
                args.customFilter(inputData, outputData)
            );
        } catch (exception) {
            var exceptionString =
                typeof exception.toString === 'function'
                    ? exception.toString()
                    : JSON.stringify(exception);
            customFilterErrorInJs = new WebAPIException(
                WebAPIException.ABORT_ERR,
                'CustomFilter has thrown exception: ' + exceptionString
            );
        }

        if (!customFilterErrorInJs && jsResponse.status > 0 && jsResponse.status !== 1) {
            customFilterErrorInJs = new WebAPIException(
                WebAPIException.INVALID_VALUES_ERR,
                'The only legal positive value of status returned from CustomFilter is 1'
            );
            jsResponse.status = -1;
        }

        /*
         * Entering stage 3.
         */
        var result = native_.callSync('MLPipelineManagerCustomFilterOutput', jsResponse);

        /*
         * Stage 4.
         */
        if (customFilterErrorInJs) {
            /*
             * If we detect that user-provided CustomFilter callback caused
             * any errors in JS, the C++ layer gets the message to stop the
             * pipeline (status == -1) and does not reply to JS with errors.
             * Thus, "result" is a success we call the user-provided error
             * callback here.
             */
            native_.callIfPossible(args.errorCallback, customFilterErrorInJs);
        } else if (native_.isFailure(result)) {
            var error = native_.getErrorObjectAndValidate(
                result,
                ValidCustomFilterOutputErrors,
                AbortError
            );

            native_.callIfPossible(args.errorCallback, error);
        }
    };

    if (native_.listeners_.hasOwnProperty(nativeArgs.listenerName)) {
        throw new WebAPIException(
            WebAPIException.INVALID_VALUES_ERR,
            '"' + nativeArgs.name + '" custom filter is already registered'
        );
    }

    native_.addListener(nativeArgs.listenerName, customFilterWrapper);

    var result = native_.callSync('MLPipelineManagerRegisterCustomFilter', nativeArgs);
    if (native_.isFailure(result)) {
        native_.removeListener(nativeArgs.listenerName);

        throw native_.getErrorObjectAndValidate(
            result,
            ValidRegisterCustomFilterExceptions,
            AbortError
        );
    }
};
//Pipeline::registerCustomFilter() end

//Pipeline::unregisterCustomFilter() begin
var ValidUnregisterCustomFilterExceptions = [
    'InvalidValuesError',
    'NotSupportedError',
    'AbortError'
];
MachineLearningPipeline.prototype.unregisterCustomFilter = function() {
    var args = validator_.validateArgs(arguments, [
        {
            name: 'name',
            type: validator_.Types.STRING
        }
    ]);

    if (!args.has.name) {
        throw new WebAPIException(
            WebAPIException.INVALID_VALUES_ERR,
            'Invalid parameter: custom filter name is mandatory'
        );
    }

    var result = native_.callSync('MLPipelineManagerUnregisterCustomFilter', {
        name: args.name
    });
    if (native_.isFailure(result)) {
        throw native_.getErrorObjectAndValidate(
            result,
            ValidUnregisterCustomFilterExceptions,
            AbortError
        );
    }

    var customFilterListenerName = kCustomFilterListenerNamePrefix + args.name;
    native_.removeListener(customFilterListenerName);
};
//Pipeline::unregisterCustomFilter() end

// ML Pipeline API