DeviceInterface.h

Go to the documentation of this file.

// Copyright 2014 Sensics, Inc.
//
// 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.

#ifndef INCLUDED_DeviceInterface_h_GUID_A929799C_02F5_4C92_C503_36C7F59D6BA1
#define INCLUDED_DeviceInterface_h_GUID_A929799C_02F5_4C92_C503_36C7F59D6BA1

// Internal Includes
#include <osvr/PluginKit/DeviceInterfaceC.h>
#include <osvr/Util/TimeValue.h>

// Library/third-party includes
// - none

// Standard includes
#include <stdexcept>
#include <vector>
#include <string>

namespace osvr {
namespace pluginkit {

    inline OSVR_MessageType
    registerMessageType(OSVR_IN_PTR OSVR_PluginRegContext ctx,
                        OSVR_IN_STRZ const char *name) {
        OSVR_MessageType msg;
        OSVR_ReturnCode ret = osvrDeviceRegisterMessageType(ctx, name, &msg);
        if (OSVR_RETURN_SUCCESS != ret) {
            throw std::runtime_error("Could not register message type: " +
                                     std::string(name));
        }
        return msg;
    }

    inline OSVR_MessageType
    registerMessageType(OSVR_IN_PTR OSVR_PluginRegContext ctx,
                        OSVR_IN std::string const &name) {
        if (name.empty()) {
            throw std::runtime_error(
                "Cannot register a message type with an empty name!");
        }
        return registerMessageType(ctx, name.c_str());
    }

#ifndef OSVR_DOXYGEN_EXTERNAL
    namespace detail {
        template <typename DeviceObjectType> struct UpdateTrampoline {
            static OSVR_ReturnCode update(void *userData) {
                return static_cast<DeviceObjectType *>(userData)->update();
            }
        };
    } // namespace detail
#endif

    class DeviceToken {
      public:
        DeviceToken(OSVR_DeviceToken device) : m_dev(device) {}

        DeviceToken() : m_dev(NULL) {}

        operator OSVR_DeviceToken() const {
            m_validateToken();
            return m_dev;
        }

        void initSync(OSVR_IN_PTR OSVR_PluginRegContext ctx,
                      OSVR_IN_STRZ const char *name,
                      OSVR_IN_OPT OSVR_DeviceInitOptions options = NULL) {
            OSVR_ReturnCode ret;
            if (options) {
                ret = osvrDeviceSyncInitWithOptions(ctx, name, options, &m_dev);
            } else {
                ret = osvrDeviceSyncInit(ctx, name, &m_dev);
            }
            if (OSVR_RETURN_SUCCESS != ret) {
                throw std::runtime_error("Could not initialize device token: " +
                                         std::string(name));
            }
        }

        void initSync(OSVR_IN_PTR OSVR_PluginRegContext ctx,
                      OSVR_IN std::string const &name,
                      OSVR_IN_OPT OSVR_DeviceInitOptions options = NULL) {
            if (name.empty()) {
                throw std::runtime_error("Could not initialize device token "
                                         "with an empty name field!");
            }
            initSync(ctx, name.c_str(), options);
        }

        void initAsync(OSVR_IN_PTR OSVR_PluginRegContext ctx,
                       OSVR_IN_STRZ const char *name,
                       OSVR_IN_OPT OSVR_DeviceInitOptions options = NULL) {
            OSVR_ReturnCode ret;
            if (options) {
                ret =
                    osvrDeviceAsyncInitWithOptions(ctx, name, options, &m_dev);
            } else {
                ret = osvrDeviceAsyncInit(ctx, name, &m_dev);
            }
            if (OSVR_RETURN_SUCCESS != ret) {
                throw std::runtime_error("Could not initialize device token: " +
                                         std::string(name));
            }
        }

        void initAsync(OSVR_IN_PTR OSVR_PluginRegContext ctx,
                       OSVR_IN std::string const &name,
                       OSVR_IN_OPT OSVR_DeviceInitOptions options = NULL) {
            if (name.empty()) {
                throw std::runtime_error("Could not initialize device token "
                                         "with an empty name field!");
            }
            initAsync(ctx, name.c_str(), options);
        }

        template <typename InterfaceType, typename MessageType>
        void send(InterfaceType &iface, MessageType const &msg,
                  OSVR_TimeValue const &timestamp) {
            iface.send(*this, msg, timestamp);
        }

        template <typename InterfaceType, typename MessageType>
        void send(InterfaceType &iface, MessageType const &msg) {
            send(iface, msg, util::time::getNow());
        }

