1 files changed, 212 insertions, 89 deletions

diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index d6beb3c497..6d7fdeec61 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -190,6 +190,104 @@ ApplicationSharedPtr ApplicationManagerImpl::active_application() const {
   return ApplicationSharedPtr();
 }
 
+
+ApplicationSharedPtr
+ApplicationManagerImpl::get_limited_media_application() const {
+  sync_primitives::AutoLock lock(applications_list_lock_);
+
+  for (TAppListIt it = application_list_.begin();
+       application_list_.end() != it; ++it) {
+    if ((*it)->is_media_application() &&
+        (mobile_api::HMILevel::HMI_LIMITED == (*it)->hmi_level())) {
+      return *it;
+    }
+  }
+
+  return ApplicationSharedPtr();
+}
+
+ApplicationSharedPtr
+ApplicationManagerImpl::get_limited_navi_application() const {
+  sync_primitives::AutoLock lock(applications_list_lock_);
+
+  for (TAppListIt it = application_list_.begin();
+       application_list_.end() != it; ++it) {
+    if ((*it)->allowed_support_navigation() &&
+        (mobile_api::HMILevel::HMI_LIMITED == (*it)->hmi_level())) {
+      return *it;
+    }
+  }
+
+  return ApplicationSharedPtr();
+}
+
+ApplicationSharedPtr
+ApplicationManagerImpl::get_limited_voice_application() const {
+  sync_primitives::AutoLock lock(applications_list_lock_);
+
+  for (TAppListIt it = application_list_.begin();
+       application_list_.end() != it; ++it) {
+    if ((*it)->is_voice_communication_supported() &&
+        (mobile_api::HMILevel::HMI_LIMITED == (*it)->hmi_level())) {
+      return *it;
+    }
+  }
+
+  return ApplicationSharedPtr();
+}
+
+bool ApplicationManagerImpl::DoesAudioAppWithSameHMITypeExistInFullOrLimited(
+    ApplicationSharedPtr app) const {
+  bool voice_state = app->is_voice_communication_supported();
+  bool media_state = app->is_media_application();
+  bool navi_state = app->hmi_supports_navi_video_streaming();
+  ApplicationSharedPtr active_app = active_application();
+  // Check app in FULL level
+  if (active_app.valid()) {
+    // If checking app hmi level FULL, we return false
+    // because we couldn't have two applications with same HMIType in FULL and LIMITED HMI level
+    if (active_app->app_id() == app->app_id()) {
+      return false;
+    }
+
+    if (voice_state && active_app->is_voice_communication_supported()) {
+      return true;
+    }
+
+    if (media_state && active_app->is_media_application()) {
+      return true;
+    }
+
+    if (navi_state && active_app->hmi_supports_navi_video_streaming()) {
+      return true;
+    }
+  }
+
+  // Check LIMITED apps
+  if (voice_state) {
+    if (get_limited_voice_application().valid() &&
+        (get_limited_voice_application()->app_id() != app->app_id())) {
+      return true;
+    }
+  }
+
+  if (media_state) {
+    if (get_limited_media_application().valid() &&
+        (get_limited_media_application()->app_id() != app->app_id())) {
+      return true;
+    }
+  }
+
+  if (navi_state) {
+    if (get_limited_navi_application().valid() &&
+        (get_limited_navi_application()->app_id() != app->app_id())) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 std::vector<ApplicationSharedPtr> ApplicationManagerImpl::applications_by_button(
   uint32_t button) {
   std::vector<ApplicationSharedPtr> result;
@@ -399,116 +497,90 @@ bool ApplicationManagerImpl::ActivateApplication(ApplicationSharedPtr app) {
     return false;
   }
 
-  bool is_new_app_media = app->is_media_application();
-
   if (app->IsFullscreen()) {
     LOG4CXX_WARN(logger_, "Application is already active.");
     return false;
   }
-  if (mobile_api::HMILevel::eType::HMI_LIMITED !=
-      app->hmi_level()) {
+
+  bool is_new_app_media = app->is_media_application();
+  ApplicationSharedPtr current_active_app = active_application();
+
+  if (mobile_api::HMILevel::eType::HMI_LIMITED != app->hmi_level()) {
     if (app->has_been_activated()) {
       MessageHelper::SendAppDataToHMI(app);
     }
   }
-  app->MakeFullscreen();
-  for (std::set<ApplicationSharedPtr>::iterator it = application_list_.begin();
-       application_list_.end() != it;
-       ++it) {
-    ApplicationSharedPtr curr_app = *it;
-    if (app->app_id() == curr_app->app_id()) {
-      continue;
+
+  if (current_active_app.valid()) {
+    if (is_new_app_media && current_active_app->is_media_application()) {
+      current_active_app->MakeNotAudible();
+    } else if (!(current_active_app->IsAudioApplication())) {
+      current_active_app->set_hmi_level(mobile_api::HMILevel::HMI_BACKGROUND);
     } else {
-      if (is_new_app_media) {
-        if (curr_app->IsAudible()) {
-          curr_app->MakeNotAudible();
-          MessageHelper::SendHMIStatusNotification(*curr_app);
-        }
-      }
-      if (curr_app->IsFullscreen()) {
-        if (true == curr_app->is_media_application()) {
-          PutApplicationInLimited(app);
-        } else {
-          app->set_hmi_level(mobile_api::HMILevel::HMI_BACKGROUND);
-        }
-        MessageHelper::SendHMIStatusNotification(*curr_app);
-      }
+      current_active_app->set_hmi_level(mobile_api::HMILevel::HMI_LIMITED);
     }
-  }
-  return true;
-}
 
-mobile_apis::HMILevel::eType ApplicationManagerImpl::PutApplicationInLimited(
-  ApplicationSharedPtr app) {
-  DCHECK(app.get())
+    MessageHelper::SendHMIStatusNotification(*current_active_app);
+  }
 
-  mobile_api::HMILevel::eType result = mobile_api::HMILevel::HMI_LIMITED;
+  app->MakeFullscreen();
 
-  for (std::set<ApplicationSharedPtr>::iterator it = application_list_.begin();
-       application_list_.end() != it;
-       ++it) {
-    ApplicationSharedPtr curr_app = *it;
-    if (app->app_id() == curr_app->app_id()) {
-      continue;
+  if (is_new_app_media) {
+    ApplicationSharedPtr limited_app = get_limited_media_application();
+    if (limited_app.valid()) {
+      limited_app->MakeNotAudible();
+      MessageHelper::SendHMIStatusNotification(*limited_app);
     }
+  }
 
-    if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_LIMITED) {
-      result = mobile_api::HMILevel::HMI_BACKGROUND;
-      break;
-    }
-    if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_FULL) {
-      if (curr_app->is_media_application()) {
-        result = mobile_api::HMILevel::HMI_BACKGROUND;
-        break;
-      } else {
-        result = mobile_api::HMILevel::HMI_LIMITED;
+  if (app->is_voice_communication_supported()) {
+    ApplicationSharedPtr limited_app = get_limited_voice_application();
+    if (limited_app.valid()) {
+      if (limited_app->is_media_application()) {
+        limited_app->set_audio_streaming_state(
+            mobile_api::AudioStreamingState::NOT_AUDIBLE);
       }
+      limited_app->set_hmi_level(mobile_api::HMILevel::HMI_BACKGROUND);
+      MessageHelper::SendHMIStatusNotification(*limited_app);
     }
+  }
 
+  if (app->allowed_support_navigation()) {
+    ApplicationSharedPtr limited_app = get_limited_navi_application();
+    if (limited_app.valid()) {
+      if (limited_app->is_media_application()) {
+        limited_app->set_audio_streaming_state(
+            mobile_api::AudioStreamingState::NOT_AUDIBLE);
+      }
+      limited_app->set_hmi_level(mobile_api::HMILevel::HMI_BACKGROUND);
+      MessageHelper::SendHMIStatusNotification(*limited_app);
+    }
   }
-  app->set_hmi_level(result);
-  return result;
+
+  return true;
 }
 
 mobile_api::HMILevel::eType ApplicationManagerImpl::PutApplicationInFull(
   ApplicationSharedPtr app) {
   DCHECK(app.get())
 
-  bool is_new_app_media = app->is_media_application();
+  bool is_audio_app = app->IsAudioApplication();
+  bool does_audio_app_with_same_type_exist =
+      DoesAudioAppWithSameHMITypeExistInFullOrLimited(app);
+
   mobile_api::HMILevel::eType result = mobile_api::HMILevel::HMI_FULL;
 
-  std::set<ApplicationSharedPtr>::iterator it = application_list_.begin();
-  for (; application_list_.end() != it; ++it) {
-    ApplicationSharedPtr curr_app = *it;
-    if (app->app_id() == curr_app->app_id()) {
-      continue;
-    }
+  bool is_active_app_exist = active_application().valid();
 
-    if (is_new_app_media) {
-      if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_FULL) {
-        if (curr_app->is_media_application()) {
-          result = mobile_api::HMILevel::HMI_BACKGROUND;
-          break;
-        } else {
-          result = mobile_api::HMILevel::HMI_LIMITED;
-        }
-      }
-      if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_LIMITED) {
-        result = mobile_api::HMILevel::HMI_BACKGROUND;
-        break;
-      }
-    } else {
-      if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_FULL) {
-        result = mobile_api::HMILevel::HMI_BACKGROUND;
-        break;
-      }
-      if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_LIMITED) {
-        result = mobile_api::HMILevel::HMI_FULL;
-      }
-    }
+  if (is_audio_app && does_audio_app_with_same_type_exist) {
+    result = mobile_apis::HMILevel::HMI_BACKGROUND;
+  } else if (is_active_app_exist && is_audio_app) {
+    result = mobile_apis::HMILevel::HMI_LIMITED;
+  } else if (is_active_app_exist && (!is_audio_app)) {
+    result = mobile_apis::HMILevel::HMI_BACKGROUND;
   }
 
-  if (result == mobile_api::HMILevel::HMI_FULL) {
+  if (mobile_api::HMILevel::HMI_FULL == result) {
     app->set_hmi_level(result);
     MessageHelper::SendActivateAppToHMI(app->app_id());
   }
@@ -688,7 +760,7 @@ std::string ApplicationManagerImpl::GetDeviceName(
 }
 
 void ApplicationManagerImpl::OnMessageReceived(
-  const RawMessagePtr message) {
+  const ::protocol_handler::RawMessagePtr message) {
   LOG4CXX_INFO(logger_, "ApplicationManagerImpl::OnMessageReceived");
 
   if (!message) {
@@ -706,7 +778,7 @@ void ApplicationManagerImpl::OnMessageReceived(
 }
 
 void ApplicationManagerImpl::OnMobileMessageSent(
-  const RawMessagePtr message) {
+  const ::protocol_handler::RawMessagePtr message) {
   LOG4CXX_INFO(logger_, "ApplicationManagerImpl::OnMobileMessageSent");
 }
 
@@ -1041,7 +1113,7 @@ void ApplicationManagerImpl::StartDevicesDiscovery() {
 }
 
 void ApplicationManagerImpl::SendMessageToMobile(
-  const utils::SharedPtr<smart_objects::SmartObject>& message,
+  const utils::SharedPtr<smart_objects::SmartObject> message,
   bool final_message) {
   LOG4CXX_INFO(logger_, "ApplicationManagerImpl::SendMessageToMobile");
 
@@ -1131,7 +1203,7 @@ void ApplicationManagerImpl::SendMessageToMobile(
 }
 
 bool ApplicationManagerImpl::ManageMobileCommand(
-  const utils::SharedPtr<smart_objects::SmartObject>& message) {
+  const utils::SharedPtr<smart_objects::SmartObject> message) {
   LOG4CXX_INFO(logger_, "ApplicationManagerImpl::ManageMobileCommand");
 
   if (!message) {
@@ -1288,7 +1360,7 @@ bool ApplicationManagerImpl::ManageMobileCommand(
 }
 
 void ApplicationManagerImpl::SendMessageToHMI(
-  const utils::SharedPtr<smart_objects::SmartObject>& message) {
+  const utils::SharedPtr<smart_objects::SmartObject> message) {
   LOG4CXX_INFO(logger_, "ApplicationManagerImpl::SendMessageToHMI");
 
   if (!message) {
@@ -1330,7 +1402,7 @@ void ApplicationManagerImpl::SendMessageToHMI(
 }
 
 bool ApplicationManagerImpl::ManageHMICommand(
-  const utils::SharedPtr<smart_objects::SmartObject>& message) {
+  const utils::SharedPtr<smart_objects::SmartObject> message) {
   LOG4CXX_INFO(logger_, "ApplicationManagerImpl::ManageHMICommand");
 
   if (!message) {
@@ -1642,7 +1714,7 @@ bool ApplicationManagerImpl::ConvertSOtoMessage(
 }
 
 utils::SharedPtr<Message> ApplicationManagerImpl::ConvertRawMsgToMessage(
-  const RawMessagePtr message) {
+  const ::protocol_handler::RawMessagePtr message) {
   DCHECK(message);
   utils::SharedPtr<Message> outgoing_message;
 
@@ -1678,7 +1750,7 @@ utils::SharedPtr<Message> ApplicationManagerImpl::ConvertRawMsgToMessage(
 }
 
 void ApplicationManagerImpl::ProcessMessageFromMobile(
-  const utils::SharedPtr<Message>& message) {
+  const utils::SharedPtr<Message> message) {
   LOG4CXX_INFO(logger_, "ApplicationManagerImpl::ProcessMessageFromMobile()");
 #ifdef TIME_TESTER
   AMMetricObserver::MessageMetricSharedPtr metric(new AMMetricObserver::MessageMetric());
@@ -1712,7 +1784,7 @@ void ApplicationManagerImpl::ProcessMessageFromMobile(
 }
 
 void ApplicationManagerImpl::ProcessMessageFromHMI(
-  const utils::SharedPtr<Message>& message) {
+  const utils::SharedPtr<Message> message) {
   LOG4CXX_INFO(logger_, "ApplicationManagerImpl::ProcessMessageFromHMI()");
   utils::SharedPtr<smart_objects::SmartObject> smart_object(
     new smart_objects::SmartObject);
@@ -2335,4 +2407,55 @@ void ApplicationManagerImpl::RemoveAppFromTTSGlobalPropertiesList(
   }
 }
 
+void ApplicationManagerImpl::CreatePhoneCallAppList() {
+  LOG4CXX_TRACE_ENTER(logger_);
+
+  ApplicationManagerImpl::ApplicationListAccessor accessor;
+  ApplicationManagerImpl::TAppList local_app_list = accessor.applications();
+
+  ApplicationManagerImpl::TAppListIt it = local_app_list.begin();
+  ApplicationManagerImpl::TAppListIt itEnd = local_app_list.end();
+
+  for (; it != itEnd; ++it) {
+    if (mobile_api::HMILevel::HMI_FULL == (*it)->hmi_level() ||
+        mobile_api::HMILevel::HMI_LIMITED == (*it)->hmi_level()) {
+
+      // back up app state
+      on_phone_call_app_list_.insert(std::pair<uint32_t, AppState>(
+          (*it)->app_id(), AppState((*it)->hmi_level(),
+                                    (*it)->audio_streaming_state(),
+                                    (*it)->system_context())));
+
+      // app state during phone call
+      (*it)->set_hmi_level(mobile_api::HMILevel::HMI_BACKGROUND);
+      (*it)->set_audio_streaming_state(mobile_api::AudioStreamingState::NOT_AUDIBLE);
+      (*it)->set_system_context(mobile_api::SystemContext::SYSCTXT_MAIN);
+      MessageHelper::SendHMIStatusNotification(*(*it));
+    }
+  }
+}
+
+void ApplicationManagerImpl::ResetPhoneCallAppList() {
+  LOG4CXX_TRACE_ENTER(logger_);
+
+  ApplicationManagerImpl::ApplicationListAccessor accessor;
+  ApplicationManagerImpl::TAppList local_app_list = accessor.applications();
+
+  std::map<uint32_t, AppState>::iterator it =
+      on_phone_call_app_list_.begin();
+  std::map<uint32_t, AppState>::iterator it_end =
+      on_phone_call_app_list_.end();
+  for (; it != it_end; ++it) {
+    ApplicationSharedPtr app = application(it->first);
+    if (app) {
+      app->set_hmi_level(it->second.hmi_level);
+      app->set_audio_streaming_state(it->second.audio_streaming_state);
+      app->set_system_context(it->second.system_context);
+      MessageHelper::SendHMIStatusNotification(*app);
+    }
+  }
+
+  on_phone_call_app_list_.clear();
+}
+
 }  // namespace application_manager