Remove dependency on sigc++ for video focus requests and events.

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,29 +41,24 @@ 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;
  AADBus *androiddbus;
  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);
- };
+ void requestFocus() override;
+ void releaseFocus() override;
+};

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;

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);
+ }
+ }
+
+};

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,

include/autoapp/Projection/GSTVideoOutput.hpp

@@ -4,7 +4,6 @@
 #include <autoapp/Projection/IVideoOutput.hpp>
 #include <thread>
 #include <asio.hpp>
-#include <autoapp/Signals/VideoSignals.hpp>
 
 
 

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;

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;
+
 };
 
 }

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)) {
+
+ };
 };

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,21 +41,19 @@ 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);
 
  session_object = com_jci_aapa_objectAdapter::create(session_connection, adapter, "/com/jci/aapa");
 
  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();
 }

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));
 }