src/appMain/life_cycle.cc

   1 /**
   2 * \file signals.cc
   3 * \brief Signal (i.e. SIGINT) handling.
   4 * Copyright (c) 2013, Ford Motor Company
   5 * All rights reserved.
   6 *
   7 * Redistribution and use in source and binary forms, with or without
   8 * modification, are permitted provided that the following conditions are met:
   9 *
  10 * Redistributions of source code must retain the above copyright notice, this
  11 * list of conditions and the following disclaimer.
  12 *
  13 * Redistributions in binary form must reproduce the above copyright notice,
  14 * this list of conditions and the following
  15 * disclaimer in the documentation and/or other materials provided with the
  16 * distribution.
  17 *
  18 * Neither the name of the Ford Motor Company nor the names of its contributors
  19 * may be used to endorse or promote products derived from this software
  20 * without specific prior written permission.
  21 *
  22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32 * POSSIBILITY OF SUCH DAMAGE.
  33 */
  34
  35 #include "./life_cycle.h"
  36 #include "utils/signals.h"
  37 #include "config_profile/profile.h"
  38 #include "resumption/last_state.h"
  39
  40 using threads::Thread;
  41
  42 namespace main_namespace {
  43 CREATE_LOGGERPTR_GLOBAL(logger_, "appMain")
  44
  45 namespace {
  46 void NameMessageBrokerThread(const System::Thread& thread,
  47                              const std::string& name) {
  48   Thread::SetNameForId(Thread::Id(thread.GetId()), name);
  49 }
  50
  51 } // namespace
  52
  53 LifeCycle::LifeCycle()
  54   : transport_manager_(NULL)
  55   , protocol_handler_(NULL)
  56   , connection_handler_(NULL)
  57   , app_manager_(NULL)
  58   , hmi_handler_(NULL)
  59   , hmi_message_adapter_(NULL)
  60   , media_manager_(NULL)
  61 #ifdef TIME_TESTER
  62   , time_tester_(NULL)
  63 #endif //TIME_TESTER
  64 #ifdef DBUS_HMIADAPTER
  65   , dbus_adapter_(NULL)
  66   , dbus_adapter_thread_(NULL)
  67 #endif  // DBUS_HMIADAPTER
  68 #ifdef MESSAGEBROKER_HMIADAPTER
  69   , mb_adapter_(NULL)
  70   , message_broker_(NULL)
  71   , message_broker_server_(NULL)
  72   , mb_thread_(NULL)
  73   , mb_server_thread_(NULL)
  74   , mb_adapter_thread_(NULL)
  75 #endif  // MESSAGEBROKER_HMIADAPTER
  76 {
  77 }
  78
  79 bool LifeCycle::StartComponents() {
  80   LOG4CXX_INFO(logger_, "LifeCycle::StartComponents()");
  81   transport_manager_ =
  82     transport_manager::TransportManagerDefault::instance();
  83   DCHECK(transport_manager_ != NULL);
  84
  85   protocol_handler_ =
  86     new protocol_handler::ProtocolHandlerImpl(transport_manager_);
  87   DCHECK(protocol_handler_ != NULL);
  88
  89   connection_handler_ =
  90     connection_handler::ConnectionHandlerImpl::instance();
  91   DCHECK(connection_handler_ != NULL);
  92
  93   app_manager_ =
  94     application_manager::ApplicationManagerImpl::instance();
  95   DCHECK(app_manager_ != NULL);
  96   hmi_handler_ =
  97     hmi_message_handler::HMIMessageHandlerImpl::instance();
  98   DCHECK(hmi_handler_ != NULL)
  99
 100   transport_manager_->AddEventListener(protocol_handler_);
 101   transport_manager_->AddEventListener(connection_handler_);
 102
 103   hmi_handler_->set_message_observer(app_manager_);
 104
 105   media_manager_ = media_manager::MediaManagerImpl::instance();
 106
 107   connection_handler_->SetProtocolHandler(protocol_handler_);
 108   protocol_handler_->set_session_observer(connection_handler_);
 109   protocol_handler_->AddProtocolObserver(media_manager_);
 110   protocol_handler_->AddProtocolObserver(app_manager_);
 111   media_manager_->SetProtocolHandler(protocol_handler_);
 112
 113   connection_handler_->set_transport_manager(transport_manager_);
 114   connection_handler_->set_connection_handler_observer(app_manager_);
 115
 116   // it is important to initialise TimeTester before TM to listen TM Adapters
 117 #ifdef TIME_TESTER
 118   time_tester_ = new time_tester::TimeManager();
 119   time_tester_->Init(protocol_handler_);
 120 #endif //TIME_TESTER
 121   // It's important to initialise TM after setting up listener chain
 122   // [TM -> CH -> AM], otherwise some events from TM could arrive at nowhere
 123   transport_manager_->Init();
 124   //start transport manager
 125   transport_manager_->Visibility(true);
 126   app_manager_->set_protocol_handler(protocol_handler_);
 127   app_manager_->set_connection_handler(connection_handler_);
 128   app_manager_->set_hmi_message_handler(hmi_handler_);
 129   return true;
 130 }
 131
 132 #ifdef MESSAGEBROKER_HMIADAPTER
 133 bool LifeCycle::InitMessageSystem() {
 134   message_broker_ =
 135     NsMessageBroker::CMessageBroker::getInstance();
 136   if (!message_broker_) {
 137     LOG4CXX_INFO(logger_, " Wrong pMessageBroker pointer!");
 138     return false;
 139   }
 140
 141   message_broker_server_ =
 142     new NsMessageBroker::TcpServer(
 143     profile::Profile::instance()->server_address(),
 144     profile::Profile::instance()->server_port(),
 145     message_broker_);
 146   if (!message_broker_server_) {
 147     LOG4CXX_INFO(logger_, " Wrong pJSONRPC20Server pointer!");
 148     return false;
 149   }
 150   message_broker_->startMessageBroker(message_broker_server_);
 151   if (!networking::init()) {
 152     LOG4CXX_INFO(logger_, " Networking initialization failed!");
 153     return false;
 154   }
 155
 156   if (!message_broker_server_->Bind()) {
 157     LOG4CXX_FATAL(logger_, "Bind failed!");
 158     return false;
 159   } else {
 160     LOG4CXX_INFO(logger_, "Bind successful!");
 161   }
 162
 163   if (!message_broker_server_->Listen()) {
 164     LOG4CXX_FATAL(logger_, "Listen failed!");
 165     return false;
 166   } else {
 167     LOG4CXX_INFO(logger_, " Listen successful!");
 168   }
 169
 170   mb_adapter_ =
 171     new hmi_message_handler::MessageBrokerAdapter(
 172     hmi_message_handler::HMIMessageHandlerImpl::instance(),
 173     profile::Profile::instance()->server_address(),
 174     profile::Profile::instance()->server_port());
 175
 176   hmi_message_handler::HMIMessageHandlerImpl::instance()->AddHMIMessageAdapter(
 177     mb_adapter_);
 178   if (!mb_adapter_->Connect()) {
 179     LOG4CXX_INFO(logger_, "Cannot connect to remote peer!");
 180     return false;
 181   }
 182
 183   LOG4CXX_INFO(logger_, "Start CMessageBroker thread!");
 184   mb_thread_ = new System::Thread(
 185     new System::ThreadArgImpl<NsMessageBroker::CMessageBroker>(
 186       *message_broker_, &NsMessageBroker::CMessageBroker::MethodForThread,
 187       NULL));
 188   mb_thread_->Start(false);
 189   // Thread can be named only when started because before that point
 190   // thread doesn't have valid Id to associate name with
 191   NameMessageBrokerThread(*mb_thread_, "MessageBrokerThread");
 192
 193   LOG4CXX_INFO(logger_, "Start MessageBroker TCP server thread!");
 194   mb_server_thread_  = new System::Thread(
 195     new System::ThreadArgImpl<NsMessageBroker::TcpServer>(
 196       *message_broker_server_, &NsMessageBroker::TcpServer::MethodForThread,
 197       NULL));
 198   mb_server_thread_->Start(false);
 199   NameMessageBrokerThread(*mb_server_thread_, "MessageBrokerTCPServerThread");
 200
 201   LOG4CXX_INFO(logger_, "StartAppMgr JSONRPC 2.0 controller receiver thread!");
 202   mb_adapter_thread_  = new System::Thread(
 203     new System::ThreadArgImpl<hmi_message_handler::MessageBrokerAdapter>(
 204       *mb_adapter_,
 205       &hmi_message_handler::MessageBrokerAdapter::SubscribeAndBeginReceiverThread,
 206       NULL));
 207   mb_adapter_thread_->Start(false);
 208   NameMessageBrokerThread(*mb_adapter_thread_, "MessageBrokerAdapterThread");
 209
 210   return true;
 211 }
 212 #endif  // MESSAGEBROKER_HMIADAPTER
 213
 214 #ifdef DBUS_HMIADAPTER
 215 /**
 216  * Initialize DBus component
 217  * @return true if success otherwise false.
 218  */
 219 bool LifeCycle::InitMessageSystem() {
 220
 221   dbus_adapter_ = new hmi_message_handler::DBusMessageAdapter(
 222     hmi_message_handler::HMIMessageHandlerImpl::instance());
 223
 224   hmi_message_handler::HMIMessageHandlerImpl::instance()->AddHMIMessageAdapter(
 225     dbus_adapter_);
 226   if (!dbus_adapter_->Init()) {
 227     LOG4CXX_INFO(logger_, "Cannot init DBus service!");
 228     return false;
 229   }
 230
 231   dbus_adapter_->SubscribeTo();
 232
 233   LOG4CXX_INFO(logger_, "Start DBusMessageAdapter thread!");
 234   dbus_adapter_thread_ = new System::Thread(
 235     new System::ThreadArgImpl<hmi_message_handler::DBusMessageAdapter>(
 236       *dbus_adapter_,
 237       &hmi_message_handler::DBusMessageAdapter::MethodForReceiverThread,
 238       NULL));
 239   dbus_adapter_thread_->Start(false);
 240
 241   return true;
 242 }
 243 #endif  // DBUS_HMIADAPTER
 244
 245 #ifdef MQUEUE_HMIADAPTER
 246 bool LifeCycle::InitMessageSystem() {
 247   hmi_message_adapter_ = new hmi_message_handler::MqueueAdapter(
 248     hmi_message_handler::HMIMessageHandlerImpl::instance());
 249   hmi_message_handler::HMIMessageHandlerImpl::instance()->AddHMIMessageAdapter(
 250     hmi_message_adapter_);
 251   return true;
 252 }
 253 #endif  // MQUEUE_HMIADAPTER
 254
 255 void LifeCycle::StopComponents() {
 256   hmi_handler_->set_message_observer(NULL);
 257   connection_handler_->set_connection_handler_observer(NULL);
 258   protocol_handler_->RemoveProtocolObserver(app_manager_);
 259   app_manager_->Stop();
 260
 261   LOG4CXX_INFO(logger_, "Destroying Media Manager");
 262   protocol_handler_->RemoveProtocolObserver(media_manager_);
 263   media_manager_->SetProtocolHandler(NULL);
 264   media_manager::MediaManagerImpl::destroy();
 265
 266   LOG4CXX_INFO(logger_, "Destroying Application Manager.");
 267   application_manager::ApplicationManagerImpl::destroy();
 268
 269   LOG4CXX_INFO(logger_, "Destroying Transport Manager.");
 270   transport_manager_->Stop();
 271   transport_manager::TransportManagerDefault::destroy();
 272
 273   LOG4CXX_INFO(logger_, "Destroying Connection Handler.");
 274   protocol_handler_->set_session_observer(NULL);
 275   connection_handler::ConnectionHandlerImpl::destroy();
 276
 277   LOG4CXX_INFO(logger_, "Destroying Protocol Handler");
 278   delete protocol_handler_;
 279
 280   LOG4CXX_INFO(logger_, "Destroying HMI Message Handler and MB adapter.");
 281 #ifdef DBUS_HMIADAPTER
 282   if (dbus_adapter_) {
 283     if (hmi_handler_) {
 284       hmi_handler_->RemoveHMIMessageAdapter(dbus_adapter_);
 285       hmi_message_handler::HMIMessageHandlerImpl::destroy();
 286     }
 287     if (dbus_adapter_thread_) {
 288       dbus_adapter_thread_->Stop();
 289       dbus_adapter_thread_->Join();
 290       delete dbus_adapter_thread_;
 291     }
 292     delete dbus_adapter_;
 293   }
 294 #endif  // DBUS_HMIADAPTER
 295 #ifdef MESSAGEBROKER_HMIADAPTER
 296   hmi_handler_->RemoveHMIMessageAdapter(mb_adapter_);
 297   hmi_message_handler::HMIMessageHandlerImpl::destroy();
 298   if (mb_adapter_) {
 299     mb_adapter_->unregisterController();
 300     mb_adapter_->Close();
 301     mb_adapter_->exitReceavingThread();
 302     delete mb_adapter_;
 303   }
 304   if (mb_adapter_thread_) {
 305     mb_adapter_thread_->Stop();
 306     delete mb_adapter_thread_;
 307   }
 308
 309 #endif  // MESSAGEBROKER_HMIADAPTER
 310
 311 #ifdef MESSAGEBROKER_HMIADAPTER
 312   LOG4CXX_INFO(logger_, "Destroying Message Broker");
 313   if (mb_server_thread_) {
 314     mb_server_thread_->Stop();
 315     mb_server_thread_->Join();
 316     delete mb_server_thread_;
 317   }
 318   if (mb_thread_) {
 319     mb_thread_->Stop();
 320     mb_thread_->Join();
 321     delete mb_thread_;
 322   }
 323   message_broker_server_->Close();
 324   delete message_broker_server_;
 325   message_broker_->stopMessageBroker();
 326
 327   networking::cleanup();
 328 #endif  // MESSAGEBROKER_HMIADAPTER
 329
 330   delete hmi_message_adapter_;
 331   hmi_message_adapter_ = NULL;
 332
 333   LOG4CXX_INFO(logger_, "Destroying Last State");
 334   resumption::LastState::destroy();
 335
 336 #ifdef TIME_TESTER
 337   // It's important to delete tester Obcervers after TM adapters destruction
 338   if (time_tester_) {
 339     time_tester_->Stop();
 340     delete time_tester_;
 341     time_tester_ = NULL;
 342   }
 343 #endif //TIME_TESTER
 344 }
 345
 346 void LifeCycle::StopComponentsOnSignal(int32_t params) {
 347   utils::ResetSubscribeToTerminateSignal();
 348   instance()->StopComponents();
 349   utils::ForwardSignal();
 350 }
 351
 352 }  //  namespace main_namespace