diff --git a/include/f1x/openauto/autoapp/USB/USBMain.hpp b/include/f1x/openauto/autoapp/USB/USBMain.hpp
index 481d84b..32f7977 100644
--- a/include/f1x/openauto/autoapp/USB/USBMain.hpp
+++ b/include/f1x/openauto/autoapp/USB/USBMain.hpp
@@ -18,7 +18,6 @@
 
 #pragma once
 
-#include <thread>
 #include <f1x/aasdk/USB/USBWrapper.hpp>
 #include <f1x/aasdk/USB/AccessoryModeQueryChain.hpp>
 #include <f1x/aasdk/USB/AccessoryModeQueryChainFactory.hpp>
@@ -28,6 +27,8 @@
 #include <f1x/openauto/autoapp/Projection/AndroidAutoEntityFactory.hpp>
 #include <f1x/openauto/autoapp/Projection/ServiceFactory.hpp>
 
+class QApplication;
+
 namespace f1x
 {
 namespace openauto
@@ -40,26 +41,19 @@ namespace usb
 class USBMain
 {
 public:
-    USBMain(libusb_context* context);
+    USBMain(aasdk::usb::IUSBWrapper& usbWrapper, boost::asio::io_service& ioService, configuration::IConfiguration::Pointer configuration);
 
-    int exec(int argc, char* argv[]);
+    void start();
+    void stop();
 
 private:
-    typedef std::vector<std::thread> ThreadPool;
-
-    void startUSBWorkers();
-    void startIOServiceWorkers();
-
-    libusb_context* usbContext_;
-    aasdk::usb::USBWrapper usbWrapper_;
-    boost::asio::io_service ioService_;
+    aasdk::usb::IUSBWrapper& usbWrapper_;
+    boost::asio::io_service& ioService_;
     aasdk::usb::AccessoryModeQueryFactory queryFactory_;
     aasdk::usb::AccessoryModeQueryChainFactory queryChainFactory_;
-    configuration::IConfiguration::Pointer configuration_;
     projection::ServiceFactory serviceFactory_;
     projection::AndroidAutoEntityFactory androidAutoEntityFactory_;
     autoapp::usb::USBApp::Pointer usbApp_;
-    ThreadPool threadPool_;
 };
 
 }
diff --git a/src/autoapp/Main.cpp b/src/autoapp/Main.cpp
index 0f7783a..e5de25d 100644
--- a/src/autoapp/Main.cpp
+++ b/src/autoapp/Main.cpp
@@ -16,24 +16,89 @@
 *  along with openauto. If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <thread>
+#include <QApplication>
+#include <f1x/openauto/autoapp/Configuration/Configuration.hpp>
+#include <f1x/openauto/autoapp/UI/MainWindow.hpp>
+#include <f1x/openauto/autoapp/UI/SettingsWindow.hpp>
 #include <f1x/openauto/autoapp/USB/USBMain.hpp>
 #include <f1x/openauto/Common/Log.hpp>
 
 namespace aasdk = f1x::aasdk;
 namespace autoapp = f1x::openauto::autoapp;
+using ThreadPool = std::vector<std::thread>;
+
+void startUSBWorkers(boost::asio::io_service& ioService, libusb_context* usbContext, ThreadPool& threadPool)
+{
+    auto usbWorker = [&ioService, usbContext]() {
+        timeval libusbEventTimeout{180, 0};
+
+        while(!ioService.stopped())
+        {
+            libusb_handle_events_timeout_completed(usbContext, &libusbEventTimeout, nullptr);
+        }
+    };
+
+    threadPool.emplace_back(usbWorker);
+    threadPool.emplace_back(usbWorker);
+    threadPool.emplace_back(usbWorker);
+    threadPool.emplace_back(usbWorker);
+}
+
+void startIOServiceWorkers(boost::asio::io_service& ioService, ThreadPool& threadPool)
+{
+    auto ioServiceWorker = [&ioService]() {
+        ioService.run();
+    };
+
+    threadPool.emplace_back(ioServiceWorker);
+    threadPool.emplace_back(ioServiceWorker);
+    threadPool.emplace_back(ioServiceWorker);
+    threadPool.emplace_back(ioServiceWorker);
+}
 
 int main(int argc, char* argv[])
 {
-    libusb_context* context;
-    if(libusb_init(&context) != 0)
+    libusb_context* usbContext;
+    if(libusb_init(&usbContext) != 0)
     {
         OPENAUTO_LOG(error) << "[OpenAuto] libusb init failed.";
         return 1;
     }
 
-    autoapp::usb::USBMain main(context);
-    auto result = main.exec(argc, argv);
+    QApplication qApplication(argc, argv);
+    boost::asio::io_service ioService;
+    boost::asio::io_service::work work(ioService);
 
-    libusb_exit(context);
+    autoapp::ui::MainWindow mainWindow;
+    //mainWindow.setWindowFlags(Qt::WindowStaysOnTopHint);
+    mainWindow.showFullScreen();
+
+    auto configuration = std::make_shared<autoapp::configuration::Configuration>();
+    autoapp::ui::SettingsWindow settingsWindow(configuration);
+    //settingsWindow.setWindowFlags(Qt::WindowStaysOnTopHint);
+
+    qApplication.setOverrideCursor(Qt::BlankCursor);
+    bool cursorVisible = false;
+    QObject::connect(&mainWindow, &autoapp::ui::MainWindow::toggleCursor, [&cursorVisible, &qApplication]() {
+        cursorVisible = !cursorVisible;
+        qApplication.setOverrideCursor(cursorVisible ? Qt::ArrowCursor : Qt::BlankCursor);
+    });
+
+    aasdk::usb::USBWrapper usbWrapper(usbContext);
+    autoapp::usb::USBMain main(usbWrapper, ioService, configuration);
+
+    QObject::connect(&mainWindow, &autoapp::ui::MainWindow::exit, []() { std::exit(0); });
+    QObject::connect(&mainWindow, &autoapp::ui::MainWindow::openSettings, &settingsWindow, &autoapp::ui::SettingsWindow::showFullScreen);
+
+    std::vector<std::thread> threadPool;
+    startUSBWorkers(ioService, usbContext, threadPool);
+    startIOServiceWorkers(ioService, threadPool);
+    main.start();
+
+    auto result = qApplication.exec();
+    std::for_each(threadPool.begin(), threadPool.end(), std::bind(&std::thread::join, std::placeholders::_1));
+
+    libusb_exit(usbContext);
     return result;
 }
