Added PluginKit API for plugins to trigger hardware detection.

examples/plugin/CMakeLists.txt

@@ -6,7 +6,8 @@ set(OSVR_EXAMPLE_DEVICE_PLUGINS_SIMPLE
     com_osvr_example_EyeTracker
     com_osvr_example_Locomotion
     com_osvr_example_MultipleAsync
-    org_osvr_example_Tracker)
+    org_osvr_example_Tracker
+    org_osvr_example_TriggerHardwareDetect)
 
 # These are all the plugin targets: one listed only here need more careful configuration.
 set(OSVR_EXAMPLE_DEVICE_PLUGINS
@@ -40,6 +41,7 @@ foreach(pluginname
     com_osvr_example_Configured
     com_osvr_example_EyeTracker
     com_osvr_example_Locomotion
+    org_osvr_example_TriggerHardwareDetect
     org_osvr_example_Tracker
     com_osvr_example_MultipleAsync)
     target_link_libraries(${pluginname} osvr_cxx11_flags)

examples/plugin/org_osvr_example_TriggerHardwareDetect.cpp

@@ -0,0 +1,109 @@
+/** @date 2016
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+// Copyright 2016 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.
+
+// Internal Includes
+#include <osvr/PluginKit/PluginKit.h>
+#include <osvr/PluginKit/ButtonInterfaceC.h>
+
+// Library/third-party includes
+
+// Standard includes
+#include <iostream>
+#include <chrono>
+#include <thread>
+#include <mutex>
+
+
+// Anonymous namespace to avoid symbol collision
+namespace {
+
+/**
+ * @brief This fake device just triggers an autodetect every few seconds.
+ */
+class FakeDevice {
+  public:
+    FakeDevice(OSVR_PluginRegContext ctx) : m_context(ctx) {
+        /// Create the initialization options
+        OSVR_DeviceInitOptions opts = osvrDeviceCreateInitOptions(ctx);
+
+        // configure our tracker
+        osvrDeviceButtonConfigure(opts, &m_button, 1);
+
+        /// Create the device token with the options
+        m_dev.initAsync(ctx, "Hardware detection trigger", opts);
+
+        /// Send JSON descriptor
+        //m_dev.sendJsonDescriptor("{}");
+
+        /// Register update callback
+        m_dev.registerUpdateCallback(this);
+    }
+
+    OSVR_ReturnCode update() {
+        std::this_thread::sleep_for(std::chrono::seconds(3));
+
+        osvr::pluginkit::triggerHardwareDetect(m_context);
+
+        return OSVR_RETURN_SUCCESS;
+    }
+
+  private:
+    OSVR_PluginRegContext m_context;
+    osvr::pluginkit::DeviceToken m_dev;
+    OSVR_ButtonDeviceInterface m_button;
+};
+
+class HardwareDetection {
+  public:
+    HardwareDetection() : m_found(false), m_count(0), m_mutex() {}
+
+    OSVR_ReturnCode operator()(OSVR_PluginRegContext ctx) {
+        std::lock_guard<std::mutex> guard(m_mutex);
+
+        m_count++;
+        std::cout << "[org_osvr_example_TriggerHardwareDetect] Hardware detection triggered " << m_count << " times." << std::endl;
+
+        if (m_found)
+            return OSVR_RETURN_SUCCESS;
+
+        osvr::pluginkit::registerObjectForDeletion(ctx, new FakeDevice(ctx));
+        m_found = true;
+
+        return OSVR_RETURN_SUCCESS;
+    }
+
+  private:
+    bool m_found;
+    int m_count;
+    std::mutex m_mutex;
+};
+
+} // namespace
+
+OSVR_PLUGIN(org_osvr_example_TriggerHardwareDetect) {
+
+    osvr::pluginkit::PluginContext context(ctx);
+
+    /// Register a detection callback function object.
+    context.registerHardwareDetectCallback(new HardwareDetection());
+
+    return OSVR_RETURN_SUCCESS;
+}
+

inc/osvr/PluginHost/PluginSpecificRegistrationContext.h

@@ -130,6 +130,9 @@ namespace pluginhost {
         /// @brief Accessor for plugin name.
         OSVR_PLUGINHOST_EXPORT const std::string &getName() const;
 
+        /// @brief Trigger system-wide hardware detection.
+        OSVR_PLUGINHOST_EXPORT virtual void triggerHardwareDetect() = 0;
+
       protected:
         /// @brief Constructor for derived class use only
         PluginSpecificRegistrationContext(std::string const &name);

inc/osvr/PluginKit/PluginKit.h

@@ -93,6 +93,12 @@ namespace pluginkit {
             return ::osvr::pluginkit::registerObjectForDeletion(m_ctx, obj);
         }
 
+        /// @brief Triggers system-wide hardware detection.
+        /// @sa ::osvr::pluginkit::triggerHardwareDetect.
+        void triggerHardwareDetect() {
+            ::osvr::pluginkit::triggerHardwareDetect(m_ctx);
+        }
+
       private:
         OSVR_PluginRegContext m_ctx;
     };

