cangenplugin.h

/*
Copyright (C) 2012 Intel Corporation

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef _CANGENPLUGINIMPL_H_
#define _CANGENPLUGINIMPL_H_

#include <map>
#include <memory>
#include <tgmath.h>
#include <libwebsockets.h>
#include <json.h>

#include <canbus.h>
#include <canobserver.h>

#include <ambpluginimpl.h>
#include "websockets.h"

static const char* CANSimPluginUUID = "3f43e231-11ec-4782-9b5a-3dbcc5221eeb";

class CANGenPlugin: public AmbPluginImpl, public CANObserver, public WebSocketsObserver {

public:

    CANGenPlugin(AbstractRoutingEngine* re, const std::map<std::string, std::string>& config, AbstractSource &parent);
    virtual ~CANGenPlugin(); // has to be virtual because of unit tests

    // from AbstractSink
public:

    const std::string uuid() const { return "becbbef9-6cc8-4b9e-8cd7-2fbe37b9b52a"; }

    void propertyChanged(AbstractPropertyType* value);

    AsyncPropertyReply* setProperty(const AsyncSetPropertyRequest &request);

    // from CANObserver
public:
    virtual void errorOccured(CANObserver::CANError error);/* socket error */
    virtual void standardFrameReceived(const can_frame& frame);/* SFF was present */
    virtual void extendedFrameReceived(const can_frame& frame);/* EFF was present */
    virtual void errorFrameReceived(const can_frame& frame);/* error frame */
    virtual void remoteTransmissionRequest(const can_frame& frame);/* remote transmission request (SFF/EFF is still present)*/
    virtual void timeoutDetected(const can_frame& frame);

    virtual void init();

    // from WebSocketsObserver

    void dataReceived(lws* socket, const char* data, size_t len);

//
// Internal methods:
//
private:

    void printFrame(const can_frame& frame) const;

    void parseMappingTable(const std::string& json);

    void getValue(lws* socket, const std::string& property, int zone, const std::string& uuid);

    void setValue(lws* socket, const std::string& property, const std::string& value, int zone, const std::string& interface, const std::string& transactionId);

    bool sendValue(const std::string& interface, AbstractPropertyType* value);

    class MappingTable{
    public:
        MappingTable()
        {
        }

        MappingTable(const MappingTable& other) = delete;
        MappingTable& operator=(const MappingTable& other) = delete;
        MappingTable(MappingTable&& other) = default;
        MappingTable& operator=(MappingTable&& other) = default;

        void addProperty(const std::string& source, json_object* signal)
        {
            json_object* canIdObj = json_object_object_get(signal, "can_id");
            json_object* nameObj = json_object_object_get(signal, "name");
            if(!canIdObj || !nameObj) // mandatory
                return;
            Zone::Type zone(Zone::None);
            json_object* zoneObj = json_object_object_get(signal, "zone");
            if(zoneObj)
                zone = json_object_get_int(zoneObj);

            auto& zp = mapping[source];
            auto& prop = zp[Zone::Type(zone)];
            std::string name(json_object_get_string(nameObj));
            int can_id = json_object_get_int(canIdObj);
            prop[name] = can_id; // update an existing value
        }

        int getCanId(const std::string& source, const Zone::Type& zone, const VehicleProperty::Property& name) const
        {
            //return mapping[source][zone][name]; // caution! this will insert if not found. I don't want it.
            auto sourceIt = mapping.find(source);
            if(sourceIt == mapping.end())
                return 0;
            auto zoneIt = sourceIt->second.find(zone);
            if(zoneIt == sourceIt->second.end())
                return 0;
            auto propIt = zoneIt->second.find(name);
            if(propIt == zoneIt->second.end())
                return 0;
            else
                return propIt->second;
        }

        void clear()
        {
            mapping.clear();
        }

    private:
        typedef std::map< Zone::Type, std::map<VehicleProperty::Property, canid_t> > ZonedProperty;
        std::map<std::string, ZonedProperty> mapping;
    };

//
// data:
//

    MappingTable mappingTable;

    std::map<std::string, std::shared_ptr<CANBus> > interfaces;

    std::unique_ptr<WebSockets> ws;

    interprocess_recursive_mutex mutex;
};

class SimCommand: public StringPropertyType
{
public:
    SimCommand(): StringPropertyType("SimCommand") { }
    SimCommand(std::string val) : StringPropertyType("SimCommand",val) { }
};

#endif // _CANGENPLUGINIMPL_H_