diff --git a/src/autoapp/USB/USBMain.cpp b/src/autoapp/USB/USBMain.cpp
index 6c3602f..b4ddb2e 100644
--- a/src/autoapp/USB/USBMain.cpp
+++ b/src/autoapp/USB/USBMain.cpp
@@ -17,12 +17,8 @@
 */
 
 #include <QApplication>
-#include <QMainWindow>
 #include <f1x/aasdk/USB/USBHub.hpp>
 #include <f1x/aasdk/USB/ConnectedAccessoriesEnumerator.hpp>
-#include <f1x/openauto/autoapp/Configuration/Configuration.hpp>
-#include <f1x/openauto/autoapp/UI/MainWindow.hpp>
-#include <f1x/openauto/autoapp/UI/SettingsWindow.hpp>
 #include <f1x/openauto/autoapp/USB/USBMain.hpp>
 
 namespace f1x
@@ -34,14 +30,13 @@ namespace autoapp
 namespace usb
 {
 
-USBMain::USBMain(libusb_context* context)
-    : usbContext_(context)
-    , usbWrapper_(usbContext_)
+USBMain::USBMain(aasdk::usb::IUSBWrapper& usbWrapper, boost::asio::io_service& ioService, configuration::IConfiguration::Pointer configuration)
+    : usbWrapper_(usbWrapper)
+    , ioService_(ioService)
     , queryFactory_(usbWrapper_, ioService_)
     , queryChainFactory_(usbWrapper_, ioService_, queryFactory_)
-    , configuration_(std::make_shared<configuration::Configuration>())
-    , serviceFactory_(ioService_, configuration_)
-    , androidAutoEntityFactory_(usbWrapper_, ioService_, configuration_, serviceFactory_)
+    , serviceFactory_(ioService_, configuration)
+    , androidAutoEntityFactory_(usbWrapper_, ioService_, configuration, serviceFactory_)
 {
     auto usbHub(std::make_shared<aasdk::usb::USBHub>(usbWrapper_, ioService_, queryChainFactory_));
     auto ConnectedAccessoriesEnumerator(std::make_shared<aasdk::usb::ConnectedAccessoriesEnumerator>(usbWrapper_, ioService_, queryChainFactory_));
@@ -50,66 +45,14 @@ USBMain::USBMain(libusb_context* context)
                                                      std::move(usbHub), std::move(ConnectedAccessoriesEnumerator));
 }
 
-int USBMain::exec(int argc, char* argv[])
+void USBMain::start()
 {
-    QApplication qApplication(argc, argv);
-
-    ui::MainWindow mainWindow;
-    mainWindow.setWindowFlags(Qt::WindowStaysOnTopHint);
-
-    ui::SettingsWindow settingsWindow(configuration_);
-    settingsWindow.setWindowFlags(Qt::WindowStaysOnTopHint);
-
-    QObject::connect(&mainWindow, &ui::MainWindow::exit, []() { std::exit(0); });
-    QObject::connect(&mainWindow, &ui::MainWindow::openSettings, &settingsWindow, &ui::SettingsWindow::showFullScreen);
-
-    qApplication.setOverrideCursor(Qt::BlankCursor);
-    bool cursorVisible = false;
-    QObject::connect(&mainWindow, &ui::MainWindow::toggleCursor, [&cursorVisible, &qApplication]() {
-        cursorVisible = !cursorVisible;
-        qApplication.setOverrideCursor(cursorVisible ? Qt::ArrowCursor : Qt::BlankCursor);
-    });
-
-    mainWindow.showFullScreen();
-
-    boost::asio::io_service::work work(ioService_);
-    this->startIOServiceWorkers();
-    this->startUSBWorkers();
     usbApp_->start();
-
-    auto result = qApplication.exec();
-    std::for_each(threadPool_.begin(), threadPool_.end(), std::bind(&std::thread::join, std::placeholders::_1));
-    return result;
 }
 
-void USBMain::startUSBWorkers()
+void USBMain::stop()
 {
-    auto usbWorker = [this]() {
-        timeval libusbEventTimeout{180, 0};
-
-        while(!ioService_.stopped())
-        {
-            libusb_handle_events_timeout_completed(usbContext_, &libusbEventTimeout, nullptr);
-        }
-    };
-    threadPool_.emplace_back(usbWorker);
-    threadPool_.emplace_back(usbWorker);
-    threadPool_.emplace_back(usbWorker);
-    threadPool_.emplace_back(usbWorker);
-}
-
-void USBMain::startIOServiceWorkers()
-{
-    auto ioServiceWorker = [this]() {
-        while(!ioService_.stopped())
-        {
-            ioService_.run();
-        }
-    };
-    threadPool_.emplace_back(ioServiceWorker);
-    threadPool_.emplace_back(ioServiceWorker);
-    threadPool_.emplace_back(ioServiceWorker);
-    threadPool_.emplace_back(ioServiceWorker);
+    usbApp_->stop();
 }
 
 }