From 8b371b3121825af744e7747799763032783f1230 Mon Sep 17 00:00:00 2001
From: silverchris <silverchris@gmail.com>
Date: Thu, 4 Aug 2022 21:21:22 -0400
Subject: [PATCH] Remove dependency on sigc++ for video focus requests and
 events.

---
 include/autoapp/Managers/AAPA.hpp             | 26 +++++++---------
 include/autoapp/Managers/HttpManager.hpp      |  4 +--
 include/autoapp/Managers/IVideoManager.hpp    | 30 +++++++++++++++++++
 include/autoapp/Managers/VideoManager.hpp     | 13 ++++----
 include/autoapp/Projection/GSTVideoOutput.hpp |  1 -
 include/autoapp/Projection/InputDevice.hpp    |  4 +--
 include/autoapp/Service/VideoService.hpp      |  9 +++---
 include/autoapp/Signals/Signals.hpp           | 12 +++++---
 include/autoapp/Signals/VideoSignals.hpp      | 19 ------------
 src/autoapp/Managers/AAPA.cpp                 | 23 ++++++--------
 src/autoapp/Managers/HttpManager.cpp          |  8 ++---
 src/autoapp/Managers/VideoManager.cpp         | 21 ++++---------
 src/autoapp/Projection/InputDevice.cpp        | 10 +++----
 src/autoapp/Service/ServiceFactory.cpp        |  4 +--
 src/autoapp/Service/VideoService.cpp          | 16 +++++-----
 src/autoapp/autoapp.cpp                       | 26 +++++++---------
 16 files changed, 107 insertions(+), 119 deletions(-)
 create mode 100644 include/autoapp/Managers/IVideoManager.hpp
 delete mode 100644 include/autoapp/Signals/VideoSignals.hpp

diff --git a/include/autoapp/Managers/AAPA.hpp b/include/autoapp/Managers/AAPA.hpp
index 7f99bf72..986fe06a 100644
--- a/include/autoapp/Managers/AAPA.hpp
+++ b/include/autoapp/Managers/AAPA.hpp
@@ -4,20 +4,19 @@
 
 #include <atomic>
 #include <set>
+#include <autoapp/Managers/IVideoManager.hpp>
 #include <autoapp/Service/VideoService.hpp>
-#include <autoapp/Signals/VideoSignals.hpp>
 #include <autoapp/Signals/AASignals.hpp>
 
 #include <com_jci_aapa_objectAdapter.h>
 #include <com_jci_bucpsa_objectProxy.h>
 
