Runtime API Sample Program

Table of Contents

• Code Example CPP-File
• Example CMake-File

The Sample program demonstrates the main functionality of the OTX-Runtime API. It can be used as a reference for the expected runtime behavior of the API and the source code below is like a reference guide about the proper programming of the API.

Code Example CPP-File

Code example (.\otxruntime\Sample.Console\src\Main.cpp) of the OTX-Runtime API Sample Program.

#include <iostream>
#include <memory>
#include <thread>
#include <string>
#include <sstream>
#include <regex>
 
/* Header files of the OTX-Runtime-Api */
#include <RuntimeManagerFactory.h>
#include <IRuntimeContext.h>
#include <RuntimeConfig.h>
#include <Project/IProject.h>
#include <Otx/IPackage.h>
#include <Otx/IDocument.h>
#include <Otx/IContextVariable.h>
#include <Otx/IStateVariable.h>
#include <Otx/IProcedure.h>
#include <Otx/IProcedureParameter.h>
#include <Otx/IProcedureInParameter.h>
#include <Otx/IProcedureInOutParameter.h>
#include <DataTypes/Object.h>
#include <DataTypes/ValueConverter.h>
#include <Exceptions/Exception.h>
 
using namespace OpenTestSystem::Otx::Runtime::Api;
 
#include <SingletonManager.h>
using OpenTestSystem::Otx::Common::SingletonManager;
 
#include <License/LicenseManager.h>
using namespace OpenTestSystem::Otx::Runtime::Api::License;
/***************************************/
 
/* Header files of the DiagManager */
#include <IOtxDiag.h>
#include <IDiagConfiguration.h>
#include <OtxDiagFactory.h>
using namespace OpenTestSystem::Otx::DiagManager::OtxDiagApi;
 
#include <CommandProcessor.h>
using OpenTestSystem::Otx::DiagManager::CommandProcessor::CommandProcessor;
 
#ifdef _WIN32
#include <filesystem.h>
namespace fs = otx::filesystem;
 
HMODULE DiagRuntimeSystemDLL = NULL;
std::string GetLastErrorAsString();
#elif defined(__linux__) || defined(__QNXNTO__)
#include <unistd.h>
#include <sys/types.h>
#include <dirent.h>
#include <signal.h>
#ifdef  USE_VWMCD_LINK_LIBRARY
#ifdef USE_VWMCDSP
#include <VwMcdSPDiagRuntimeSystem.h>
typedef OpenTestSystem::Otx::DiagManager::DiagRuntimeSystem::VwMcdSPDiagRuntimeSystem VwMcdDiagRuntimeSystem;
#else
#include <VwMcdDiagRuntimeSystem.h>
typedef OpenTestSystem::Otx::DiagManager::DiagRuntimeSystem::VwMcdDiagRuntimeSystem VwMcdDiagRuntimeSystem;
#endif
#else
#include <dlfcn.h>
void* handle;
#endif //  USE_VWMCD_LINK_LIBRARY
#endif
using OpenTestSystem::Otx::DiagManager::Common::IDiagRuntimeSystem;
 
#include "../../../lib/OpenTestSystem.OtxDiagManager.SystemApi/include/Util.h"
using OpenTestSystem::Otx::DiagManager::SystemApi::Util;
/***************************************/
 
/* Header files of the CustomImplementations */
#include <DefaultMeasureImplementation.h>
#include <StateVariableImplementation.h>
#include <ContextVariableImplementation.h>
#include <DefaultCustomScreenImplementation.h>
#include <DefaultExternalServiceProviderImplementation.h>
using namespace OpenTestSystem::Otx::Runtime::Api::Custom;
/***************************************/
 
#include "ExecutionState.h"
#include <ClientFactory.h>
 
bool isProcedureFinished = false;
CommandProcessor* cp = nullptr;
std::shared_ptr<IRuntimeManager> runtimeManager;
std::vector<std::shared_ptr<Otx::IProcedure>> DisplayPtxTree(std::shared_ptr<Project::IProject> project);
std::shared_ptr<Otx::IProcedure> GetProcedure(std::shared_ptr<Project::IProject> project, std::string procedureFullName);
void SelectAndExecuteProcedure(std::shared_ptr<IRuntimeManager> runtimeManager, std::shared_ptr<Project::IProject> project, std::vector<std::shared_ptr<Otx::IProcedure>> procedures);
std::string SelectProject(std::shared_ptr<IDiagConfiguration> diagConfiguration);
std::string SelectVehicleInformation(std::shared_ptr<IDiagConfiguration> diagConfiguration);
std::shared_ptr<IOtxDiag> CreateRawOtxDiag();
 
std::string licenseKey;
bool IsLicenseValid(std::string);
void ReadAndSetOtxRuntimeLicense();
 
IDiagRuntimeSystem* CreateDiagRuntimeSystem(const char* projectName, const char* vehicleInfo, const char* kernelPath, bool useVwmcdSP);
 
