Changing the way that activities are being built

Provided tests currently fails. Patch https://review.tizen.org/gerrit/#/c/131357/ fix this problem.

Change-Id: I265113e244fc2db397ead0e1d4e8d6db6c0b2fa2

diff --git a/src/AccessoriesSwitchProvider.cpp b/src/AccessoriesSwitchProvider.cpp
index 64c4540..a17784c 100644 (file)
--- a/src/AccessoriesSwitchProvider.cpp
+++ b/src/AccessoriesSwitchProvider.cpp
@@ -703,7 +703,7 @@ Eina_Bool AccessoriesSwitchProvider::onEcoreEventKeyDownCb(void *data, int type,
        auto event = static_cast<Ecore_Event_Key *>(ev);
        std::string keyId(event->key);
 
-       auto accessoriesSwitchProvider = reinterpret_cast<AccessoriesSwitchProvider*>(data);
+       auto accessoriesSwitchProvider = reinterpret_cast<AccessoriesSwitchProvider *>(data);
        auto switchId = SwitchId(keyId, accessoriesSwitchProvider->getId());
        auto sw = accessoriesSwitchProvider->findSwitchById(switchId.getGlobalId());
 

diff --git a/src/Activity.cpp b/src/Activity.cpp
index f75a251..b0b2467 100644 (file)
--- a/src/Activity.cpp
+++ b/src/Activity.cpp
@@ -1,11 +1,10 @@
 #include "Activity.hpp"
 
-/*
-Activity::Activity(const std::shared_ptr<UIElement> &element)
-:uiElement(element)
+Activity::Activity(const std::string &activityType)
+       : type(activityType)
 {}
 
-Activity::setUIElement(const std::shared_ptr<UIElement> &element) {
-       UIElement = element;
+std::string Activity::getType()
+{
+       return type;
 }
-*/

diff --git a/src/Activity.hpp b/src/Activity.hpp
index a711980..6f6065e 100644 (file)
--- a/src/Activity.hpp
+++ b/src/Activity.hpp
@@ -1,21 +1,21 @@
 #ifndef ACTIVITY_HPP
 #define ACTIVITY_HPP
 
-#include "UIElement.hpp"
-
 #include <memory>
 
 class Activity
 {
 public:
-       Activity(){}
-       Activity(const std::shared_ptr<UIElement> &element);
-       virtual ~Activity();
-       void setUIElement(const std::shared_ptr<UIElement> &element);
+       Activity(const std::string &activityType);
+       virtual ~Activity() = default;
+
+       std::string getType();
 
+       virtual bool prepare() = 0;
        virtual void execute() = 0;
+
 private:
-       std::shared_ptr<UIElement> uiElement;
+       std::string type;
 };
 
 #endif

diff --git a/src/ActivityBuilder.hpp b/src/ActivityBuilder.hpp
deleted file mode 100644 (file)
index bda5d87..0000000
--- a/src/ActivityBuilder.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef ACTIVITY_BUILDER_HPP
-#define ACTIVITY_BUILDER_HPP
-
-#include "Activity.hpp"
-#include "Subject.hpp"
-#include "UIElement.hpp"
-
-class ActivityBuilder : public Subject<Activity>
-{
-public:
-       virtual void createNewActivity() = 0;
-       virtual void buildUIElement() = 0;
-};
-
-#endif

diff --git a/src/ActivityBuilderFactory.hpp b/src/ActivityBuilderFactory.hpp
deleted file mode 100644 (file)
index 39f02ed..0000000
--- a/src/ActivityBuilderFactory.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef ACTIVITY_BUILDER_FACTORY_HPP
-#define ACTIVITY_BUILDER_FACTORY_HPP
-
-#include "ActivityBuilder.hpp"
-
-#include <memory>
-
-class ActivityBuilderFactory
-{
-public:
-       virtual ~ActivityBuilderFactory(){};
-       virtual std::shared_ptr<ActivityBuilder> getActivityBuilder(const std::string &activityType) = 0;
-};
-
-#endif

diff --git a/src/ActivityDispatcher.hpp b/src/ActivityDispatcher.hpp
index ae9815f..fc4cba7 100644 (file)
--- a/src/ActivityDispatcher.hpp
+++ b/src/ActivityDispatcher.hpp
@@ -8,7 +8,7 @@
 class ActivityDispatcher
 {
 public:
-       virtual ~ActivityDispatcher(){};
+       virtual ~ActivityDispatcher() {};
 
        virtual void dispatch(std::shared_ptr<Activity> activity) = 0;
 };

diff --git a/src/ActivityFactory.cpp b/src/ActivityFactory.cpp
new file mode 100644 (file)
index 0000000..e4d0692
--- /dev/null
+++ b/src/ActivityFactory.cpp
@@ -0,0 +1,33 @@
+#include "ActivityFactory.hpp"
+
+std::shared_ptr<Activity> ActivityFactory::getActivity(const std::string &activityType)
+{
+       auto it = constructorMap.find(activityType);
+
+       if (it == constructorMap.end())
+               return nullptr;
+
+       ActivityConstructor constructor = it->second;
+       return constructor();
+}
+
+void ActivityFactory::registerActivityConstructor(const char *activityType, ActivityConstructor c)
+{
+       constructorMap.emplace(activityType, c);
+}
+
+std::vector<std::string> ActivityFactory::getAllActivityTypes()
+{
+       std::vector<std::string> result;
+
+       for (auto &pair : constructorMap)
+               result.emplace_back(pair.first);
+
+       return result;
+}
+
+std::shared_ptr<ActivityFactory> ActivityFactory::getInstance()
+{
+       static auto instance = std::make_shared<ActivityFactory>();
+       return instance;
+}

diff --git a/src/ActivityFactory.hpp b/src/ActivityFactory.hpp
new file mode 100644 (file)
index 0000000..15d0389
--- /dev/null
+++ b/src/ActivityFactory.hpp
@@ -0,0 +1,45 @@
+#ifndef ACTIVITY_FACTORY_HPP
+#define ACTIVITY_FACTORY_HPP
+
+#include "Activity.hpp"
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+class ActivityFactory
+{
+public:
+       using ActivityConstructor = std::function<std::shared_ptr<Activity>()>;
+
+       virtual ~ActivityFactory() = default;
+       static std::shared_ptr<ActivityFactory> getInstance();
+
+       std::shared_ptr<Activity> getActivity(const std::string &activityType);
+       void registerActivityConstructor(const char *activityType, ActivityConstructor c);
+       std::vector<std::string> getAllActivityTypes();
+
+private:
+       std::unordered_map<std::string, ActivityConstructor> constructorMap;
+};
+
+
+
+template <class T>
+class RegisterActivity
+{
+public:
+       static bool reg;
+       static bool init()
+       {
+               ActivityFactory::getInstance()->registerActivityConstructor(T::activityType, [](void) {
+                       return std::make_shared<T>();
+               });
+               return true;
+       }
+};
+
+template <class T>
+bool RegisterActivity<T>::reg = RegisterActivity<T>::init();
+
+#endif

diff --git a/src/ActivityTypes.cpp b/src/ActivityTypes.cpp
deleted file mode 100644 (file)
index 4576e53..0000000
--- a/src/ActivityTypes.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "ActivityTypes.hpp"
-
-std::set<std::string> ActivityTypes::getActivityCollection() {
-       static ActivityTypes activityTypes;
-       return activityTypes.activities;
-}
-
-ActivityTypes::ActivityTypes() {
-       for (auto name : {"ACTIVITY_SELECT",
-       "ACTIVITY_TOUCH",
-       "ACTIVITY_MORE_OPTIONS",
-       "ACTIVITY_MOVE_NEXT",
-       "ACTIVITY_MORE_PREVIOUS",
-       "ACTIVITY_HOME_SCREEN",
-       "ACTIVITY_BACK",
-       "ACTIVITY_RINGTONE_VOLUME_UP",
-       "ACTIVITY_RINGTONE_VOLUME_DOWN",
-       "ACTIVITY_NOTIFICATIONS",
-       "ACTIVITY_RECENTLY_USED_APPS",
-       "ACTIVITY_AUTO_SCAN_OFF",
-       "ACTIVITY_AUTO_SCAN_ON",
-
-       "ACTIVITY_GESTURES",
-       "ACTIVITY_FLICK_LEFT",
-       "ACTIVITY_FLICK_RIGHT",
-       "ACTIVITY_FLICK_TOP",
-       "ACTIVITY_FLICK_DOWN",
-       "ACTIVITY_AUTOMATICALLY",
-       "ACTIVITY_TOUCH_AND_HOLD",
-       "ACTIVITY_FLICK",
-       "ACTIVITY_TOUCH_AND_FLICK",
-
-       "ACTIVITY_ACTIONS",
-       "ACTIVITY_ZOOM_IN",
-       "ACTIVITY_ZOOM_OUT",
-       "ACTIVITY_SCREEN_ROTATION",
-       "ACTIVITY_VIBRATION",
-       "ACTIVITY_LOCK",
-       "ACTIVITY_SCREEN_SHOT",
-
-       "ACTIVITY_SETTINGS",
-       "ACTIVITY_FASTER",
-       "ACTIVITY_SLOWER",
-       "ACTIVITY_POINT_SCANNING",
-       "ACTIVITY_BOTTOM_UP",
-       "ACTIVITY_UNMUTE",
-       "ACTIVITY_MUTE",
-       "ACTIVITY_MORE_SETTINGS",
-
-       "ACTIVITY_KEYS",
-       "ACTIVITY_MEDIA_VOLUME_UP",
-       "ACTIVITY_MEDIA_VOLUME_DOWN",
-       "ACTIVITY_DOUBLE_TAP_HOME_BTN",
-       "ACTIVITY_TRIPLE_TAP_HOME_BTN",
-       "ACTIVITY_DEVICE_OPTIONS",
-       "ACTIVITY_MORE_OPTIONS"})
-               activities.insert(name);
-}

diff --git a/src/ActivityTypes.hpp b/src/ActivityTypes.hpp
deleted file mode 100644 (file)
index 751c0c4..0000000
--- a/src/ActivityTypes.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef ACTIVITY_TYPES_HPP
-#define ACTIVITY_TYPES_HPP
-
-#include <set>
-#include <string>
-
-class ActivityTypes
-{
-public:
-       static std::set<std::string> getActivityCollection();
-
-private:
-       ActivityTypes();
-       ~ActivityTypes(){};
-
-       std::set<std::string> activities;
-};
-
-#endif

diff --git a/src/AdHocActivityDispatcher.cpp b/src/AdHocActivityDispatcher.cpp
index 2deb598..a2ec274 100644 (file)
--- a/src/AdHocActivityDispatcher.cpp
+++ b/src/AdHocActivityDispatcher.cpp
@@ -1,6 +1,7 @@
 #include "AdHocActivityDispatcher.hpp"
 
-void AdHocActivityDispatcher::dispatch(std::shared_ptr<Activity> activity) {
+void AdHocActivityDispatcher::dispatch(std::shared_ptr<Activity> activity)
+{
        if (activity)
                activity->execute();
 }

diff --git a/src/AsyncActivityConstructor.hpp b/src/AsyncActivityConstructor.hpp
deleted file mode 100644 (file)
index cee233d..0000000
--- a/src/AsyncActivityConstructor.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef ASYNC_ACTIVITY_CONSTRUCTOR_HPP
-#define ASYNC_ACTIVITY_CONSTRUCTOR_HPP
-
-#include "ActivityBuilder.hpp"
-#include "ActivityObserver.hpp"
-
-class AsyncActivityConstructor
-{
-public:
-       void construct(const std::shared_ptr<ActivityBuilder> &builder, const std::shared_ptr<ActivityObserver> &observer);
-};
-
-#endif

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 41a6072..2383e17 100644 (file)
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,8 +1,6 @@
 SET(SRCS
        AccessoriesSwitchProvider.cpp
-       ActivityTypes.cpp
        AdHocActivityDispatcher.cpp
-       CachedActivityBuilderFactory.cpp
        QueryBuilder.cpp
        Switch.cpp
        SwitchProvider.cpp
@@ -13,6 +11,10 @@ SET(SRCS
        SQLiteConfiguration.cpp
        SwitchManager.cpp
        SwitchId.cpp
+       ScreenScannerManager.cpp
+       SelectActivity.cpp
+       ActivityFactory.cpp
+       UIActivity.cpp
 )
 
 ADD_LIBRARY(universal-switch-obj OBJECT ${SRCS})

diff --git a/src/CachedActivityBuilderFactory.cpp b/src/CachedActivityBuilderFactory.cpp
deleted file mode 100644 (file)
index 6d91340..0000000
--- a/src/CachedActivityBuilderFactory.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "CachedActivityBuilderFactory.hpp"
-
-std::shared_ptr<ActivityBuilder> CachedActivityBuilderFactory::getActivityBuilder(const std::string &activityType) {
-}

diff --git a/src/CachedActivityBuilderFactory.hpp b/src/CachedActivityBuilderFactory.hpp
deleted file mode 100644 (file)
index 13a14b1..0000000
--- a/src/CachedActivityBuilderFactory.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef CACHED_ACTIVITY_BUILDER_FACTORY_HPP
-#define CACHED_ACTIVITY_BUILDER_FACTORY_HPP
-
-#include "ActivityBuilderFactory.hpp"
-
-class CachedActivityBuilderFactory : public ActivityBuilderFactory
-{
-public:
-       std::shared_ptr<ActivityBuilder> getActivityBuilder(const std::string &activityType) override;
-};
-
-#endif

diff --git a/src/Condition.hpp b/src/Condition.hpp
index f917ddd..5a9553a 100644 (file)
--- a/src/Condition.hpp
+++ b/src/Condition.hpp
@@ -4,7 +4,8 @@
 #include <memory>
 
 template<typename T>
-class Condition {
+class Condition
+{
 public:
        virtual ~Condition() = default;
        virtual bool matching(const T *item) const = 0;

diff --git a/src/ConditionAll.hpp b/src/ConditionAll.hpp
index 8eb5886..e8c3cb9 100644 (file)
--- a/src/ConditionAll.hpp
+++ b/src/ConditionAll.hpp
@@ -7,11 +7,13 @@ template<typename T>
 class ConditionAll : public Condition<T>
 {
 public:
-       bool matching(const T *item) const override {
+       bool matching(const T *item) const override
+       {
                return true;
        }
-       
-       std::shared_ptr<T> getItem() const override {
+
+       std::shared_ptr<T> getItem() const override
+       {
                return nullptr;
        }
 };

diff --git a/src/ConditionEqual.hpp b/src/ConditionEqual.hpp
index f3c9d9a..fa57d16 100644 (file)
--- a/src/ConditionEqual.hpp
+++ b/src/ConditionEqual.hpp
@@ -8,14 +8,16 @@ class ConditionEqual : public Condition<T>
 {
 public:
        ConditionEqual(const std::shared_ptr<T> &item)
-               :item(item)
+               : item(item)
        {}
 
-       bool matching(const T *item) const override {
+       bool matching(const T *item) const override
+       {
                return *item == *(this->item);
        }
 
-       std::shared_ptr<T> getItem() const override {
+       std::shared_ptr<T> getItem() const override
+       {
                return item;
        }
 

diff --git a/src/Configuration.hpp b/src/Configuration.hpp
index f989728..a7d375e 100644 (file)
--- a/src/Configuration.hpp
+++ b/src/Configuration.hpp
@@ -12,7 +12,7 @@ class Configuration : public Subject<SwitchConfigurationItem>
 {
 public:
        virtual ~Configuration() = default;
-       
+
        virtual void add(const std::shared_ptr<SwitchConfigurationItem> &item) = 0;
        virtual void update(const std::shared_ptr<SwitchConfigurationItem> &item) = 0;
        virtual void remove(const std::string &switchId) = 0;

diff --git a/src/Observer.hpp b/src/Observer.hpp
index 082db7d..ed94d05 100644 (file)
--- a/src/Observer.hpp
+++ b/src/Observer.hpp
@@ -6,7 +6,8 @@
 #include <memory>
 
 template<typename T>
-class Observer {
+class Observer
+{
 public:
        virtual void update(const std::shared_ptr<T> &item) = 0;
 };

diff --git a/src/QueryBuilder.cpp b/src/QueryBuilder.cpp
index aa4308b..3dd9c3e 100644 (file)
--- a/src/QueryBuilder.cpp
+++ b/src/QueryBuilder.cpp
@@ -2,7 +2,8 @@
 
 #include "UniversalSwitchLog.hpp"
 
-QueryBuilder &QueryBuilder::select(const std::initializer_list<std::string> &list) {
+QueryBuilder &QueryBuilder::select(const std::initializer_list<std::string> &list)
+{
        query << "select ";
 
        bool first = true;
@@ -18,21 +19,24 @@ QueryBuilder &QueryBuilder::select(const std::initializer_list<std::string> &lis
        return *this;
 }
 
-QueryBuilder &QueryBuilder::from(const std::string &s) {
+QueryBuilder &QueryBuilder::from(const std::string &s)
+{
        query << " from " << s << " ";
 
        printDebug();
        return *this;
 }
 
-QueryBuilder &QueryBuilder::where(const std::string &lv, const std::string &op, const std::string &rv) {
+QueryBuilder &QueryBuilder::where(const std::string &lv, const std::string &op, const std::string &rv)
+{
        query << "where " << lv << op << "'" << rv  << "' ";
 
        printDebug();
        return *this;
 }
 
-QueryBuilder &QueryBuilder::set(const std::initializer_list<std::pair<std::string, std::string>> &pairs) {
+QueryBuilder &QueryBuilder::set(const std::initializer_list<std::pair<std::string, std::string>> &pairs)
+{
        query << "set ";
 
        bool first = true;
@@ -41,21 +45,23 @@ QueryBuilder &QueryBuilder::set(const std::initializer_list<std::pair<std::strin
                        first = false;
                else
                        query << ", ";
-               query << elem.first << "='" << elem.second <<"'";
+               query << elem.first << "='" << elem.second << "'";
        }
 
        printDebug();
        return *this;
 }
 
-QueryBuilder &QueryBuilder::insertInto(const std::string &s) {
+QueryBuilder &QueryBuilder::insertInto(const std::string &s)
+{
        query << "insert into " << s << " ";
 
        printDebug();
        return *this;
 }
 
-QueryBuilder &QueryBuilder::values(const std::initializer_list<std::string> &list) {
+QueryBuilder &QueryBuilder::values(const std::initializer_list<std::string> &list)
+{
        query << "values (";
 
        bool first = true;
@@ -64,7 +70,7 @@ QueryBuilder &QueryBuilder::values(const std::initializer_list<std::string> &lis
                        first = false;
                else
                        query << ", ";
-               query << "'" << elem <<"'";
+               query << "'" << elem << "'";
        }
 
        query << ") ";
@@ -73,41 +79,47 @@ QueryBuilder &QueryBuilder::values(const std::initializer_list<std::string> &lis
        return *this;
 }
 
-QueryBuilder &QueryBuilder::update(const std::string &s) {
+QueryBuilder &QueryBuilder::update(const std::string &s)
+{
        query << "update " << s << " ";
 
        printDebug();
        return *this;
 }
 
-QueryBuilder &QueryBuilder::deleteFrom(const std::string &s) {
+QueryBuilder &QueryBuilder::deleteFrom(const std::string &s)
+{
        query << "delete from " << s << " ";
 
        printDebug();
        return *this;
 }
 
-QueryBuilder &QueryBuilder::qAnd(const std::string &lv, const std::string &op, const std::string &rv) {
+QueryBuilder &QueryBuilder::qAnd(const std::string &lv, const std::string &op, const std::string &rv)
+{
        query << "and " << lv << op << "'" << rv << "' ";
 
        printDebug();
        return *this;
 }
 
-QueryBuilder &QueryBuilder::qOr(const std::string &lv, const std::string &op, const std::string &rv) {
+QueryBuilder &QueryBuilder::qOr(const std::string &lv, const std::string &op, const std::string &rv)
+{
        query << "or " << lv << op << "'" << rv << "' ";
 
        printDebug();
        return *this;
 }
 
-std::string QueryBuilder::build() {
+std::string QueryBuilder::build()
+{
        query << ";";
 
        printDebug();
        return query.str();
 }
 
-void QueryBuilder::printDebug() {
+void QueryBuilder::printDebug()
+{
        DEBUG("query: %s", query.str().c_str());
 }

diff --git a/src/SQLiteConfiguration.cpp b/src/SQLiteConfiguration.cpp
index f39123b..07e1403 100644 (file)
--- a/src/SQLiteConfiguration.cpp
+++ b/src/SQLiteConfiguration.cpp
@@ -43,9 +43,9 @@ SQLiteConfiguration::~SQLiteConfiguration()
 void SQLiteConfiguration::add(const std::shared_ptr<SwitchConfigurationItem> &item)
 {
        auto query = QueryBuilder().insertInto(tableName).values({item->getSwitchId(),
-                                                                                                          item->getUserName(),
-                                                                                                          item->getActivityType()
-                                                                                                  }).build();
+                                item->getUserName(),
+                                item->getActivityType()
+                                                                                                                        }).build();
 
        item->setChangeType(ChangeType::ADD);
        if (executeQuery(query))
@@ -94,31 +94,35 @@ std::shared_ptr<SwitchConfigurationItem> SQLiteConfiguration::findBySwitchId(con
 
        auto item = std::make_shared<SwitchConfigurationItem>();
 
-       if (!executeQuery(query, [=](int argc, char **argv, char **azColName) { item->construct(argc, argv, azColName); }))
-               return nullptr;
+       if (!executeQuery(query, [ = ](int argc, char **argv, char **azColName) {
+       item->construct(argc, argv, azColName);
+       }))
+       return nullptr;
 
        INFO("Found: %s, %s, %s", item->getSwitchId().c_str(), item->getUserName().c_str(), item->getActivityType().c_str());
 
        return item;
 }
 
-std::vector<std::shared_ptr<SwitchConfigurationItem>> SQLiteConfiguration::findAll() const {
+std::vector<std::shared_ptr<SwitchConfigurationItem>> SQLiteConfiguration::findAll() const
+{
        auto query = QueryBuilder().select({"*"}).from(tableName).build();
 
        auto collection = std::vector<std::shared_ptr<SwitchConfigurationItem>>();
 
        if (!executeQuery(query, [&](int argc, char **argv, char **azColName) {
-                                    auto item = std::make_shared<SwitchConfigurationItem>();
-                                    item->construct(argc, argv, azColName);
-                                    collection.emplace_back(item); }))
-               return {};
+       auto item = std::make_shared<SwitchConfigurationItem>();
+               item->construct(argc, argv, azColName);
+               collection.emplace_back(item);
+       }))
+       return {};
 
        return collection;
 }
 
 static int call_functor(void *data, int argc, char **argv, char **colName)
 {
-       auto &callback = *(const SQLiteConfiguration::execCallback_t*)data;
+       auto &callback = *(const SQLiteConfiguration::execCallback_t *)data;
        callback(argc, argv, colName);
        return 0;
 }
@@ -127,7 +131,7 @@ bool SQLiteConfiguration::executeQuery(const std::string &query, const execCallb
 {
        INFO("executeQuery: %s", query.c_str());
        char *errorMessage = nullptr;
-       auto result = sqlite3_exec(dbHandler, query.c_str(), call_functor, const_cast<execCallback_t*>(&cb), &errorMessage);
+       auto result = sqlite3_exec(dbHandler, query.c_str(), call_functor, const_cast<execCallback_t *>(&cb), &errorMessage);
        if (result != SQLITE_OK) {
                ERROR("sqlite ERROR: %s", errorMessage);
                sqlite3_free(errorMessage);
@@ -156,10 +160,10 @@ bool SQLiteConfiguration::executeQuery(const std::string &query) const
 void SQLiteConfiguration::createTable()
 {
        auto query = "CREATE TABLE IF NOT EXISTS " + tableName + "("
-                                               + switchIdCol + " TEXT NOT NULL, "
-                                               + userNameCol + " TEXT, "
-                                               + activityTypeCol + " TEXT NOT NULL, "
-                                               + "PRIMARY KEY (" + switchIdCol + "));";
+                                + switchIdCol + " TEXT NOT NULL, "
+                                + userNameCol + " TEXT, "
+                                + activityTypeCol + " TEXT NOT NULL, "
+                                + "PRIMARY KEY (" + switchIdCol + "));";
 
        INFO("query: %s", query.c_str());
        executeQuery(query);

diff --git a/src/ScanningControlRequest.hpp b/src/ScanningControlRequest.hpp
deleted file mode 100644 (file)
index cc99542..0000000
--- a/src/ScanningControlRequest.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef SCANNING_CONTROL_REQUEST_HPP
-#define SCANNING_CONTROL_REQUEST_HPP
-
-class ScannigControlRequest
-{
-
-};
-
-#endif

diff --git a/src/ScreenScanner.hpp b/src/ScreenScanner.hpp
index 20d3f41..84baf4d 100644 (file)
--- a/src/ScreenScanner.hpp
+++ b/src/ScreenScanner.hpp
@@ -1,17 +1,19 @@
 #ifndef SCREEN_SCANNER_HPP
 #define SCREEN_SCANNER_HPP
 
-#include "Observer.hpp"
 #include "UIElement.hpp"
-#include "ScanningControlRequest.hpp"
 
 #include <memory>
 
-class ScreenScanner : public Subject<UIElement>
+class ScreenScanner
 {
 public:
        virtual ~ScreenScanner();
-       virtual void handle(std::shared_ptr<ScanningControlRequest> request) = 0;
+
+       virtual std::shared_ptr<UIElement> acceptAutoscanning() = 0;
+
+protected:
+       unsigned int speed;
 };
 
 #endif

diff --git a/src/ScreenScannerManager.cpp b/src/ScreenScannerManager.cpp
new file mode 100644 (file)
index 0000000..3dab35e
--- /dev/null
+++ b/src/ScreenScannerManager.cpp
@@ -0,0 +1,48 @@
+#include "ScreenScannerManager.hpp"
+
+ScreenScannerManager::ScreenScannerManager()
+{
+       //TODO: register for scanning parameteres in vconf.
+       // vconf key are defined in universal-switch UI in settings information
+}
+
+ScreenScannerManager &ScreenScannerManager::instance()
+{
+       static ScreenScannerManager *instance = new ScreenScannerManager;
+       return *instance;
+}
+
+void ScreenScannerManager::changeScanningMethod()
+{
+
+}
+
+void ScreenScannerManager::changeScanningDirection()
+{
+
+}
+
+void ScreenScannerManager::changeScanningSpeed(unsigned speed)
+{
+
+}
+
+void ScreenScannerManager::changeScanningLoopLimit(unsigned limit)
+{
+
+}
+
+void ScreenScannerManager::startAutoscanning()
+{
+
+}
+
+void ScreenScannerManager::stopAutoscanning()
+{
+
+}
+
+void ScreenScannerManager::acceptAutoscanning()
+{
+
+}

diff --git a/src/ScreenScannerManager.hpp b/src/ScreenScannerManager.hpp
new file mode 100644 (file)
index 0000000..1a7c680
--- /dev/null
+++ b/src/ScreenScannerManager.hpp
@@ -0,0 +1,34 @@
+#ifndef SCREEN_SCANNER_MANAGER_HPP
+#define SCREEN_SCANNER_MANAGER_HPP
+
+#include "Subject.hpp"
+#include "UIElement.hpp"
+#include "ScreenScanner.hpp"
+
+enum class ScanningMethod {
+       ROW,
+       POINT
+};
+
+class ScreenScannerManager : public Subject<UIElement>
+{
+public:
+       static ScreenScannerManager &instance();
+
+       void changeScanningMethod();
+       void changeScanningDirection();
+       void changeScanningSpeed(unsigned int speed);
+       void changeScanningLoopLimit(unsigned int limit);
+
+       void startAutoscanning();
+       void stopAutoscanning();
+       void acceptAutoscanning();
+
+private:
+       ScreenScannerManager();
+
+       ScanningMethod scanningMethod;
+       std::shared_ptr<ScreenScanner> screenScanner;
+};
+
+#endif

diff --git a/src/SelectActivity.cpp b/src/SelectActivity.cpp
new file mode 100644 (file)
index 0000000..dff8c35
--- /dev/null
+++ b/src/SelectActivity.cpp
@@ -0,0 +1,13 @@
+#include "UIActivity.hpp"
+#include "ActivityFactory.hpp"
+
+
+
+class SelectActivity : public UIActivity, RegisterActivity<SelectActivity>
+{
+       static constexpr const char *activityType = "SELECT";
+       void execute()
+       {
+               //TODO: build contextual menu
+       }
+};

diff --git a/src/Subject.hpp b/src/Subject.hpp
index 2d5ed02..e5be8b2 100644 (file)
--- a/src/Subject.hpp
+++ b/src/Subject.hpp
@@ -33,8 +33,9 @@ protected:
        {
                for (auto &it : observers) {
                        auto observer = it.first.lock();
-                       if (it.second->matching(item.get()))
+                       if (observer && it.second->matching(item.get()))
                                observer->update(item);
+
                }
        }
 

diff --git a/src/SwitchConfigurationItem.cpp b/src/SwitchConfigurationItem.cpp
index 00a41df..cb7a18c 100644 (file)
--- a/src/SwitchConfigurationItem.cpp
+++ b/src/SwitchConfigurationItem.cpp
@@ -29,11 +29,13 @@ void SwitchConfigurationItem::setSwitchId(const std::string &switchId)
        this->switchId = switchId;
 }
 
-std::string SwitchConfigurationItem::getUserName() const {
+std::string SwitchConfigurationItem::getUserName() const
+{
        return userName;
 }
 
-void SwitchConfigurationItem::setUserName(const std::string &userName) {
+void SwitchConfigurationItem::setUserName(const std::string &userName)
+{
        this->userName = userName;
 }
 

diff --git a/src/SwitchManager.cpp b/src/SwitchManager.cpp
index 34cf8ee..42937c2 100644 (file)
--- a/src/SwitchManager.cpp
+++ b/src/SwitchManager.cpp
@@ -5,15 +5,14 @@
 #include "AdHocActivityDispatcher.hpp"
 
 SwitchManager::SwitchManager(const std::shared_ptr<SwitchProvider> &provider,
-                                        const std::shared_ptr<Configuration> &configuration,
-                                        const std::shared_ptr<ActivityBuilderFactory> &factory)
-       : switchProvider(provider),
+                                                        const std::shared_ptr<Configuration> &configuration,
+                                                        const std::shared_ptr<ActivityFactory> &factory,
+                                                        const std::shared_ptr<ActivityDispatcher> &dispatcher)
+       : switchProvider(provider),
          configuration(configuration),
-         activityBuilderFactory(factory)
-{
-       asyncActivityConstructor = std::make_shared<AsyncActivityConstructor>();
-       activityDispatcher = std::make_shared<AdHocActivityDispatcher>();
-}
+         activityFactory(factory),
+         activityDispatcher(dispatcher)
+{}
 
 void SwitchManager::initialize()
 {
@@ -32,9 +31,9 @@ void SwitchManager::initialize()
        }
 }
 
-void SwitchManager::update(const std::shared_ptr<SwitchConfigurationItem> &item) {
-       switch (item->getChangeType())
-       {
+void SwitchManager::update(const std::shared_ptr<SwitchConfigurationItem> &item)
+{
+       switch (item->getChangeType()) {
        case ChangeType::ADD: {
                auto sw = switchProvider->findSwitchById(item->getSwitchId());
                if (!sw)
@@ -61,10 +60,42 @@ void SwitchManager::update(const std::shared_ptr<SwitchConfigurationItem> &item)
        }
 }
 
-void SwitchManager::update(const std::shared_ptr<Switch> &item) {
+void SwitchManager::update(const std::shared_ptr<Switch> &sw)
+{
+       auto confItem = configuration->findBySwitchId(sw->getId()->getGlobalId());
+       auto activityType = confItem->getActivityType();
+
+       if (!activity || activity->getType() != activityType)
+               activity = activityFactory->getActivity(activityType);
+
+       bool ready = false;
+       if (!activity)
+               ERROR("No activity provided.");
+       else
+               ready = activity->prepare();
+
+       if (ready) {
+               activityDispatcher->dispatch(activity);
+               activity.reset();
+       }
+}
+
+void SwitchManager::setActivityProvider(const std::shared_ptr<SwitchProvider> &provider)
+{
+       switchProvider = provider;
+}
 
+void SwitchManager::setConfiguration(const std::shared_ptr<Configuration> &configuration)
+{
+       this->configuration = configuration;
 }
 
-void SwitchManager::update(const std::shared_ptr<Activity> &item) {
+void SwitchManager::setActivityFactory(const std::shared_ptr<ActivityFactory> &factory)
+{
+       activityFactory = factory;
+}
 
+void SwitchManager::setActivityDispatcher(const std::shared_ptr<ActivityDispatcher> &dispatcher)
+{
+       activityDispatcher = dispatcher;
 }

diff --git a/src/SwitchManager.hpp b/src/SwitchManager.hpp
index 4af0f5a..e0cf83c 100644 (file)
--- a/src/SwitchManager.hpp
+++ b/src/SwitchManager.hpp
@@ -4,43 +4,50 @@
 #include "SwitchConfigurationItemObserver.hpp"
 #include "SwitchObserver.hpp"
 #include "SwitchProvider.hpp"
-#include "AsyncActivityConstructor.hpp"
 #include "ActivityDispatcher.hpp"
 #include "Configuration.hpp"
 #include "Condition.hpp"
-#include "ActivityBuilderFactory.hpp"
+#include "ActivityFactory.hpp"
 #include "Activity.hpp"
 
 #include <memory>
 
-class SwitchManager : public SwitchConfigurationItemObserver, public SwitchObserver, public ActivityObserver, public std::enable_shared_from_this<SwitchManager>
+class SwitchManager : public SwitchConfigurationItemObserver, public SwitchObserver, public std::enable_shared_from_this<SwitchManager>
 {
 public:
        void update(const std::shared_ptr<SwitchConfigurationItem> &item) override;
        void update(const std::shared_ptr<Switch> &item) override;
-       void update(const std::shared_ptr<Activity> &item) override;
 
        template<class A>
        static std::shared_ptr<A> create(const std::shared_ptr<SwitchProvider> &provider,
-                                                            const std::shared_ptr<Configuration> &configuration,
-                                                            const std::shared_ptr<ActivityBuilderFactory> &factory) {
-               auto ptr = std::shared_ptr<A>(new A(provider, configuration, factory));
+                                                                        const std::shared_ptr<Configuration> &configuration,
+                                                                        const std::shared_ptr<ActivityFactory> &factory,
+                                                                        const std::shared_ptr<ActivityDispatcher> &dispatcher)
+       {
+               auto ptr = std::shared_ptr<A>(new A(provider, configuration, factory, dispatcher));
                ptr->initialize();
                return ptr;
        }
 
+       void setActivityProvider(const std::shared_ptr<SwitchProvider> &provider);
+       void setConfiguration(const std::shared_ptr<Configuration> &configuration);
+       void setActivityFactory(const std::shared_ptr<ActivityFactory> &factory);
+       void setActivityDispatcher(const std::shared_ptr<ActivityDispatcher> &dispatcher);
+
 protected:
        SwitchManager(const std::shared_ptr<SwitchProvider> &provider,
-                     const std::shared_ptr<Configuration> &configuration,
-                     const std::shared_ptr<ActivityBuilderFactory> &factory);
+                                 const std::shared_ptr<Configuration> &configuration,
+                                 const std::shared_ptr<ActivityFactory> &factory,
+                                 const std::shared_ptr<ActivityDispatcher> &dispatcher);
 
        void initialize();
 
        std::shared_ptr<SwitchProvider> switchProvider;
        std::shared_ptr<Configuration> configuration;
-       std::shared_ptr<ActivityBuilderFactory> activityBuilderFactory;
-       std::shared_ptr<AsyncActivityConstructor> asyncActivityConstructor;
+       std::shared_ptr<ActivityFactory> activityFactory;
        std::shared_ptr<ActivityDispatcher> activityDispatcher;
+
+       std::shared_ptr<Activity> activity;
 };
 
 #endif

diff --git a/src/UIActivity.cpp b/src/UIActivity.cpp
new file mode 100644 (file)
index 0000000..27c93f1
--- /dev/null
+++ b/src/UIActivity.cpp
@@ -0,0 +1,28 @@
+#include "UIActivity.hpp"
+
+#include "ScreenScannerManager.hpp"
+#include "ConditionAll.hpp"
+
+UIActivity::UIActivity(const std::string &type)
+       : Activity(type)
+{
+       auto cond = std::unique_ptr<Condition<UIElement>>(new ConditionAll<UIElement>);
+       ScreenScannerManager::instance().attach(shared_from_this(), std::move(cond));
+}
+
+UIActivity::~UIActivity()
+{
+       ScreenScannerManager::instance().detach(this, nullptr);
+}
+
+bool UIActivity::prepare()
+{
+       ScreenScannerManager::instance().acceptAutoscanning();
+
+       return uiElement != nullptr;
+}
+
+void UIActivity::update(const std::shared_ptr<UIElement> &elem)
+{
+       uiElement = elem;
+}

diff --git a/src/UIActivity.hpp b/src/UIActivity.hpp
new file mode 100644 (file)
index 0000000..3c7b9f2
--- /dev/null
+++ b/src/UIActivity.hpp
@@ -0,0 +1,23 @@
+#ifndef UI_ACTIVITY_HPP
+#define UI_ACTIVITY_HPP
+
+#include "Activity.hpp"
+#include "UIElementObserver.hpp"
+#include "UIElement.hpp"
+
+#include <memory>
+
+class UIActivity : public Activity, public UIElementObserver, public std::enable_shared_from_this<UIActivity>
+{
+public:
+       UIActivity(const std::string &type);
+       ~UIActivity();
+       bool prepare() override;
+
+       void update(const std::shared_ptr<UIElement> &elem) override;
+
+private:
+       std::shared_ptr<UIElement> uiElement;
+};
+
+#endif

diff --git a/src/UIElement.cpp b/src/UIElement.cpp
index afb6937..bd02c0b 100644 (file)
--- a/src/UIElement.cpp
+++ b/src/UIElement.cpp
@@ -1,13 +1,16 @@
 #include "UIElement.hpp"
 
-int32_t UIElement::getX() {
+int32_t UIElement::getX()
+{
        return x;
 }
 
-int32_t UIElement::getY() {
+int32_t UIElement::getY()
+{
        return y;
 }
 
-std::shared_ptr<AtspiAccessible> UIElement::getObject() {
+std::shared_ptr<AtspiAccessible> UIElement::getObject()
+{
        return obj;
 }

diff --git a/src/UIElementObserver.hpp b/src/UIElementObserver.hpp
index 487a8f9..06f75b2 100644 (file)
--- a/src/UIElementObserver.hpp
+++ b/src/UIElementObserver.hpp
@@ -7,7 +7,7 @@
 class UIElementObserver : public Observer<UIElement>
 {
 public:
-       virtual ~UIElementObserver();
+       virtual ~UIElementObserver() = default;
 };
 
 #endif

diff --git a/src/universalswitch.cpp b/src/universalswitch.cpp
index 4ba8dcf..0e607ff 100644 (file)
--- a/src/universalswitch.cpp
+++ b/src/universalswitch.cpp
@@ -8,20 +8,20 @@
 
 bool service_app_create(void *data)
 {
-    // Todo: add your code here.
-    return true;
+       // Todo: add your code here.
+       return true;
 }
 
 void service_app_terminate(void *data)
 {
-    // Todo: add your code here.
-    return;
+       // Todo: add your code here.
+       return;
 }
 
 void service_app_control(app_control_h app_control, void *data)
 {
-    // Todo: add your code here.
-    return;
+       // Todo: add your code here.
+       return;
 }
 
 static void
@@ -49,7 +49,7 @@ service_app_low_memory(app_event_info_h event_info, void *user_data)
        /*APP_EVENT_LOW_MEMORY*/
 }
 
-int main(int argc, char* argv[])
+int main(int argc, char *argv[])
 {
        DEBUG("main function called");
        char ad[50] = {0,};

diff --git a/tests/ActivityDispatchingTests.cpp b/tests/ActivityDispatchingTests.cpp
new file mode 100644 (file)
index 0000000..b6db195
--- /dev/null
+++ b/tests/ActivityDispatchingTests.cpp
@@ -0,0 +1,34 @@
+#include "ActivityDispatchingTests.hpp"
+
+#include "ActivityFactory.hpp"
+
+#include <cassert>
+
+TEST_F(ActivityDispatchingFixture, FactoryWorks)
+{
+       EXPECT_TRUE(ActivityFactory::getInstance()->getActivity(activityType_));
+}
+
+TEST_F(ActivityDispatchingFixture, ActivityNotPrepared)
+{
+       initialEnvironmentExpect();
+       EXPECT_EQ(adHocActivityDispatcher_->updatedWithActivity, 0);
+}
+
+TEST_F(ActivityDispatchingFixture, ActivityReady)
+{
+       initialEnvironmentExpect();
+       EXPECT_EQ(adHocActivityDispatcher_->updatedWithActivity, 0);
+       simulateKeyDown(keyMappedToSelectActivity_);
+       EXPECT_EQ(adHocActivityDispatcher_->updatedWithActivity, 1);
+}
+
+TEST_F(ActivityDispatchingFixture, ActivityAbandoned)
+{
+       initialEnvironmentExpect();
+       EXPECT_EQ(adHocActivityDispatcher_->updatedWithActivity, 0);
+       simulateKeyDown(keyNotMappedToSelectActivity_);
+       EXPECT_EQ(adHocActivityDispatcher_->updatedWithActivity, 0);
+       simulateKeyDown(keyMappedToSelectActivity_);
+       EXPECT_EQ(adHocActivityDispatcher_->updatedWithActivity, 0);
+}

diff --git a/tests/ActivityDispatchingTests.hpp b/tests/ActivityDispatchingTests.hpp
new file mode 100644 (file)
index 0000000..4878bf5
--- /dev/null
+++ b/tests/ActivityDispatchingTests.hpp
@@ -0,0 +1,51 @@
+#include "ConfigurationTests.hpp"
+
+#include "AdHocActivityDispatcher.hpp"
+
+class AdHocActivityDispatcher_ActivityDispatchingTest : public AdHocActivityDispatcher
+{
+public:
+       void dispatch(std::shared_ptr<Activity> activity) override
+       {
+               AdHocActivityDispatcher::dispatch(activity);
+               ++updatedWithActivity;
+       }
+
+       int updatedWithActivity = 0;
+};
+
+class ActivityDispatchingFixture : public ConfigurationTestsFixture
+{
+public:
+       void SetUp()
+       {
+               ConfigurationTestsFixture::SetUp();
+               configuration_->add(item_);
+
+               auto newSwitch = switchProvider_->findSwitchById(newSwitchId_);
+               auto newItem = std::make_shared<SwitchConfigurationItem>(newSwitch->getId()->getGlobalId(), newActivityType_);
+               configuration_->add(newItem);
+
+               adHocActivityDispatcher_ = std::make_shared<AdHocActivityDispatcher_ActivityDispatchingTest>();
+               switchManager_ = SwitchManager::create<SwitchManager_ConfigurationTests>(switchProvider_, configuration_, activityFactory_, adHocActivityDispatcher_);
+       }
+
+       void TearDown()
+       {
+               ConfigurationTestsFixture::TearDown();
+       }
+
+       void initialEnvironmentExpect()
+       {
+               simulateKeyDown(keyMappedToSelectActivity_);
+               EXPECT_EQ(switchManager_->updatedWithSwitch, 1);
+       }
+
+protected:
+       std::shared_ptr<AdHocActivityDispatcher_ActivityDispatchingTest> adHocActivityDispatcher_;
+       std::shared_ptr<SwitchManager_ConfigurationTests> switchManager_;
+       std::string keyMappedToSelectActivity_ = "Down";
+       std::string keyNotMappedToSelectActivity_ = "Up";
+       std::string newSwitchId_ = "AccessoriesSwitchProvider_Up";
+       std::string newActivityType_ = "SCAN_OFF";
+};

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 06c91cc..809da3f 100644 (file)
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -18,3 +18,4 @@ FUNCTION(CREATE_TEST_FROM_SOURCE TEST_SRC_FILE)
 ENDFUNCTION(CREATE_TEST_FROM_SOURCE)
 
 CREATE_TEST_FROM_SOURCE(ConfigurationTests.cpp)
+CREATE_TEST_FROM_SOURCE(ActivityDispatchingTests.cpp)

diff --git a/tests/ConfigurationTests.cpp b/tests/ConfigurationTests.cpp
index 802702d..c2a64f1 100644 (file)
--- a/tests/ConfigurationTests.cpp
+++ b/tests/ConfigurationTests.cpp
@@ -1,40 +1,44 @@
 #include "ConfigurationTests.hpp"
 
-TEST_F(ConfigurationFixture, ConfigurationNotEmpty_BeUpdatedOnEvent) {
+TEST_F(ConfigurationTestsFixture, ConfigurationNotEmpty_BeUpdatedOnEvent)
+{
        configuration_->add(item_);
 
-       auto switchManager = SwitchManager::create<SwitchManagerMocked>(switchProvider_, configuration_, nullptr);
-       simulateKeyDown();
+       auto switchManager = SwitchManager::create<SwitchManager_ConfigurationTests>(switchProvider_, configuration_, activityFactory_, nullptr);
+       simulateKeyDown(key_);
 
        EXPECT_EQ(switchManager->updatedWithSwitch, 1);
        EXPECT_EQ(switchManager->receivedItem->getId()->getGlobalId(), switchId_);
 }
 
-TEST_F(ConfigurationFixture, ConfigurationEmpty_MappingAdded_BeUpdatedOnEvent) {
-       auto switchManager = SwitchManager::create<SwitchManagerMocked>(switchProvider_, configuration_, nullptr);
+TEST_F(ConfigurationTestsFixture, ConfigurationEmpty_MappingAdded_BeUpdatedOnEvent)
+{
+       auto switchManager = SwitchManager::create<SwitchManager_ConfigurationTests>(switchProvider_, configuration_, activityFactory_, nullptr);
        configuration_->add(item_);
-       simulateKeyDown();
+       simulateKeyDown(key_);
 
        EXPECT_EQ(switchManager->updatedWithSwitch, 1);
        EXPECT_EQ(switchManager->receivedItem->getId()->getGlobalId(), switchId_);
 }
 
-TEST_F(ConfigurationFixture, MappingAddedAndRemoved_BeNotUpdatedOnEvent) {
+TEST_F(ConfigurationTestsFixture, MappingAddedAndRemoved_BeNotUpdatedOnEvent)
+{
        configuration_->add(item_);
-       auto switchManager = SwitchManager::create<SwitchManagerMocked>(switchProvider_, configuration_, nullptr);
+       auto switchManager = SwitchManager::create<SwitchManager_ConfigurationTests>(switchProvider_, configuration_, activityFactory_, nullptr);
        configuration_->remove(switchId_);
-       simulateKeyDown();
+       simulateKeyDown(key_);
 
        EXPECT_EQ(switchManager->updatedWithSwitch, 0);
 }
 
-TEST_F(ConfigurationFixture, MappingAddedAndUpdated_BeUpdatedWithNewValue) {
+TEST_F(ConfigurationTestsFixture, MappingAddedAndUpdated_BeUpdatedWithNewValue)
+{
        configuration_->add(item_);
-       auto switchManager = SwitchManager::create<SwitchManagerMocked>(switchProvider_, configuration_, nullptr);
+       auto switchManager = SwitchManager::create<SwitchManager_ConfigurationTests>(switchProvider_, configuration_, activityFactory_, nullptr);
        auto newActivityType = "SCAN_OFF";
        auto newItem = std::make_shared<SwitchConfigurationItem>(switch_->getId()->getGlobalId(), newActivityType);
        configuration_->update(newItem);
-       simulateKeyDown();
+       simulateKeyDown(key_);
 
        EXPECT_EQ(switchManager->updatedWithSwitch, 1);
        EXPECT_EQ(switchManager->receivedItem->getId()->getGlobalId(), switchId_);

diff --git a/tests/ConfigurationTests.hpp b/tests/ConfigurationTests.hpp
index 2d6de5c..bcf6287 100644 (file)
--- a/tests/ConfigurationTests.hpp
+++ b/tests/ConfigurationTests.hpp
@@ -18,24 +18,29 @@ using ::testing::SetArgPointee;
 using ::testing::StrEq;
 using ::testing::_;
 
-class ConfigurationFixture : public ::testing::Test {
+class ConfigurationTestsFixture : public ::testing::Test
+{
 public:
-       void SetUp() {
+       void SetUp()
+       {
                EXPECT_TRUE(ecore_init());
                EXPECT_TRUE(ecore_event_init());
                configuration_ = std::make_shared<SQLiteConfiguration>(true);
                switchProvider_ = std::make_shared<AccessoriesSwitchProvider>();
+               activityFactory_ = ActivityFactory::getInstance();
                switch_ = switchProvider_->findSwitchById(switchId_);
                item_ = std::make_shared<SwitchConfigurationItem>(switch_->getId()->getGlobalId(), activityType_);
        }
 
-       void TearDown() {
+       void TearDown()
+       {
                ecore_event_shutdown();
                ecore_shutdown();
        }
 
-       void simulateKeyDown() {
-               Ecore_Event_Key *event = (Ecore_Event_Key*)malloc(sizeof(Ecore_Event_Key));
+       void simulateKeyDown(const std::string &key)
+       {
+               Ecore_Event_Key *event = (Ecore_Event_Key *)malloc(sizeof(Ecore_Event_Key));
                event->key = key.c_str();
                EXPECT_TRUE(ecore_event_add(ECORE_EVENT_KEY_DOWN, event, NULL, NULL));
                ecore_main_loop_iterate();
@@ -44,23 +49,27 @@ public:
 protected:
        std::shared_ptr<Configuration> configuration_;
        std::shared_ptr<SwitchProvider> switchProvider_;
+       std::shared_ptr<ActivityFactory> activityFactory_;
        std::shared_ptr<Switch> switch_;
        std::shared_ptr<SwitchConfigurationItem> item_;
-       std::string key = "Down";
+       std::string key_ = "Down";
        std::string switchId_ = "AccessoriesSwitchProvider_Down";
        std::string activityType_ = "SELECT";
 };
 
-class SwitchManagerMocked : public SwitchManager {
+class SwitchManager_ConfigurationTests : public SwitchManager
+{
 public:
 
-       SwitchManagerMocked(const std::shared_ptr<SwitchProvider> &provider,
-                     const std::shared_ptr<Configuration> &configuration,
-                     const std::shared_ptr<ActivityBuilderFactory> &factory)
-               : SwitchManager(provider, configuration, factory)
+       SwitchManager_ConfigurationTests(const std::shared_ptr<SwitchProvider> &provider,
+                                                                        const std::shared_ptr<Configuration> &configuration,
+                                                                        const std::shared_ptr<ActivityFactory> &factory,
+                                                                        const std::shared_ptr<ActivityDispatcher> &dispatcher)
+               : SwitchManager(provider, configuration, factory, dispatcher)
        {}
 
-       void update(const std::shared_ptr<Switch> &item) override {
+       void update(const std::shared_ptr<Switch> &item) override
+       {
                SwitchManager::update(item);
                receivedItem = item;
                ++updatedWithSwitch;