ozw.hpp

/*
 * Author: Jon Trulson <jtrulson@ics.com>
 * Copyright (c) 2015-2016 Intel Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#pragma once

#include <string>
#include <map>

#include "Manager.h"
#include "Notification.h"
#include "Options.h"
#include "Driver.h"
#include "Node.h"
#include "Group.h"
#include "platform/Log.h"

namespace upm {
  
  // forward declaration of private zwNode data
  class zwNode;

  class OZW {
  public:

    typedef std::map<uint8_t, zwNode *> zwNodeMap_t;

    static OZW* instance();

    void optionsCreate(std::string configPath="/etc/openzwave", 
                       std::string userConfigDir="",
                       std::string cmdLine="");
    
    void optionAddInt(std::string name, int val);

    void optionAddBool(std::string name, bool val);

    void optionAddString(std::string name, std::string val, bool append);

    void optionsLock();

    bool init(std::string devicePath, bool isHID=false);

    void dumpNodes(bool all=false);

    std::string getValueUnits(int nodeId, int index);

    void setValueUnits(int nodeId, int index, std::string text);

    std::string getValueLabel(int nodeId, int index);

    void setValueLabel(int nodeId, int index, std::string text);

    std::string getValueHelp(int nodeId, int index);

    void setValueHelp(int nodeId, int index, std::string text);

    void setValueAsString(int nodeId, int index, std::string val);

    void setValueAsBool(int nodeId, int index, bool val);

    void setValueAsByte(int nodeId, int index, uint8_t val);

    void setValueAsFloat(int nodeId, int index, float val);

    void setValueAsInt32(int nodeId, int index, int32_t val);

    void setValueAsInt16(int nodeId, int index, int16_t val);

    void setValueAsBytes(int nodeId, int index, uint8_t *val, uint8_t len);

    int getValueMin(int nodeId, int index);

    int getValueMax(int nodeId, int index);

    bool isValueReadOnly(int nodeId, int index);

    bool isValueWriteOnly(int nodeId, int index);

    bool isValueSet(int nodeId, int index);

    bool isValuePolled(int nodeId, int index);

    std::string getValueAsString(int nodeId, int index);

    bool getValueAsBool(int nodeId, int index);

    uint8_t getValueAsByte(int nodeId, int index);

    float getValueAsFloat(int nodeId, int index);

    int getValueAsInt32(int nodeId, int index);

    int getValueAsInt16(int nodeId, int index);

    void refreshValue(int nodeId, int index);

    void setDebug(bool enable);

    bool isNodeListeningDevice(int nodeId);

    bool isNodeFrequentListeningDevice(int nodeId);

    bool isNodeAwake(int nodeId);

    bool isNodeInfoReceived(int nodeId);

    bool isInitialized()
    {
      return m_initialized;
    }

  protected:
    OZW();

    ~OZW();

    bool getValueID(int nodeId, int index, OpenZWave::ValueID *vid);

    uint32_t getHomeID()
    {
      return m_homeId;
    }

    void lockNodes() { pthread_mutex_lock(&m_nodeLock); };

    void unlockNodes() { pthread_mutex_unlock(&m_nodeLock); };

  private:
    // prevent copying and assignment
    OZW(OZW const &) = delete;
    OZW& operator=(OZW const&) = delete;

    // our class instance
    static OZW* m_instance;

    uint32_t m_homeId;
    bool m_mgrCreated;
    bool m_driverFailed;
    bool m_debugging;
    bool m_initialized;

    bool m_driverIsHID;
    std::string m_devicePath;

    // our notification handler, called by OpenZWave for events on the
    // network.
    static void notificationHandler(OpenZWave::Notification 
                                    const* notification, 
                                    void *ctx);

    // a map of added nodes
    zwNodeMap_t m_zwNodeMap;

    // for coordinating access to the node list
    pthread_mutex_t m_nodeLock;

    // We use these to determine init failure or success (if OpenZWave
    // has successfully queried essential data about the network).
    pthread_mutex_t m_initLock;
    pthread_cond_t m_initCond;
  };
}