std::shared_ptr<DefaultCustomScreenImplementation> customScreenImplementation = std::make_shared<DefaultCustomScreenImplementation>();
std::shared_ptr<DefaultMeasureImplementation> measureImplementation = std::make_shared<DefaultMeasureImplementation>();
std::shared_ptr<StateVariableImplementation> stateVariableImplementation = std::make_shared<StateVariableImplementation>();
std::shared_ptr<ContextVariableImplementation> contextVariableImplementation = std::make_shared<ContextVariableImplementation>();
std::shared_ptr<DefaultExternalServiceProviderImplementation> externalServiceProviderImplementation = std::make_shared<DefaultExternalServiceProviderImplementation>();
 
void ProcedureStarted(const IRuntimeContext& context)
{
    std::cout << std::endl << "Procedure '" << context.GetProcedure()->GetFullName() << "' started" << std::endl;
}
 
void ProcedureFinished(const IRuntimeContext& context)
{
    std::cout << std::endl << "Procedure '" << context.GetProcedure()->GetFullName() << "' finished" << std::endl;
 
    for (size_t i = 0; i < context.GetProcedure()->GetParameters().size(); i++)
    {
        std::shared_ptr<Otx::IProcedureParameter> procedureParameter = context.GetProcedure()->GetParameters().at(i);
 
        std::cout << std::endl << "\tParameterValueFinished(" << procedureParameter->GetDataType() << ", " << procedureParameter->GetName() << " = " << procedureParameter->GetValue()->ToLiteralString() << ")";
    }
    std::cout << std::endl;
 
    isProcedureFinished = true;
}
 
void ProcedureAborted(const IRuntimeContext& context)
{
    std::cout << std::endl << "Procedure '" << context.GetProcedure()->GetFullName() << "' aborted" << std::endl;
    isProcedureFinished = true;
}
 
void ProcedureStopped(const IRuntimeContext& context)
{
    std::cout << std::endl << "Procedure '" << context.GetProcedure()->GetFullName() << "' stopped" << std::endl;
 
    isProcedureFinished = true;
}
 
 
void ProcedureTimeout(const IRuntimeContext& context)
{
    std::cout << std::endl << "Procedure '" << context.GetProcedure()->GetFullName() << "' timeout expired" << std::endl;
}
 
void InOutParameterValueChanged(const IRuntimeContext& context, const IProcedureInOutParameter& parameter)
{
    std::string separator = " || ";
    time_t now = time(0);
    tm* ltm = localtime(&now);
    std::stringstream ss;
    ss << ltm->tm_hour << ":" << ltm->tm_min << ":" << ltm->tm_sec;
 
    std::string outputLog = "InOutParameterValueChanged(" + parameter.GetDataType() + ", " + parameter.GetName() + " = " + parameter.GetValue()->ToLiteralString() + ")";
 
    std::cout << "\t" << ss.str() << separator << outputLog << std::endl;
}
 
void ContextVariableRead(std::shared_ptr<IContextVariable> contextVariable, std::shared_ptr<Object> value)
{
    std::string separator = " || ";
    time_t now = time(0);
    tm* ltm = localtime(&now);
    std::stringstream ss;
    ss << ltm->tm_hour << ":" << ltm->tm_min << ":" << ltm->tm_sec;
 
    std::string mappingStr = contextVariable->GetMappingName().empty() ? "" : (" [MappedTo: " + contextVariable->GetMappingName() + (contextVariable->GetMappingIndex() > -1 ? ("[" + std::to_string(contextVariable->GetMappingIndex()) + "]") : "") + "]");
    std::string outputLog = "ContextVariableRead(" + contextVariable->GetDataType() + ", " + contextVariable->GetDocument()->GetFullName() + "." + contextVariable->GetName() + mappingStr + " = " + value->ToLiteralString() + ")";
 
    std::cout << "\t" << ss.str() << separator << outputLog << std::endl;
}
void StateVariableValueChanged(std::shared_ptr<IStateVariable> stateVariable, std::shared_ptr<Object> value)
{
    std::string mappingStr = stateVariable->GetMappingName().empty() ? "" : (" [MappedTo: " + stateVariable->GetMappingName() + (stateVariable->GetMappingIndex() > -1 ? ("[" + std::to_string(stateVariable->GetMappingIndex()) + "]") : "") + "]");
    std::string outputLog = "StateVariableChanged(" + stateVariable->GetDataType() + ", " + stateVariable->GetDocument()->GetFullName() + "." + stateVariable->GetName() + mappingStr + " = " + value->ToLiteralString() + ")";
    std::string separator = " || ";
    time_t now = time(0);
    tm* ltm = localtime(&now);
    std::stringstream ss;
    ss << ltm->tm_hour << ":" << ltm->tm_min << ":" << ltm->tm_sec;
 
    std::cout << "\t" << ss.str() << separator << outputLog << std::endl;
}
 
std::vector<std::string> SplitString(std::string str, char delimiter)
{
    std::string token;
    std::istringstream ss(str);
    std::vector<std::string> tokens;
    while (std::getline(ss, token, delimiter))
    {
        tokens.push_back(token);
    }
 
 
    return tokens;
}
 
bool IsLicenseValid(std::string licenseKey)
{
    try
    {
        LicenseManager::SetLicenseKey(licenseKey);
        // Try to create a runtime manager instance with the inputed license key. An exception is thrown if the license key is invalid.
        RuntimeManagerFactory::CreateRawRuntimeManager();
        return true;
    }
    catch (const std::exception& e)
    {
        std::cout << e.what() << std::endl;
        return false;
    }
}
 