inc/osvr/PluginKit/PluginRegistration.h

@@ -197,6 +197,18 @@ namespace pluginkit {
                 "registerDriverInstantiationCallback failed!");
         }
     }
+
+    /// @brief Triggers system-wide hardware detection.
+    ///
+    /// @param ctx The registration context passed to your entry point.
+    ///
+    /// @sa PluginContext::triggerHardwareDetect
+    inline void triggerHardwareDetect(OSVR_PluginRegContext ctx) {
+        OSVR_ReturnCode ret = osvrPluginTriggerHardwareDetect(ctx);
+        if (ret != OSVR_RETURN_SUCCESS) {
+            throw std::runtime_error("triggerHardwareDetect failed!");
+        }
+    }
     /// @}
 } // namespace pluginkit
 } // namespace osvr

inc/osvr/PluginKit/PluginRegistrationC.h

@@ -143,8 +143,19 @@ OSVR_PLUGINKIT_EXPORT OSVR_ReturnCode osvrPluginRegisterDataWithDeleteCallback(
     OSVR_INOUT_PTR void *pluginData) OSVR_FUNC_NONNULL((1, 2, 3));
 /** @} */
 
+/** @brief Trigger system-wide hardware detection.
+
+   This causes each plugin's hardware detection callback to be called prior to
+   the next run of the server main loop.
+
+   @param ctx The registration context passed to your entry point.
+*/
+OSVR_PLUGINKIT_EXPORT OSVR_ReturnCode osvrPluginTriggerHardwareDetect(
+    OSVR_INOUT_PTR OSVR_PluginRegContext ctx) OSVR_FUNC_NONNULL((1));
+
 OSVR_EXTERN_C_END
 
 /** @} */
 
-#endif
+#endif /* INCLUDED_PluginRegistrationC_h_GUID_C019DFA9_5B54_4791_B0A4_040EA20501BA */
+

src/osvr/PluginHost/PluginSpecificRegistrationContextImpl.cpp

@@ -26,6 +26,7 @@
 
 // Internal Includes
 #include "PluginSpecificRegistrationContextImpl.h"
+#include <osvr/PluginHost/RegistrationContext.h>
 #include <osvr/Util/Verbosity.h>
 
 // Library/third-party includes
@@ -169,5 +170,14 @@ namespace pluginhost {
     util::AnyMap const &PluginSpecificRegistrationContextImpl::data() const {
         return m_data;
     }
+
+    void PluginSpecificRegistrationContextImpl::triggerHardwareDetect() {
+        if (m_parent == nullptr) {
+            throw std::logic_error(
+                "Can't access the registration context parent - it is null!");
+        }
+        m_parent->triggerHardwareDetect();;
+    }
+
 } // namespace pluginhost
 } // namespace osvr

src/osvr/PluginHost/PluginSpecificRegistrationContextImpl.h

@@ -115,6 +115,9 @@ namespace pluginhost {
             void *userData);
         /// @}
 
+        /// @brief Trigger system-wide hardware detection.
+        virtual void triggerHardwareDetect();
+
       private:
         /// @brief Pointer with ownership semantics for deletion of plugin data.
         typedef unique_ptr<void, OSVR_PluginDataDeleteCallback> PluginDataPtr;

src/osvr/PluginKit/PluginRegistrationC.cpp

@@ -79,3 +79,20 @@ OSVR_ReturnCode osvrPluginRegisterDataWithDeleteCallback(
     context->registerDataWithDeleteCallback(deleteCallback, pluginData);
     return OSVR_RETURN_SUCCESS;
 }
+
+OSVR_ReturnCode
+osvrPluginTriggerHardwareDetect(OSVR_INOUT_PTR OSVR_PluginRegContext ctx) {
+    OSVR_PLUGIN_HANDLE_NULL_CONTEXT("osvrPluginTriggerHardwareDetect", ctx);
+
+    try {
+        osvr::pluginhost::PluginSpecificRegistrationContext::get(ctx)
+            .triggerHardwareDetect();
+    } catch (std::exception &e) {
+        std::cerr << "Error in osvrPluginTriggerHardwareDetectCallback - "
+                     "caught exception reporting: "
+                  << e.what() << std::endl;
+        return OSVR_RETURN_FAILURE;
+    }
+    return OSVR_RETURN_SUCCESS;
+}
+