        void sendJsonDescriptor(OSVR_IN_READS(len) const char *json,
            OSVR_IN size_t len) {
            m_validateToken();
            OSVR_ReturnCode ret =
                osvrDeviceSendJsonDescriptor(m_dev, json, len);
            if (OSVR_RETURN_SUCCESS != ret) {
                throw std::runtime_error("Could not send JSON descriptor!");
            }
        }

        template <size_t N> void sendJsonDescriptor(const char(&json)[N]) {
            sendJsonDescriptor(json, N);
        }

        void sendJsonDescriptor(OSVR_IN std::string const &json) {
            if (json.empty()) {
                throw std::runtime_error(
                    "Cannot send an empty JSON descriptor!");
            }
            sendJsonDescriptor(json.c_str(), json.length());
        }

        template <typename DeviceObjectType>
        void registerUpdateCallback(OSVR_IN_PTR DeviceObjectType *object) {
            if (!object) {
                throw std::logic_error(
                    "Cannot register update callback for a null object!");
            }
            m_validateToken();
            OSVR_ReturnCode ret = osvrDeviceRegisterUpdateCallback(
                m_dev, &detail::UpdateTrampoline<DeviceObjectType>::update,
                static_cast<void *>(object));
            if (OSVR_RETURN_SUCCESS != ret) {
                throw std::runtime_error("Could not register update callback!");
            }
        }

        void sendData(OSVR_IN_PTR OSVR_MessageType msg,
                      OSVR_IN_READS(len) const char *bytestream = NULL,
                      OSVR_IN size_t len = 0) {
            m_validateToken();
            OSVR_ReturnCode ret =
                osvrDeviceSendData(m_dev, msg, bytestream, len);
            if (OSVR_RETURN_SUCCESS != ret) {
                throw std::runtime_error("Could not send data!");
            }
        }

        template <size_t N>
        void sendData(OSVR_MessageType msg, const char(&bytestream)[N]) {
            sendData(msg, bytestream, N);
        }

        void sendData(OSVR_IN_PTR OSVR_MessageType msg,
                      OSVR_IN std::string const &bytestream) {
            if (bytestream.empty()) {
                sendData(msg);
            } else {
                sendData(msg, bytestream.data(), bytestream.length());
            }
        }

        void sendData(OSVR_IN_PTR OSVR_MessageType msg,
                      OSVR_IN std::vector<char> const &bytestream) {
            if (bytestream.empty()) {
                sendData(msg);
            } else {
                sendData(msg, bytestream.data(), bytestream.size());
            }
        }

        void sendData(OSVR_IN OSVR_TimeValue const &timestamp,
                      OSVR_IN_PTR OSVR_MessageType msg,
                      OSVR_IN_READS(len) const char *bytestream = NULL,
                      OSVR_IN size_t len = 0) {
            OSVR_ReturnCode ret = osvrDeviceSendTimestampedData(
                m_dev, &timestamp, msg, bytestream, len);
            if (OSVR_RETURN_SUCCESS != ret) {
                throw std::runtime_error("Could not send data!");
            }
        }

        template <size_t N>
        void sendData(OSVR_IN OSVR_TimeValue const &timestamp,
                      OSVR_MessageType msg, const char(&bytestream)[N]) {
            sendData(timestamp, msg, bytestream, N);
        }

        void sendData(OSVR_IN OSVR_TimeValue const &timestamp,
                      OSVR_IN_PTR OSVR_MessageType msg,
                      OSVR_IN std::string const &bytestream) {
            if (bytestream.empty()) {
                sendData(timestamp, msg);
            } else {
                sendData(timestamp, msg, bytestream.data(),
                         bytestream.length());
            }
        }

        void sendData(OSVR_IN OSVR_TimeValue const &timestamp,
                      OSVR_IN_PTR OSVR_MessageType msg,
                      OSVR_IN std::vector<char> const &bytestream) {
            if (bytestream.empty()) {
                sendData(timestamp, msg);
            } else {
                sendData(timestamp, msg, bytestream.data(), bytestream.size());
            }
        }

      private:
        void m_validateToken() const {
            if (!m_dev) {
                throw std::logic_error("Attempting an operation on a device "
                                       "token that is not yet initialized!");
            }
        }
        OSVR_DeviceToken m_dev;
    };

} // namespace pluginkit
} // namespace osvr

#endif // INCLUDED_DeviceInterface_h_GUID_A929799C_02F5_4C92_C503_36C7F59D6BA1