void ReadAndSetOtxRuntimeLicense()
{
    while (true)
    {
        std::cout << "Please enter your OtxRuntime license key here (enter empty to exit): ";
        std::getline(std::cin, licenseKey);
 
        if (licenseKey.empty())
        {
            exit(0);
        }
 
        std::regex pattern("^[0-9a-zA-Z]{5}-[0-9a-zA-Z]{5}-[0-9a-zA-Z]{5}-[0-9a-zA-Z]{5}-[0-9a-zA-Z]{5}$|^$");
 
        if (std::regex_match(licenseKey, pattern))  // license key must match the format XXXXX-XXXXX-XXXXX-XXXXX-XXXXX
        {
            if (!IsLicenseValid(licenseKey))
            {
                continue;
            }
            else
            {
                break;
            }
        }
        else
        {
            std::cout << "License key does not match the desired format XXXXX-XXXXX-XXXXX-XXXXX-XXXXX. Enter empty to exit.\n";
        }
    }
}
 
int main(int argc, char** argv)
{
    ReadAndSetOtxRuntimeLicense();
 
    std::string runtimeManagerType;
 
    while (true)
    {
        std::cout << "Select a RuntimeManager:" << std::endl << "\t1 or empty - Raw." << std::endl << "\t2 - Socket." << std::endl << "\t3 - Pipe." << std::endl;
        std::cout << "Enter a number: ";
        std::getline(std::cin, runtimeManagerType);
        if (runtimeManagerType == "" || runtimeManagerType == "1")
        {
            std::shared_ptr<IOtxDiag> otxDiag = nullptr;
            try
            {
                otxDiag = CreateRawOtxDiag();   // Create a Raw DiagManager instance
                if (!otxDiag)
                {
                    return EXIT_FAILURE;
                }
 
                runtimeManager = RuntimeManagerFactory::CreateRawRuntimeManager(otxDiag); // Create a Raw RuntimeManager with the Raw DiagManager instance above
                std::cout << "\tRawRuntimeManager is created." << std::endl;
                std::shared_ptr<IDiagConfiguration> diagConfiguration = otxDiag->GetDiagConfiguration();
                std::string projectName, vehicleInformationName;
                projectName = SelectProject(diagConfiguration); // Select an available ODX-Runtime-Project
                if (!projectName.empty())
                {
                    vehicleInformationName = SelectVehicleInformation(diagConfiguration); // Select an available vehicle information
                }
            }
            catch (const std::exception& ex)
            {
                std::cerr << ex.what() << std::endl;
                continue;
            }
 
            break;
        }
        else if (runtimeManagerType == "2")
        {
            int otxRunnerPort, diagManagerPort;
            while (true)
            {
                std::cout << "Enter OtxRunnerPort and DiagManagerPort, separated by space: ";
                std::string input;
                std::getline(std::cin, input);
                std::vector<std::string> tokens = SplitString(input, ' ');
                try
                {
                    otxRunnerPort = atoi(tokens.at(0).c_str());
                    diagManagerPort = atoi(tokens.at(1).c_str());
                    break;
                }
                catch (const std::exception& ex)
                {
                    std::cerr << ex.what() << std::endl;
                    continue;
                }
 
                std::cout << "Wrong numbers!" << std::endl;
            }
 
            try
            {
                // Create a RuntimeManager socket on otxRunnerPort, which then works with an active diagManager at the provided port.
                runtimeManager = RuntimeManagerFactory::CreateSocketRuntimeManager(otxRunnerPort, diagManagerPort);
            }
            catch (const std::exception& ex)
            {
                std::cerr << ex.what() << std::endl;
                continue;
            }
 
            std::cout << "\tSocketRuntimeManager(otxRunnerPort=" << otxRunnerPort << ", diagManagerPort=" << diagManagerPort << ") was created." << std::endl;
            break;
        }
        else if (runtimeManagerType == "3")
        {
            std::string otxRunnerPipeName, diagManagerPipeName;
            while (true)
            {
                std::cout << "Enter OtxRunnerPipeName and DiagManagerPipeName, separated by space: ";
                std::string input;
                std::getline(std::cin, input);
                std::vector<std::string> tokens = SplitString(input, ' ');
                try
                {
                    otxRunnerPipeName = tokens.at(0);
                    diagManagerPipeName = tokens.at(1);
                    break;
                }
                catch (const std::exception& ex)
                {
                    std::cerr << ex.what() << std::endl;
                    continue;
                }
 
                std::cout << "Wrong names!" << std::endl;
            }
 
            try
            {
                // Create a RuntimeManager pipe with given otxRunnerPipeName, which then works with an active diagManager via pipe at the provided pipe name.
                runtimeManager = RuntimeManagerFactory::CreatePipeRuntimeManager(otxRunnerPipeName, diagManagerPipeName);
            }
            catch (const std::exception& ex)
            {
                std::cerr << ex.what() << std::endl;
                continue;
            }
 
            std::cout << "\tPipeRuntimeManager(otxRunnerPipeName=\"" << otxRunnerPipeName << "\", diagManagerPipeName=\"" << diagManagerPipeName << "\") was created." << std::endl;
            break;
        }
 
        std::cout << "Wrong number!" << std::endl;
    }
 
    printf("\temotive OTX-Runtime API (Version %s - MinBin: %s)\n\n", RuntimeConfig::GetInstance().GetVersion().c_str(), RuntimeConfig::GetInstance().GetMinBinVersion().c_str());
 
    // Set the Custom implementations 
    runtimeManager->SetCustomImplementation(customScreenImplementation);
    runtimeManager->SetCustomImplementation(measureImplementation);
    runtimeManager->SetCustomImplementation(externalServiceProviderImplementation);
    stateVariableImplementation->SetStateVariableValueChangedHandler(std::make_shared<std::function<void(std::shared_ptr<IStateVariable>, std::shared_ptr<Object>)>>(StateVariableValueChanged));
    runtimeManager->SetCustomImplementation(stateVariableImplementation);
    contextVariableImplementation->SetContextVariableReadHandler(std::make_shared<std::function<void(std::shared_ptr<IContextVariable>, std::shared_ptr<Object>)>>(ContextVariableRead));
    runtimeManager->SetCustomImplementation(contextVariableImplementation);
 
    // Register the event handlers!!!
    std::shared_ptr<std::function<void(const IRuntimeContext&)>> procedureStartListener = std::make_shared<std::function<void(const IRuntimeContext&)>>(ProcedureStarted);
    std::shared_ptr<std::function<void(const IRuntimeContext&)>> procedureFinishedListener = std::make_shared<std::function<void(const IRuntimeContext&)>>(ProcedureFinished);
    std::shared_ptr<std::function<void(const IRuntimeContext&)>> procedureAbortedListener = std::make_shared<std::function<void(const IRuntimeContext&)>>(ProcedureAborted);
    std::shared_ptr<std::function<void(const IRuntimeContext&)>> procedureStoppedListener = std::make_shared<std::function<void(const IRuntimeContext&)>>(ProcedureStopped);
    std::shared_ptr<std::function<void(const IRuntimeContext&, const IProcedureInOutParameter&)>> parameterChangedListener = std::make_shared<std::function<void(const IRuntimeContext&, const IProcedureInOutParameter&)>>(InOutParameterValueChanged);
    std::shared_ptr<std::function<void(const IRuntimeContext&)>> procedureTimeoutListener = std::make_shared<std::function<void(const IRuntimeContext&)>>(ProcedureTimeout);
 
    runtimeManager->AddProcedureStartedListener(procedureStartListener);
    runtimeManager->AddProcedureFinishedListener(procedureFinishedListener);
    runtimeManager->AddProcedureTimeoutListener(procedureTimeoutListener);
    runtimeManager->AddProcedureAbortedListener(procedureAbortedListener);
    runtimeManager->AddProcedureStoppedListener(procedureStoppedListener);
    runtimeManager->AddInOutParameterValueChangedListener(parameterChangedListener);
 
    std::shared_ptr<Project::IProject> project = nullptr;
 
    while (true)
    {
        std::cout << "Enter PTX: ";
        std::string ptxFile;
        std::getline(std::cin, ptxFile);
        try
        {
            if (ptxFile.at(0) == '"' && ptxFile.at(ptxFile.size() - 1) == '"')
            {
                ptxFile = ptxFile.substr(1, ptxFile.size() - 2);
            }
 
            project = runtimeManager->LoadPtx(ptxFile); // Loads the given PTX file.
 
            break;
        }
        catch (std::exception& ex)
        {
            std::cerr << "\t" << ex.what() << std::endl;
        }
    }
 
    if (project)
    {
        std::vector<std::shared_ptr<Otx::IProcedure>> procedures = DisplayPtxTree(project); // Display the PTX content
 
        // Execute a procedure with diagnostics(not the main)
        SelectAndExecuteProcedure(runtimeManager, project, procedures);
    }
 
    SingletonManager::Get().DestroyAll(); // Destroy all singletons in the runtime API to ensure a clean shutdown without warnings.
#ifdef _WIN32
    system("pause");
#endif
    delete cp;
    return EXIT_SUCCESS;
}
 
