Start up procedures

apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.cpp

@@ -0,0 +1,119 @@
+#include "RuntimeServices.h"
+
+#include "ControlServer.h"
+#include "OscServer.h"
+#include "RuntimeControlBridge.h"
+#include "RuntimeHost.h"
+
+#include <windows.h>
+
+RuntimeServices::RuntimeServices() :
+	mControlServer(std::make_unique<ControlServer>()),
+	mOscServer(std::make_unique<OscServer>()),
+	mPollRunning(false),
+	mRegistryChanged(false),
+	mReloadRequested(false),
+	mPollFailed(false)
+{
+}
+
+RuntimeServices::~RuntimeServices()
+{
+	Stop();
+}
+
+bool RuntimeServices::Start(OpenGLComposite& composite, RuntimeHost& runtimeHost, std::string& error)
+{
+	Stop();
+
+	if (!StartRuntimeControlServices(composite, runtimeHost, *mControlServer, *mOscServer, error))
+	{
+		Stop();
+		return false;
+	}
+
+	return true;
+}
+
+void RuntimeServices::BeginPolling(RuntimeHost& runtimeHost)
+{
+	StartPolling(runtimeHost);
+}
+
+void RuntimeServices::Stop()
+{
+	StopPolling();
+
+	if (mOscServer)
+		mOscServer->Stop();
+
+	if (mControlServer)
+		mControlServer->Stop();
+}
+
+void RuntimeServices::BroadcastState()
+{
+	if (mControlServer)
+		mControlServer->BroadcastState();
+}
+
+RuntimePollEvents RuntimeServices::ConsumePollEvents()
+{
+	RuntimePollEvents events;
+	events.registryChanged = mRegistryChanged.exchange(false);
+	events.reloadRequested = mReloadRequested.exchange(false);
+	events.failed = mPollFailed.exchange(false);
+
+	if (events.failed)
+	{
+		std::lock_guard<std::mutex> lock(mPollErrorMutex);
+		events.error = mPollError;
+	}
+
+	return events;
+}
+
+void RuntimeServices::StartPolling(RuntimeHost& runtimeHost)
+{
+	if (mPollRunning.exchange(true))
+		return;
+
+	mPollThread = std::thread([this, &runtimeHost]() { PollLoop(runtimeHost); });
+}
+
+void RuntimeServices::StopPolling()
+{
+	if (!mPollRunning.exchange(false))
+		return;
+
+	if (mPollThread.joinable())
+		mPollThread.join();
+}
+
+void RuntimeServices::PollLoop(RuntimeHost& runtimeHost)
+{
+	while (mPollRunning)
+	{
+		bool registryChanged = false;
+		bool reloadRequested = false;
+		std::string runtimeError;
+		if (!runtimeHost.PollFileChanges(registryChanged, reloadRequested, runtimeError))
+		{
+			{
+				std::lock_guard<std::mutex> lock(mPollErrorMutex);
+				mPollError = runtimeError;
+			}
+			mPollFailed = true;
+		}
+		else
+		{
+			if (registryChanged)
+				mRegistryChanged = true;
+			if (reloadRequested)
+				mReloadRequested = true;
+		}
+
+		for (int i = 0; i < 25 && mPollRunning; ++i)
+			Sleep(10);
+	}
+}

apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+
+class ControlServer;
+class OpenGLComposite;
+class OscServer;
+class RuntimeHost;
+
+struct RuntimePollEvents
+{
+	bool registryChanged = false;
+	bool reloadRequested = false;
+	bool failed = false;
+	std::string error;
+};
+
+class RuntimeServices
+{
+public:
+	RuntimeServices();
+	~RuntimeServices();
+
+	bool Start(OpenGLComposite& composite, RuntimeHost& runtimeHost, std::string& error);
+	void BeginPolling(RuntimeHost& runtimeHost);
+	void Stop();
+	void BroadcastState();
+	RuntimePollEvents ConsumePollEvents();
+
+private:
+	void StartPolling(RuntimeHost& runtimeHost);
+	void StopPolling();
+	void PollLoop(RuntimeHost& runtimeHost);
+
+	std::unique_ptr<ControlServer> mControlServer;
+	std::unique_ptr<OscServer> mOscServer;
+	std::thread mPollThread;
+	std::atomic<bool> mPollRunning;
+	std::atomic<bool> mRegistryChanged;
+	std::atomic<bool> mReloadRequested;
+	std::atomic<bool> mPollFailed;
+	std::mutex mPollErrorMutex;
+	std::string mPollError;
+};