1 files changed, 140 insertions, 0 deletions
diff --git a/CommonAPI-Examples/E07Mainloop/src/E07MainloopService.cpp b/CommonAPI-Examples/E07Mainloop/src/E07MainloopService.cpp
new file mode 100644
index 0000000..e57f192
--- /dev/null
+++ b/CommonAPI-Examples/E07Mainloop/src/E07MainloopService.cpp
@@ -0,0 +1,140 @@
+/* Copyright (C) 2015 BMW Group
+ * Author: Lutz Bichler (lutz.bichler@bmw.de)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <iostream>
+#include <thread>
+
+#include <glib.h>
+
+#include <CommonAPI/CommonAPI.hpp>
+#include "E07MainloopStubImpl.hpp"
+
+using namespace std;
+
+GIOChannel* channel;
+
+gboolean callIncCounter(void* service) {
+
+	E07MainloopStubImpl* myService = static_cast<E07MainloopStubImpl*>(service);
+	myService->incAttrX();
+
+	return true;
+}
+
+gboolean callWaitingInfo(void* service) {
+	std::cout << "Waiting for calls... (Abort with CTRL+C)" << std::endl;
+
+	return true;
+}
+
+class GDispatchWrapper: public GSource {
+ public:
+    GDispatchWrapper(CommonAPI::DispatchSource* dispatchSource): dispatchSource_(dispatchSource) {}
+    CommonAPI::DispatchSource* dispatchSource_;
+};
+
+gboolean dispatchPrepare ( GSource* source, gint* timeout ) {
+
+	bool result = false;
+	int64_t eventTimeout;
+
+	result = static_cast<GDispatchWrapper*>(source)->dispatchSource_->prepare(eventTimeout);
+
+	*timeout = eventTimeout;
+
+    return result;
+}
+
+gboolean dispatchCheck ( GSource* source ) {
+
+	return static_cast<GDispatchWrapper*>(source)->dispatchSource_->check();
+}
+
+gboolean dispatchExecute ( GSource* source, GSourceFunc callback, gpointer userData ) {
+
+	static_cast<GDispatchWrapper*>(source)->dispatchSource_->dispatch();
+    return true;
+}
+
+static GSourceFuncs standardGLibSourceCallbackFuncs = {
+	dispatchPrepare,
+	dispatchCheck,
+	dispatchExecute,
+	NULL
+};
+
+gboolean gWatchDispatcher ( GIOChannel *source, GIOCondition condition, gpointer userData ) {
+
+	CommonAPI::Watch* watch = static_cast<CommonAPI::Watch*>(userData);
+    watch->dispatch(condition);
+    return true;
+}
+
+gboolean gTimeoutDispatcher ( void* userData ) {
+
+	return static_cast<CommonAPI::DispatchSource*>(userData)->dispatch();
+}
+
+void watchAddedCallback ( CommonAPI::Watch* watch, const CommonAPI::DispatchPriority dispatchPriority ) {
+
+	const pollfd& fileDesc = watch->getAssociatedFileDescriptor();
+    channel = g_io_channel_unix_new(fileDesc.fd);
+
+    GSource* gWatch = g_io_create_watch(channel, static_cast<GIOCondition>(fileDesc.events));
+    g_source_set_callback(gWatch, reinterpret_cast<GSourceFunc>(&gWatchDispatcher), watch, NULL);
+
+    const auto& dependentSources = watch->getDependentDispatchSources();
+    for (auto dependentSourceIterator = dependentSources.begin();
+            dependentSourceIterator != dependentSources.end();
+            dependentSourceIterator++) {
+        GSource* gDispatchSource = g_source_new(&standardGLibSourceCallbackFuncs, sizeof(GDispatchWrapper));
+        static_cast<GDispatchWrapper*>(gDispatchSource)->dispatchSource_ = *dependentSourceIterator;
+
+        g_source_add_child_source(gWatch, gDispatchSource);
+
+    }
+    g_source_attach(gWatch, NULL);
+}
+
+void watchRemovedCallback ( CommonAPI::Watch* watch ) {
+
+	g_source_remove_by_user_data(watch);
+
+    if(channel) {
+        g_io_channel_unref(channel);
+        channel = NULL;
+    }
+}
+
+int main() {
+    std::shared_ptr<CommonAPI::Runtime> runtime = CommonAPI::Runtime::get();
+
+    std::string domain = "local";
+	std::string instance = "commonapi.examples.Mainloop";
+	std::string connection = "service-sample";
+
+    std::shared_ptr<CommonAPI::MainLoopContext> mainloopContext = std::make_shared<CommonAPI::MainLoopContext>(connection);
+
+	std::function<void(CommonAPI::Watch*, const CommonAPI::DispatchPriority)> f_watchAddedCallback = watchAddedCallback;
+	std::function<void(CommonAPI::Watch*)> f_watchRemovedCallback = watchRemovedCallback;
+	mainloopContext->subscribeForWatches(f_watchAddedCallback, f_watchRemovedCallback);
+
+	std::shared_ptr<E07MainloopStubImpl> myService = std::make_shared<E07MainloopStubImpl>();
+    runtime->registerService(domain, instance, myService, mainloopContext);
+
+    GMainLoop* mainloop = NULL;
+    mainloop = g_main_loop_new(NULL, FALSE);
+
+    void *servicePtr = (void*)myService.get();
+	g_timeout_add_seconds(10, callWaitingInfo, servicePtr);
+
+	g_timeout_add(2500, callIncCounter, servicePtr);
+
+    g_main_loop_run (mainloop);
+    g_main_loop_unref (mainloop);
+
+    return 0;
+}