std::vector < std::shared_ptr<Otx::IProcedure>> DisplayPtxPackageTree(std::vector < std::shared_ptr<Otx::IProcedure>> procedures, std::vector < std::shared_ptr<Otx::IPackage>> packages, std::string stringConcat = "")
{
    for (int i = 0; i < packages.size(); i++)
    {
        std::shared_ptr<Otx::IPackage> package = packages.at(i);
        std::cout << stringConcat << " |- " << package->GetName() << " (Package)" << std::endl;
 
        procedures = DisplayPtxPackageTree(procedures, package->GetPackages(), stringConcat + " |");
 
        for (int j = 0; j < package->GetDocuments().size(); j++)
        {
            std::shared_ptr<Otx::IDocument> document = package->GetDocuments().at(j);
            document->GetImports();
 
            std::cout << stringConcat << " | |- " << document->GetName() << " (Document)" << std::endl;
            for (int k = 0; k < document->GetProcedures().size(); k++)
            {
                std::shared_ptr<Otx::IProcedure> procedure = document->GetProcedures().at(k);
                procedures.push_back(procedure);
                std::cout << stringConcat << " | | |- " << procedure->GetName() << " (Procedure)" << " - code: " << procedures.size() << std::endl;
 
                for (int m = 0; m < procedure->GetParameters().size(); m++)
                {
                    std::shared_ptr<Otx::IProcedureParameter> param = procedure->GetParameters().at(m);
 
                    std::string name = param->GetName();
                    std::string dataType = param->GetDataType();
 
                    auto value = param->GetInitValue();
                    std::string valueStr = (value != nullptr ? value->ToLiteralString() : "null");
 
                    if (std::shared_ptr<Otx::IProcedureInParameter> inParameter = std::dynamic_pointer_cast<Otx::IProcedureInParameter>(param))
                    {
                        std::cout <<
                            stringConcat << " | | | |- " << name << " (" << dataType << "): " << valueStr << " (InParameter or InOutParameter)" << std::endl;
                    }
                    else
                    {
                        std::cout << stringConcat << " | | | |- " << name << " (" << dataType << "): " << valueStr << " (OutParameter)" << std::endl;
                    }
                }
            }
        }
    }
    return procedures;
}
 