-
 class AADBus : public com_jci_aapa {
  private:
-  VideoSignals::Pointer vs;
+  std::function<void(bool)> focusChanged;
 
  public:
-  explicit AADBus(VideoSignals::Pointer videosignals);
+  explicit AADBus(std::function<void(bool)> FocusChanged);
 
   typedef DBus::MultipleReturn<std::tuple<uint8_t, std::string, std::string, std::string, std::string>,
                                int32_t> NowPlayingInfo;
@@ -42,13 +41,9 @@ class AADBus : public com_jci_aapa {
 
 };
 
-class AAPA {
+class AAPA : public IVideoManager {
  private:
-  VideoSignals::Pointer vs;
   AASignals::Pointer as;
-  sigc::connection requestFocusConnection;
-  sigc::connection releaseFocusConnection;
-  sigc::connection FocusChangeConnection;
   sigc::connection ConnectedConnection;
   std::shared_ptr<com_jci_aapa_objectAdapter> session_object;
   std::shared_ptr<com_jci_aapaInterface> adapter;
@@ -56,15 +51,14 @@ class AAPA {
   std::shared_ptr<com_jci_bucpsa_objectProxy> bucpsa;
   bool _connected = false;
 
+  void DisplayMode(uint32_t DisplayMode);
+  void AAConnected(bool connected);
 
  public:
-  explicit AAPA(VideoSignals::Pointer videosignals, AASignals::Pointer aasignals,
+  explicit AAPA(AASignals::Pointer aasignals,
                 const std::shared_ptr<DBus::Connection> &session_connection);
   ~AAPA();
 
-  void requestFocus();
-  void releaseFocus();
-
-  void DisplayMode(uint32_t DisplayMode);
-  void AAConnected(bool connected);
-  };
\ No newline at end of file
+  void requestFocus() override;
+  void releaseFocus() override;
+};
\ No newline at end of file
diff --git a/include/autoapp/Managers/HttpManager.hpp b/include/autoapp/Managers/HttpManager.hpp
index 265a700c..2484799c 100644
--- a/include/autoapp/Managers/HttpManager.hpp
+++ b/include/autoapp/Managers/HttpManager.hpp
@@ -16,13 +16,13 @@ using HttpServer = SimpleWeb::Server<SimpleWeb::HTTP>;
 
 class HttpManager {
  public:
-  HttpManager(VideoSignals::Pointer videosignals, AASignals::Pointer aasignals);
+  HttpManager(IVideoManager::Pointer videosignals, AASignals::Pointer aasignals);
   ~HttpManager();
  private:
   bool has_video_focus = false;
   bool has_audio_focus = false;
   bool aa_connected = false;
-  VideoSignals::Pointer videosignals_;
+  IVideoManager::Pointer videoManager;
   AASignals::Pointer aasignals_;
   HttpServer server;
   std::thread serverThread;
diff --git a/include/autoapp/Managers/IVideoManager.hpp b/include/autoapp/Managers/IVideoManager.hpp
new file mode 100644
index 00000000..e5f110ad
--- /dev/null
+++ b/include/autoapp/Managers/IVideoManager.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <dbus-cxx.h>
+
+class IVideoManager {
+ public:
+  using Pointer = std::shared_ptr<IVideoManager>;
+  using focusCallback = std::function<void(bool)>;
+
+ private:
+  std::vector<focusCallback> focusCallbacks;
+
+ public:
+  IVideoManager() = default;
+  virtual ~IVideoManager() = default;
+
+  virtual void requestFocus() = 0;
+  virtual void releaseFocus() = 0;
+
+  void registerFocus(const focusCallback &callback) {
+    focusCallbacks.emplace_back(callback);
+  };
+
+  void focusChanged(bool hasFocus) {
+    for (auto &callback : focusCallbacks) {
+      callback(hasFocus);
+    }
+  }
+
+};
\ No newline at end of file
diff --git a/include/autoapp/Managers/VideoManager.hpp b/include/autoapp/Managers/VideoManager.hpp
index 24751d37..1d7a8a8b 100644
--- a/include/autoapp/Managers/VideoManager.hpp
+++ b/include/autoapp/Managers/VideoManager.hpp
@@ -4,30 +4,27 @@
 
 #include <atomic>
 #include <set>
+#include <autoapp/Managers/IVideoManager.hpp>
 #include <autoapp/Service/VideoService.hpp>
-#include <autoapp/Signals/VideoSignals.hpp>
 
 #include <com_jci_nativeguictrl_objectProxy.h>
 #include <com_jci_bucpsa_objectProxy.h>
 
-class VideoManager {
+class VideoManager: public IVideoManager{
  private:
   std::shared_ptr<com_jci_bucpsa_objectProxy> bucpsa;
-  VideoSignals::Pointer vs;
   bool waitsForFocus = false;
-  sigc::connection requestFocusConnection;
-  sigc::connection releaseFocusConnection;
   bool currentDisplayMode;
   bool hasFocus = false;
   std::shared_ptr<com_jci_nativeguictrl_objectProxy> gui;
   void DisplayMode(uint32_t);
 
  public:
-  explicit VideoManager(VideoSignals::Pointer videosignals, const std::shared_ptr<DBus::Connection> &);
+  explicit VideoManager(const std::shared_ptr<DBus::Connection> &);
   ~VideoManager();
 
-  void requestFocus();
-  void releaseFocus();
+  void requestFocus() override;
+  void releaseFocus() override;
 
   enum SURFACES {
     NNG_NAVI_ID = 0,
diff --git a/include/autoapp/Projection/GSTVideoOutput.hpp b/include/autoapp/Projection/GSTVideoOutput.hpp
index 6058e823..0f86bea2 100644
--- a/include/autoapp/Projection/GSTVideoOutput.hpp
+++ b/include/autoapp/Projection/GSTVideoOutput.hpp
@@ -4,7 +4,6 @@
 #include <autoapp/Projection/IVideoOutput.hpp>
 #include <thread>
 #include <asio.hpp>
-#include <autoapp/Signals/VideoSignals.hpp>
 
 
 
diff --git a/include/autoapp/Projection/InputDevice.hpp b/include/autoapp/Projection/InputDevice.hpp
index fa1ead7c..cf0b649d 100644
--- a/include/autoapp/Projection/InputDevice.hpp
+++ b/include/autoapp/Projection/InputDevice.hpp
@@ -42,7 +42,7 @@ namespace autoapp::projection {
 class InputDevice : public IInputDevice {
 
  public:
-  InputDevice(asio::io_service &ioService, AudioSignals::Pointer audiosignals, VideoSignals::Pointer videosignals);
+  InputDevice(asio::io_service &ioService, AudioSignals::Pointer audiosignals, IVideoManager::Pointer videosignals);
 
   void start(IInputDeviceEventHandler &eventHandler) override;
 
@@ -58,7 +58,7 @@ class InputDevice : public IInputDevice {
   asio::basic_waitable_timer<std::chrono::steady_clock> timer_;
   asio::io_service::strand strand_;
   AudioSignals::Pointer audiosignals_;
-  VideoSignals::Pointer videosignals_;
+  IVideoManager::Pointer videoManger;
   IInputDeviceEventHandler *eventHandler_;
   std::mutex mutex_;
   int touch_fd = -1, kbd_fd = -1;
diff --git a/include/autoapp/Service/VideoService.hpp b/include/autoapp/Service/VideoService.hpp
index 6f0fab24..9b9dbd76 100644
--- a/include/autoapp/Service/VideoService.hpp
+++ b/include/autoapp/Service/VideoService.hpp
@@ -23,8 +23,9 @@
 #include <aasdk/Channel/AV/IVideoServiceChannelEventHandler.hpp>
 #include <autoapp/Projection/IVideoOutput.hpp>
 #include <autoapp/Service/IService.hpp>
-#include <autoapp/Signals/VideoSignals.hpp>
 #include <autoapp/Managers/VideoManager.hpp>
+#include <autoapp/Managers/IVideoManager.hpp>
+
 
 namespace autoapp::service {
 
@@ -38,7 +39,7 @@ class VideoService
   VideoService(asio::io_service &ioService,
                aasdk::messenger::IMessenger::Pointer messenger,
                projection::IVideoOutput::Pointer videoOutput,
-               VideoSignals::Pointer videoSignals);
+               IVideoManager::Pointer VideoManager);
 
   ~VideoService() noexcept override;
 
@@ -63,13 +64,13 @@ class VideoService
   void sendVideoFocusIndication();
   void sendVideoFocusLost();
 
-  VideoSignals::Pointer videoSignals_;
-
   asio::io_service::strand strand_;
   aasdk::channel::av::VideoServiceChannel::Pointer channel_;
   projection::IVideoOutput::Pointer videoOutput_;
   int32_t session_;
   sigc::connection focusChanged;
+  IVideoManager::Pointer videoManager;
+
 };
 
 }
diff --git a/include/autoapp/Signals/Signals.hpp b/include/autoapp/Signals/Signals.hpp
index 7a241492..c88117eb 100644
--- a/include/autoapp/Signals/Signals.hpp
+++ b/include/autoapp/Signals/Signals.hpp
@@ -1,23 +1,27 @@
 #pragma once
 
 #include <memory>
+#include <utility>
 #include <sigc++/sigc++.h>
 
-#include "VideoSignals.hpp"
 #include "AudioSignals.hpp"
 #include "GpsSignals.hpp"
 #include "AASignals.hpp"
 #include "NavigationSignals.hpp"
+#include "autoapp/Managers/IVideoManager.hpp"
 
 class Signals : public sigc::trackable {
  public:
   typedef std::shared_ptr<Signals> Pointer;
 
-  VideoSignals::Pointer videoSignals = std::make_shared<VideoSignals>();
+  IVideoManager::Pointer videoManager;
   AudioSignals::Pointer audioSignals = std::make_shared<AudioSignals>();
   GpsSignals::Pointer gpsSignals = std::make_shared<GpsSignals>();
-  AASignals::Pointer aaSignals = std::make_shared<AASignals>();
+  AASignals::Pointer aaSignals;
   NavigationSignals::Pointer navSignals = std::make_shared<NavigationSignals>();
 
-  Signals() = default;
+  explicit Signals(IVideoManager::Pointer VideoManager, AASignals::Pointer AaSignals) : videoManager(std::move(
+      VideoManager)), aaSignals(std::move(AaSignals)) {
+
+  };
 };
\ No newline at end of file
diff --git a/include/autoapp/Signals/VideoSignals.hpp b/include/autoapp/Signals/VideoSignals.hpp
deleted file mode 100644
index 1d801629..00000000
--- a/include/autoapp/Signals/VideoSignals.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <sigc++/sigc++.h>
-
-enum class VIDEO_FOCUS_REQUESTOR : uint8_t {
-  HEADUNIT = 0, // headunit (we) has requested video focus
-  ANDROID_AUTO = 1, // AA phone app has requested video focus
-  BACKUP_CAMERA = 2 // CMU requested screen for backup camera
-};
-
-class VideoSignals : public sigc::trackable {
- public:
-  typedef std::shared_ptr<VideoSignals> Pointer;
-  using type_signal_focus = sigc::signal<void(void)>;
-  type_signal_focus focusRequest;
-  type_signal_focus focusRelease;
-  sigc::signal<void(bool)> focusChanged;
-};
\ No newline at end of file
diff --git a/src/autoapp/Managers/AAPA.cpp b/src/autoapp/Managers/AAPA.cpp
index 2bb0447e..d2e133da 100644
--- a/src/autoapp/Managers/AAPA.cpp
+++ b/src/autoapp/Managers/AAPA.cpp
@@ -3,7 +3,7 @@
 
 #include <utility>
 
-AADBus::AADBus(VideoSignals::Pointer videosignals) : vs(videosignals) {
+AADBus::AADBus(std::function<void(bool)> FocusChanged) : focusChanged(std::move(FocusChanged)) {
 
 }
 
@@ -14,10 +14,10 @@ uint8_t AADBus::GetAvailable() {
 void AADBus::VideoProjectionEventToMD(uint32_t videoProjectionEvent) {
   LOG(DEBUG) << "VideoProjectionEventToMD " << videoProjectionEvent;
   if (videoProjectionEvent == 1) {
-    vs->focusChanged.emit(false);
+    focusChanged(false);
   }
   if (videoProjectionEvent == 4){
-    vs->focusChanged.emit(true);
+    focusChanged(true);
   }
 }
 
@@ -41,12 +41,12 @@ void AADBus::SbnStatus(bool status) {
   LOG(DEBUG) << "SbnStatus " << status;
 }
 
-AAPA::AAPA(VideoSignals::Pointer videosignals, AASignals::Pointer aasignals,
+AAPA::AAPA(AASignals::Pointer aasignals,
            const std::shared_ptr<DBus::Connection> &session_connection) :
-    vs(std::move(videosignals)), as(std::move(aasignals)) {
+    as(std::move(aasignals)) {
   session_connection->request_name("com.jci.aapa", DBUSCXX_NAME_FLAG_REPLACE_EXISTING);
 
-  androiddbus = new AADBus(vs);
+  androiddbus = new AADBus([this](bool focus){this->focusChanged(focus);});
 
   adapter = com_jci_aapaInterface::create(androiddbus);
 
@@ -54,8 +54,6 @@ AAPA::AAPA(VideoSignals::Pointer videosignals, AASignals::Pointer aasignals,
 
   adapter->signal_Available()->emit(1);
 
-  releaseFocusConnection = vs->focusRelease.connect(sigc::mem_fun(*this, &AAPA::releaseFocus));
-  requestFocusConnection = vs->focusRequest.connect(sigc::mem_fun(*this, &AAPA::requestFocus));
   ConnectedConnection = as->connected.connect(sigc::mem_fun(*this, &AAPA::AAConnected));
 
 
@@ -67,26 +65,23 @@ AAPA::AAPA(VideoSignals::Pointer videosignals, AASignals::Pointer aasignals,
 void AAPA::DisplayMode(uint32_t DisplayMode) {
 //   currentDisplayMode != 0 means backup camera wants the screen
   if ((bool) DisplayMode && _connected) {
-    vs->focusChanged.emit(false);
+    focusChanged(false);
   }
 }
 
 void AAPA::requestFocus() {
   adapter->signal_VideoProjectionRequestFromMD()->emit(0);
   adapter->signal_ProjectionStatusResult()->emit(true);
-  vs->focusChanged.emit(true);
+  focusChanged(true);
 }
 
 void AAPA::releaseFocus() {
   adapter->signal_VideoProjectionRequestFromMD()->emit(1);
-  vs->focusChanged.emit(false);
+  focusChanged(false);
 }
 
 AAPA::~AAPA() {
   LOG(DEBUG) << "Stopping VideoManager";
-  releaseFocusConnection.disconnect();
-  requestFocusConnection.disconnect();
-  FocusChangeConnection.disconnect();
   ConnectedConnection.disconnect();
   releaseFocus();
 }
diff --git a/src/autoapp/Managers/HttpManager.cpp b/src/autoapp/Managers/HttpManager.cpp
index f18352c0..eef149ba 100644
--- a/src/autoapp/Managers/HttpManager.cpp
+++ b/src/autoapp/Managers/HttpManager.cpp
@@ -2,8 +2,8 @@
 #include <easylogging++.h>
 #include "version.h"
 
-HttpManager::HttpManager(VideoSignals::Pointer videosignals, AASignals::Pointer aasignals)
-    : videosignals_(std::move(videosignals)), aasignals_(std::move(aasignals)) {
+HttpManager::HttpManager(IVideoManager::Pointer videosignals, AASignals::Pointer aasignals)
+    : videoManager(std::move(videosignals)), aasignals_(std::move(aasignals)) {
   server.config.port = 9999;
 
   // Add resources using path-regex and method-string, and an anonymous function
@@ -44,7 +44,7 @@ HttpManager::HttpManager(VideoSignals::Pointer videosignals, AASignals::Pointer
 
         response->write(SimpleWeb::StatusCode::success_ok, header);
 
-        videosignals_->focusRequest.emit();
+        videoManager->requestFocus();
 
         LOG(DEBUG) << "Got /takeVideoFocus call.";
       };
@@ -67,7 +67,7 @@ HttpManager::HttpManager(VideoSignals::Pointer videosignals, AASignals::Pointer
   };
 
   serverThread = std::thread([&]() { server.start(); });
-  videosignals_->focusChanged.connect(sigc::mem_fun(*this, &HttpManager::handle_video_focus));
+  videoManager->registerFocus([this](bool focus){this->handle_video_focus(focus);});
   aasignals_->connected.connect(sigc::mem_fun(*this, &HttpManager::handle_aa_connect));
 }
 
diff --git a/src/autoapp/Managers/VideoManager.cpp b/src/autoapp/Managers/VideoManager.cpp
index a77633a6..820d90aa 100644
--- a/src/autoapp/Managers/VideoManager.cpp
+++ b/src/autoapp/Managers/VideoManager.cpp
@@ -1,9 +1,7 @@
 #include "autoapp/Managers/VideoManager.hpp"
 #include <easylogging++.h>
 
-VideoManager::VideoManager(VideoSignals::Pointer videosignals,
-                           const std::shared_ptr<DBus::Connection> &session_connection) :
-    vs(std::move(videosignals)) {
+VideoManager::VideoManager(const std::shared_ptr<DBus::Connection> &session_connection){
   gui =
       com_jci_nativeguictrl_objectProxy::create(session_connection, "com.jci.nativeguictrl", "/com/jci/nativeguictrl");
   bucpsa = com_jci_bucpsa_objectProxy::create(session_connection, "com.jci.bucpsa", "/com/jci/bucpsa");
@@ -12,27 +10,24 @@ VideoManager::VideoManager(VideoSignals::Pointer videosignals,
   std::tuple<unsigned int, int> display_mode = bucpsa->getcom_jci_bucpsaInterface()->GetDisplayMode();
 
   currentDisplayMode = (bool) std::get<0>(display_mode);
-
-  releaseFocusConnection = vs->focusRelease.connect(sigc::mem_fun(*this, &VideoManager::releaseFocus));
-  requestFocusConnection = vs->focusRequest.connect(sigc::mem_fun(*this, &VideoManager::requestFocus));
 }
 
 void VideoManager::DisplayMode(uint32_t DisplayMode) {
-  this->currentDisplayMode = (bool) DisplayMode;
+  currentDisplayMode = (bool) DisplayMode;
   // currentDisplayMode != 0 means backup camera wants the screen
   if ((bool) DisplayMode) {
-    this->vs->focusRelease.emit();
     if (hasFocus) {
-      this->waitsForFocus = true;
+      waitsForFocus = true;
     }
+    releaseFocus();
   } else {
-    this->vs->focusRequest.emit();
+    requestFocus();
   }
 }
 
 void VideoManager::requestFocus() {
   if (currentDisplayMode) {
-    // we can safely exit - backup camera will notice us when we finish and we request focus back
+    // we can safely exit - backup camera will notice us when we finish; and we request focus back
     waitsForFocus = true;
     return;
   }
@@ -45,20 +40,16 @@ void VideoManager::requestFocus() {
   LOG(DEBUG) << "Setting focus";
   hasFocus = true;
   gui->getcom_jci_nativeguictrlInterface()->SetRequiredSurfaces(std::to_string(SURFACES::TV_TOUCH_SURFACE), 1);
-  vs->focusChanged.emit(true);
 }
 
 void VideoManager::releaseFocus() {
   LOG(DEBUG) << "Releasing focus";
   hasFocus = false;
   gui->getcom_jci_nativeguictrlInterface()->SetRequiredSurfaces(std::to_string(SURFACES::JCI_OPERA_PRIMARY), 1);
-  vs->focusChanged.emit(false);
 }
 
 VideoManager::~VideoManager() {
   LOG(DEBUG) << "Stopping VideoManager";
-  releaseFocusConnection.disconnect();
-  requestFocusConnection.disconnect();
   releaseFocus();
   bucpsa.reset();
 }
diff --git a/src/autoapp/Projection/InputDevice.cpp b/src/autoapp/Projection/InputDevice.cpp
index a908b5d7..4051446e 100644
--- a/src/autoapp/Projection/InputDevice.cpp
+++ b/src/autoapp/Projection/InputDevice.cpp
@@ -28,11 +28,11 @@ namespace autoapp::projection {
 
 InputDevice::InputDevice(asio::io_service &ioService,
                          AudioSignals::Pointer audiosignals,
-                         VideoSignals::Pointer videosignals) :
+                         IVideoManager::Pointer videosignals) :
     timer_(ioService),
     strand_(ioService),
     audiosignals_(std::move(audiosignals)),
-    videosignals_(std::move(videosignals)),
+    videoManger(std::move(videosignals)),
     eventHandler_(nullptr),
     canceled_(false) {
   keymap = {
@@ -55,7 +55,7 @@ InputDevice::InputDevice(asio::io_service &ioService,
       {KEY_E, ButtonCode::MEDIA}
   };
   audioFocusChanged = audiosignals_->focusChanged.connect(sigc::mem_fun(*this, &InputDevice::audio_focus));
-  videoFocusChanged = videosignals_->focusChanged.connect(sigc::mem_fun(*this, &InputDevice::video_focus));
+  videoManger->registerFocus([this](bool focus){this->video_focus(focus);});
 }
 
 void InputDevice::audio_focus(aasdk::messenger::ChannelId channel_id, aasdk::proto::enums::AudioFocusState_Enum state) {
@@ -284,9 +284,9 @@ void InputDevice::handle_key(input_event *ev) {
             return;
           case ButtonCode::BACK: // We use both these buttons for releasing focus, so fall through to the next case.
           case ButtonCode::CALL_END:LOG(DEBUG) << "Release Video Focus";
-            videosignals_->focusRelease.emit();
+            videoManger->releaseFocus();
             return;
-          case ButtonCode::HOME:videosignals_->focusRequest.emit();
+          case ButtonCode::HOME:videoManger->requestFocus();
             return;
           default:break;
         }
diff --git a/src/autoapp/Service/ServiceFactory.cpp b/src/autoapp/Service/ServiceFactory.cpp
index 8dc72324..bbc7054d 100644
--- a/src/autoapp/Service/ServiceFactory.cpp
+++ b/src/autoapp/Service/ServiceFactory.cpp
@@ -56,7 +56,7 @@ ServiceList ServiceFactory::create(aasdk::messenger::IMessenger::Pointer messeng
 
 IService::Pointer ServiceFactory::createVideoService(aasdk::messenger::IMessenger::Pointer messenger) {
   projection::IVideoOutput::Pointer videoOutput(new projection::GSTVideoOutput(ioService_));
-  return std::make_shared<VideoService>(ioService_, messenger, std::move(videoOutput), signals_.videoSignals);
+  return std::make_shared<VideoService>(ioService_, messenger, std::move(videoOutput), signals_.videoManager);
 }
 
 IService::Pointer ServiceFactory::createBluetoothService(aasdk::messenger::IMessenger::Pointer messenger) {
@@ -68,7 +68,7 @@ IService::Pointer ServiceFactory::createBluetoothService(aasdk::messenger::IMess
 
 IService::Pointer ServiceFactory::createInputService(aasdk::messenger::IMessenger::Pointer messenger) {
   projection::IInputDevice::Pointer
-      inputDevice(std::make_shared<projection::InputDevice>(ioService_, signals_.audioSignals, signals_.videoSignals));
+      inputDevice(std::make_shared<projection::InputDevice>(ioService_, signals_.audioSignals, signals_.videoManager));
 
   return std::make_shared<InputService>(ioService_, messenger, std::move(inputDevice));
 }
diff --git a/src/autoapp/Service/VideoService.cpp b/src/autoapp/Service/VideoService.cpp
index 13a2e1e0..3d286d92 100644
--- a/src/autoapp/Service/VideoService.cpp
+++ b/src/autoapp/Service/VideoService.cpp
@@ -24,12 +24,12 @@ namespace autoapp::service {
 VideoService::VideoService(asio::io_service &ioService,
                            aasdk::messenger::IMessenger::Pointer messenger,
                            projection::IVideoOutput::Pointer videoOutput,
-                           VideoSignals::Pointer videoSignals)
-    : videoSignals_(std::move(videoSignals)),
-      strand_(ioService),
+                           IVideoManager::Pointer VideoManager)
+    : strand_(ioService),
       channel_(std::make_shared<aasdk::channel::av::VideoServiceChannel>(strand_, std::move(messenger))),
       videoOutput_(std::move(videoOutput)),
-      session_(-1) {
+      session_(-1),
+      videoManager(std::move(VideoManager)){
 
 }
 
@@ -44,7 +44,7 @@ void VideoService::stop() {
   strand_.dispatch([this, self = this->shared_from_this()]() {
     LOG(INFO) << "[VideoService] stop.";
     focusChanged.disconnect();
-    videoSignals_->focusRelease.emit();
+    videoManager->releaseFocus();
   });
 }
 
@@ -63,7 +63,7 @@ void VideoService::resume() {
 void VideoService::onChannelOpenRequest(const aasdk::proto::messages::ChannelOpenRequest &request) {
   LOG(INFO) << "[VideoService] open request, priority: " << request.priority();
   const aasdk::proto::enums::Status::Enum status = aasdk::proto::enums::Status::OK;
-  focusChanged = videoSignals_->focusChanged.connect([this](bool focus) {
+  videoManager->registerFocus([this](bool focus) {
     if (focus) {
       sendVideoFocusIndication();
     }
@@ -90,7 +90,7 @@ void VideoService::onAVChannelSetupRequest(const aasdk::proto::messages::AVChann
                            : aasdk::proto::enums::AVChannelSetupStatus::FAIL;
   LOG(INFO) << "[VideoService] setup status: " << status;
 
-  videoSignals_->focusRequest.emit();
+  videoManager->requestFocus();
 
   aasdk::proto::messages::AVChannelSetupResponse response;
   response.set_media_status(status);
@@ -183,7 +183,7 @@ void VideoService::onVideoFocusRequest(const aasdk::proto::messages::VideoFocusR
             << ", focus mode: " << request.focus_mode()
             << ", focus reason: " << request.focus_reason();
 
-  videoSignals_->focusRequest.emit();
+  videoManager->requestFocus();
   channel_->receive(this->shared_from_this());
 }
 
diff --git a/src/autoapp/autoapp.cpp b/src/autoapp/autoapp.cpp
index e3c16292..2de40d4a 100644
--- a/src/autoapp/autoapp.cpp
+++ b/src/autoapp/autoapp.cpp
@@ -36,6 +36,7 @@
 #include <autoapp/Managers/HttpManager.hpp>
 #include <autoapp/Managers/BluetoothManager.hpp>
 #include <autoapp/Managers/NavigationManager.hpp>
+#include <autoapp/Managers/IVideoManager.hpp>
 #include <autoapp/Configuration/Configuration.hpp>
 
 #define MINI_CASE_SENSITIVE
@@ -175,7 +176,6 @@ int main(int argc, char *argv[]) {
   usbThreadPool usb_thread_pool(usbContext);
   startIOServiceWorkers(ioService, threadPool);
 
-  Signals signals = Signals();
 
 //  DBus::set_logging_function(DBus::log_std_err);
 //  DBus::set_log_level(SL_TRACE);
@@ -183,22 +183,23 @@ int main(int argc, char *argv[]) {
   std::shared_ptr<DBus::Connection> session_connection = dispatcher->create_connection(DBus::BusType::SESSION);
   std::shared_ptr<DBus::Connection> system_connection = dispatcher->create_connection(DBus::BusType::SYSTEM);
 
-  AudioManagerClient audioManager(signals.audioSignals, system_connection);
 
   //Define thise here, to prevent them from falling out-of-scope outside the if statements.
-  AAPA *aapa;
-  VideoManager *videoManager;
-  HttpManager *httpManager;
+  IVideoManager::Pointer videoManager;
+  AASignals::Pointer aaSignals = std::make_shared<AASignals>();
 
   if (checkAapaVersion()) {
     LOG(DEBUG) << "Using Mazda Android Auto Video";
-    aapa = new AAPA(signals.videoSignals, signals.aaSignals, session_connection);
+    videoManager = std::make_shared<AAPA>(aaSignals, session_connection);
   } else {
     LOG(DEBUG) << "Using internal Video handling";
-    videoManager = new VideoManager(signals.videoSignals, session_connection);
-    httpManager = new HttpManager(signals.videoSignals, signals.aaSignals);
+    videoManager = std::make_shared<VideoManager>(session_connection);
   }
+  Signals signals = Signals(videoManager, aaSignals);
+  HttpManager *httpManager;
+  httpManager = new HttpManager(videoManager, signals.aaSignals);
 
+  AudioManagerClient audioManager(signals.audioSignals, system_connection);
   GPSManager gpsManager(signals.gpsSignals, system_connection);
   NavigationManager navigationManager(signals.navSignals, system_connection);
 
@@ -236,20 +237,15 @@ int main(int argc, char *argv[]) {
   }
 
   signals.audioSignals->focusRelease.emit(aasdk::messenger::ChannelId::MEDIA_AUDIO);
-  signals.videoSignals->focusRelease.emit();
+  videoManager->releaseFocus();
   sleep(2);
 //  signals.aaSignals->shutdown.emit();
 //
 //  while (connected) {
 //    sleep(1);
 //  }
-  if (checkAapaVersion()) {
-    delete aapa;
 
-  }else {
-    delete videoManager;
-    delete httpManager;
-  }
+  delete httpManager;
   LOG(DEBUG) << "Calling app->stop()";
   app->stop();
   LOG(DEBUG) << "Stopping ioService";