std::vector < std::shared_ptr<Otx::IProcedure>> DisplayPtxTree(std::shared_ptr<Project::IProject> project)
{
    std::vector < std::shared_ptr<Otx::IProcedure>>  procedures;
    if (project != NULL)
    {
        std::cout << std::endl << "PTX tree: " << std::endl;
 
        std::cout << "- " << project->GetName() << " (Project)" << std::endl;
 
        procedures = DisplayPtxPackageTree(procedures, project->GetPackages());
    }
    return procedures;
}
 
void SelectAndExecuteProcedure(std::shared_ptr<IRuntimeManager> runtimeManager, std::shared_ptr<Project::IProject> project, std::vector<std::shared_ptr<Otx::IProcedure>> procedures)
{
 
ReEnterProcedure:
    std::string procedureFullName;
    std::cout << std::endl << "Enter Procedure (full name, code or 0 - if exit): ";
    std::getline(std::cin, procedureFullName);
 
    std::shared_ptr<Otx::IProcedure> procedure = nullptr;
    try
    {
        int idxProcedure = std::stoi(procedureFullName.c_str());
        if (idxProcedure < 0 || idxProcedure>procedures.size() + 1)
        {
            std::cout << std::endl << "The procedure code is invalid.";
            goto ReEnterProcedure;
        }
        else if (idxProcedure == 0 && procedureFullName.size() > 0)
        {
            return;
        }
        else
        {
            procedure = procedures.at(idxProcedure - 1); // Select the procedure to execute
        }
    }
    catch (const std::exception&)
    {
 
    }
 
    if (procedure != nullptr)
    {
        // Set value to procedure parameters
        for (int i = 0; i < procedure->GetParameters().size(); i++)
        {
            std::shared_ptr<Otx::IProcedureParameter> procedureParameter = procedure->GetParameters().at(i);
            if (std::shared_ptr<Otx::IProcedureInParameter> inParameter = std::dynamic_pointer_cast<Otx::IProcedureInParameter>(procedureParameter))
            {
                bool isValidValue = false;
                do
                {
                    try
                    {
                        isValidValue = true;
                        std::string value;
                        std::cout << "Enter value of " << procedureParameter->GetName() << " (" << procedureParameter->GetDataType() << "): ";
                        std::getline(std::cin, value);
                        if (value != "")
                        {
                            inParameter->SetValue(ValueConverter::String2Value(value, procedureParameter->GetDataType()));
                        }
                    }
                    catch (std::exception& ex)
                    {
                        isValidValue = false;
                        std::cerr << ex.what() << std::endl;
                    }
                } while (!isValidValue);
            }
            else if (std::shared_ptr<Otx::IProcedureInOutParameter> inOutParameter = std::dynamic_pointer_cast<Otx::IProcedureInOutParameter>(procedureParameter))
            {
                bool isValidValue = false;
                do
                {
                    try
                    {
                        isValidValue = true;
                        std::string value;
                        std::cout << "Enter value of " << procedureParameter->GetName() << " (" << procedureParameter->GetDataType() << "): ";
                        std::getline(std::cin, value);
                        if (value != "")
                        {
                            inOutParameter->SetValue(ValueConverter::String2Value(value, procedureParameter->GetDataType()));
                        }
                    }
                    catch (std::exception& ex)
                    {
                        isValidValue = false;
                        std::cerr << ex.what() << std::endl;
                    }
                } while (!isValidValue);
            }
        }
 
        isProcedureFinished = false;
        std::shared_ptr<IRuntimeContext> runtimeContext = runtimeManager->ExecuteAsync(procedure);  // Execute the selected procedure
 
        while (isProcedureFinished == false) // Poll and wait until the procedure finishes.
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
 
        if (runtimeContext->HasOtxException()) // Gets the uncatched otx exceptions from the procedure (ablauf) if any
        {
            std::cout << std::endl << "Otx exception occurred:" << "\t";
            std::cout << runtimeContext->GetOtxException().GetOtxType() << ":" << runtimeContext->GetOtxException().what() << std::endl;
        }
        else if (runtimeContext->HasRuntimeException()) // Gets the uncatched runtime exceptions in the execution if any
        {
            std::cout << std::endl << "Runtime exception occurred:" << "\t";
            std::cout << runtimeContext->GetRuntimeException().what() << std::endl;
        }
    }
    else
    {
        std::cout << "Procedure " << procedureFullName << " does not exist!" << std::endl;
    }
 
    goto ReEnterProcedure;
}
 
std::string SelectProject(std::shared_ptr<IDiagConfiguration> diagConfiguration)
{
    std::string projectSelected;
    int indexProjectSelect = 0;
 
    std::shared_ptr<IDiagConfiguration> diagConfig = diagConfiguration;
    if (diagConfig == NULL)
    {
        diagConfig = CreateRawOtxDiag()->GetDiagConfiguration();
    }
    std::vector<std::string> projectList = diagConfig->GetDbProjectList();  // Get all available ODX projects for selecting
 
    if (projectList.size() > 0)
    {
        std::cout << "Select a ODX-Runtime-Project" << std::endl;
        std::cout << "\t0 - None" << std::endl;
 
        for (size_t indexProjectItem = 0; indexProjectItem < projectList.size(); indexProjectItem++)
        {
            std::cout << "\t" << indexProjectItem + 1 << " - " << projectList.at(indexProjectItem) << std::endl;
        }
 
#ifdef _WIN32
        flushall();
#endif
        std::cout << "Enter a number: ";
        std::cin >> indexProjectSelect;
        std::cin.ignore();
        if (indexProjectSelect > 0 && indexProjectSelect - 1 < projectList.size())
        {
            projectSelected = projectList.at(indexProjectSelect - 1);
            diagConfig->SelectProject(projectSelected);
        }
    }
 
    return projectSelected;
}
 
std::string SelectVehicleInformation(std::shared_ptr<IDiagConfiguration> diagConfiguration)
{
    std::string vehicleSelected;
    int indexVehicleInformationSelect = 0;
 
    std::shared_ptr<IDiagConfiguration> _diagConfiguration = diagConfiguration;
    if (_diagConfiguration == NULL)
    {
        _diagConfiguration = CreateRawOtxDiag()->GetDiagConfiguration();
    }
    std::vector<std::string> vehicleInformationList = _diagConfiguration->GetDbVehicleInformationList();
 
    for (size_t indexVehicleInformationName = 0; indexVehicleInformationName < vehicleInformationList.size(); indexVehicleInformationName++)
    {
        std::cout << "\t" << indexVehicleInformationName + 1 << " - " << vehicleInformationList.at(indexVehicleInformationName) << std::endl;
    }
 
#ifdef _WIN32
    flushall();
#endif
    std::cout << "Input vehicle information code: ";
    std::cin >> indexVehicleInformationSelect;
    std::cin.ignore();
    if (indexVehicleInformationSelect > 0 && indexVehicleInformationSelect - 1 < vehicleInformationList.size())
    {
        vehicleSelected = vehicleInformationList.at(indexVehicleInformationSelect - 1);
        _diagConfiguration->SelectVehicleInformation(vehicleSelected);
    }
    return vehicleSelected;
}
 
std::shared_ptr<IOtxDiag> CreateRawOtxDiag()
{
    OpenTestSystem::Otx::DiagManager::OtxDiagApi::OtxDiagFactory factory;
 
    if (cp == nullptr)
    {
        cp = new CommandProcessor;
    }
 
    bool useVwmcdSP = false;
#ifdef USE_VWMCDSP
    useVwmcdSP = true;
#endif
    OpenTestSystem::Otx::DiagManager::Client::ClientFactory clientFactory;
    std::shared_ptr<OpenTestSystem::Otx::DiagManager::Client::Client> rawClient = clientFactory.CreateRawClient(cp);
    Util::SetLicenseKey(rawClient, licenseKey); // use the license key of otx runtime also for diagmanager
    const char* kernelPath = getenv("VW_MCD_HOME");
    if (!kernelPath)
    {
        std::cout << "\tCannot read ENVIRONMENT VARIABLE 'VW_MCD_HOME'" << std::endl;
        return nullptr;
    }
 
    const char* configPath = getenv("VW_MCD_CONFIG");
    if (!configPath)
    {
        std::cout << "\tCannot read ENVIRONMENT VARIABLE 'VW_MCD_CONFIG'" << std::endl;
        return nullptr;
    }
 
    std::cout << "\tVW_MCD_HOME = " << kernelPath << std::endl;
    std::cout << "\tVW_MCD_CONFIG = " << configPath << std::endl;
    IDiagRuntimeSystem* drs = CreateDiagRuntimeSystem("", "", kernelPath, useVwmcdSP);
    if (drs == nullptr)
    {
        std::cout << "\tInitDiagRuntimeSystem failed!" << std::endl;
        return nullptr;
    }
    cp->SetRuntimeSystem(drs);
    return factory.CreateRawOtxDiag(cp);
}
#ifdef _WIN32
std::string GetLastErrorAsString()
{
    //Get the error message ID, if any.
    DWORD errorMessageID = ::GetLastError();
    if (errorMessageID == 0) {
        return std::string(); //No error message has been recorded
    }
 
    LPSTR messageBuffer = nullptr;
 
    //Ask Win32 to give us the string version of that message ID.
    //The parameters we pass in, tell Win32 to create the buffer that holds the message for us (because we don't yet know how long the message string will be).
    size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL, errorMessageID, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&messageBuffer, 0, NULL);
 
    //Copy the error message into a std::string.
    std::string message(messageBuffer, size);
 
    //Free the Win32's string's buffer.
    LocalFree(messageBuffer);
 
    return message;
}
#endif
 
IDiagRuntimeSystem* CreateDiagRuntimeSystem(const char* projectName, const char* vehicleInfo, const char* kernelPath, bool useVwmcdSP)
{
#ifdef _WIN32
    typedef IDiagRuntimeSystem* (__cdecl* typeCreateDiagRuntimeSystem)(const char* projectName, const char* vehicleInfo);
    DiagRuntimeSystemDLL = NULL;
 
    // represents vwmcd version 17.50.x.x
    std::string DiagRuntimeSystem_17_50_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.VwMcd_VC142.dll";
    // represents vwmcdsp version 17.50.0.x.x
    std::string DiagRuntimeSystemSP_17_50_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.VwMcdSP_VC142.dll";
    // represents vwmcd version 9.00.x.x to 14.00.x.x
    std::string DiagRuntimeSystem_09_00_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.dll";
    // represents vwmcdsp version 9.00.x.x to 14.00.x.x
    std::string DiagRuntimeSystemSP_09_00_FileName = "OpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.VwMcd90SP.dll";
 
    // Default use mcd version 17.50.x.x
    std::string DiagRuntimeSystemFileName = DiagRuntimeSystem_17_50_FileName;
    std::string kernelTypeStr = "VwMcd1750";
 
    if (useVwmcdSP)
    {
        kernelTypeStr = "VwMcd1750SP";
        DiagRuntimeSystemFileName = DiagRuntimeSystemSP_17_50_FileName;
    }
 
    if (fs::exists(std::string(kernelPath) + "/McdKernel_vc120.dll")) // check vwmcd 90
    {
        if (useVwmcdSP)
        {
            kernelTypeStr = "VwMcd90SP";
            DiagRuntimeSystemFileName = DiagRuntimeSystemSP_09_00_FileName;
        }
        else
        {
            kernelTypeStr = "VwMcd90";
            DiagRuntimeSystemFileName = DiagRuntimeSystem_09_00_FileName;
        }
    }
 
    std::cout << "\tKernel Type is " << kernelTypeStr << std::endl;
 
    DiagRuntimeSystemDLL = ::LoadLibrary(DiagRuntimeSystemFileName.c_str());
    if (DiagRuntimeSystemDLL == NULL)
    {
        std::string errorMessage = GetLastErrorAsString();
        std::cout << errorMessage << std::endl;
        throw std::exception(errorMessage.c_str());
    }
 
    typedef IDiagRuntimeSystem* (__cdecl* typeCreateDiagRuntimeSystem)(const char* projectName, const char* vehicleInfo);
    typeCreateDiagRuntimeSystem createFunction = reinterpret_cast<typeCreateDiagRuntimeSystem>(::GetProcAddress(DiagRuntimeSystemDLL, "CreateDiagRuntimeSystem"));
 
    if (createFunction == nullptr)
        return nullptr;
 
    return createFunction(projectName, vehicleInfo);
#elif defined(__linux__) || defined(__QNXNTO__)
#ifdef  USE_VWMCD_LINK_LIBRARY
    return new VwMcdDiagRuntimeSystem(projectName, vehicleInfo);
#else
    if (!handle && useVwmcdSP == false)
    {
        std::cout << "Kernel Type is VwMcd" << std::endl;
        handle = dlopen("libOpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.VwMcd.so", RTLD_NOW);
    }
    else if (!handle && useVwmcdSP == true)
    {
        std::cout << "Kernel Type is VwMcdSP" << std::endl;
        handle = dlopen("libOpenTestSystem.Otx.DiagManager.DiagRuntimeSystem.VwMcdSP.so", RTLD_NOW);
    }
 
    if (!handle) {
        /* fail to load the library */
        std::cout << dlerror() << std::endl;
        return nullptr;
    }
    typedef IDiagRuntimeSystem* typeCreateDiagRuntimeSystem(const char* projectName, const char* vehicleInfo);
    typeCreateDiagRuntimeSystem* createFunction = reinterpret_cast<typeCreateDiagRuntimeSystem*>(dlsym(handle, "CreateDiagRuntimeSystem"));
 
    if (!createFunction)
    {
        dlclose(handle);
        return nullptr;
    }
    IDiagRuntimeSystem* digRuntimeSystem = createFunction(projectName, vehicleInfo);
    dlclose(handle);
    createFunction = NULL;
    return digRuntimeSystem;
#endif
#else
    return nullptr;
#endif
}

Example CMake-File

Code example (.\otxruntime\Sample.Console\CMakeLists.txt) of the OTX-Runtime API Sample Program.

# Set the project name
project (OpenTestSystem.Otx.Runtime2.Api.ReferenceApplication.Cpp)
set(UseCompiledApi OFF)
 
###############################################################################
# Source files
file(GLOB_RECURSE headers "${PROJECT_SOURCE_DIR}/include/*.h")
file(GLOB_RECURSE srcs    "${PROJECT_SOURCE_DIR}/src/*.h" "${PROJECT_SOURCE_DIR}/src/*.cpp" "${PROJECT_SOURCE_DIR}/src/*.resx")
set(versionInfo ${PROJECT_SOURCE_DIR}/version/version.rc ${PROJECT_SOURCE_DIR}/version/version.h)
 
source_group(
    TREE ${PROJECT_SOURCE_DIR}/include
    PREFIX "Include Files"
    FILES ${headers}
)
source_group(
    TREE ${PROJECT_SOURCE_DIR}/src
    PREFIX "Source Files"
    FILES ${srcs}
)
#
 
###############################################################################
# Create the library with the provided sources and headers
add_executable(${PROJECT_NAME} ${headers} ${srcs} ${versionInfo} main.cpp)
 
###############################################################################
# DotNet libraries
SET(DOTNET_REFERENCES 
    System
    System.Core
    System.Data
    System.Drawing
    System.Windows.Forms
)
LIST(JOIN DOTNET_REFERENCES ";" DOTNET_REFERENCES)
 
# Setup CLI
set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER                             "sample")
set_target_properties(${PROJECT_NAME} PROPERTIES COMMON_LANGUAGE_RUNTIME            "")
set_target_properties(${PROJECT_NAME} PROPERTIES VS_GLOBAL_CLRSupport               "true")
set_target_properties(${PROJECT_NAME} PROPERTIES VS_DOTNET_TARGET_FRAMEWORK_VERSION "v4.6.1")
set_target_properties(${PROJECT_NAME} PROPERTIES VS_DOTNET_REFERENCES               "${DOTNET_REFERENCES}")
set_target_properties(${PROJECT_NAME} PROPERTIES VS_DOTNET_REFERENCES_COPY_LOCAL    OFF)
set_target_properties(${PROJECT_NAME} PROPERTIES VS_GLOBAL_ROOTNAMESPACE            "OpenTestSystem.Otx.Runtime2.Api.Sample")
set_target_properties(${PROJECT_NAME} PROPERTIES LINK_FLAGS                         "/SUBSYSTEM:WINDOWS /ENTRY:main /KEYFILE:${PROJECT_SOURCE_DIR}/key.snk")
set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD                       14)
set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD_REQUIRED              YES)
set_target_properties(${PROJECT_NAME} PROPERTIES CXX_EXTENSIONS                     NO)
 
include_directories(
    PUBLIC ${PROJECT_SOURCE_DIR}/include
    PUBLIC ${PROJECT_SOURCE_DIR}/src
    ${CMAKE_SOURCE_DIR}/lib/rapidjson-1.1.0/include
)
 
if (UseCompiledApi)
    target_include_directories(${PROJECT_NAME}
        PRIVATE ${Rt7InstallDir}include/OpenTestSystem.Otx.Runtime2.Api
        PRIVATE ${Rt7InstallDir}include/CustomImplementations
    )
 
    target_link_libraries(${PROJECT_NAME} ${Rt7InstallDir}lib/OpenTestSystem.Otx.Runtime2.Api.Custom.Default.lib)
    target_link_libraries(${PROJECT_NAME} ${Rt7InstallDir}lib/OpenTestSystem.Otx.Runtime2.Api.lib)
else()
    # Set include paths
    target_link_libraries(${PROJECT_NAME} OpenTestSystem.Otx.Runtime2.Api)
    target_link_libraries(${PROJECT_NAME} OpenTestSystem.Otx.Runtime2.Api.Custom.Default)
endif()
 
target_link_libraries(${PROJECT_NAME}
    ${DiagRuntimeSystemLib}
    OtxDiagManager::CommandProcessor
    OtxDiagManager::SystemApi
    OtxDiagManager::OtxDiagApi
    OtxDiagManager::NoneOtxDiagApi
    OtxDiagManager::Common
)
 
IF (USE_VWMCDSP)
    target_compile_definitions(${PROJECT_NAME} PRIVATE USE_VWMCDSP)
ENDIF(USE_VWMCDSP)
 
if (UNIX)
    if (USE_VWMCD_LINK_LIBRARY)
        target_compile_definitions(${PROJECT_NAME} PRIVATE USE_VWMCD_LINK_LIBRARY)
        target_link_libraries(${PROJECT_NAME} ${DiagRuntimeSystemLib})
    elseif(ADD_DL_LIBS)
        target_link_libraries(${PROJECT_NAME} ${CMAKE_DL_LIBS})
    endif(USE_VWMCD_LINK_LIBRARY)
endif(UNIX)
 
# RT 7 installation: copy to the desired directory
add_custom_command(
    TARGET ${PROJECT_NAME} POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy
        "$<TARGET_FILE_DIR:${PROJECT_NAME}>/${PROJECT_NAME}${CMAKE_EXECUTABLE_SUFFIX}"
        "${Rt7InstallDir}bin/${PROJECT_NAME}${CMAKE_EXECUTABLE_SUFFIX}"
)
 
# TODO: may be copy OtxDiagManager BINs