Sdl passenger mode without ut implementation

src/appMain/sdl_preloaded_pt.json

@@ -33,7 +33,8 @@
                 "COMMUNICATION": 6,
                 "NORMAL": 4,
                 "NONE": 0
-            }
+            },
+            "lock_screen_dismissal_enabled": true
         },
         "functional_groupings": {
             "Base-4": {

src/components/application_manager/include/application_manager/policies/policy_handler.h

@@ -202,6 +202,7 @@ class PolicyHandler : public PolicyHandlerInterface,
   uint32_t TimeoutExchangeMSec() const OVERRIDE;
   void OnExceededTimeout() OVERRIDE;
   void OnSystemReady() OVERRIDE;
+  const utils::OptionalVal<bool> LockScreenDismissalEnabledState() const OVERRIDE;
   void PTUpdatedAt(Counters counter, int value) OVERRIDE;
   void add_listener(PolicyHandlerObserver* listener) OVERRIDE;
   void remove_listener(PolicyHandlerObserver* listener) OVERRIDE;

src/components/application_manager/include/application_manager/smart_object_keys.h

@@ -419,6 +419,7 @@ namespace mobile_notification {
 extern const char* state;
 extern const char* syncp_timeout;
 extern const char* syncp_url;
+extern const char* lock_screen_dismissal_enabled;
 }  // namespace mobile_notification
 
 namespace hmi_levels {

src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_driver_distraction_notification.cc

@@ -127,6 +127,14 @@ void OnDriverDistractionNotification::Run() {
   (*on_driver_distraction)[strings::msg_params][mobile_notification::state] =
       state;
 
+  auto lock_screen_dismissal = application_manager_.GetPolicyHandler().LockScreenDismissalEnabledState();
+
+  if ( lock_screen_dismissal &&
+       hmi_apis::Common_DriverDistractionState::DD_ON ==  state) {
+    (*on_driver_distraction)[strings::msg_params]
+                            [mobile_notification::lock_screen_dismissal_enabled] = *lock_screen_dismissal;
+  }
+
   const ApplicationSet applications =
       application_manager_.applications().GetData();
 

src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/hmi_notifications_test.cc

@@ -1794,6 +1794,8 @@ TEST_F(HMICommandsNotificationsTest, OnDriverDistractionNotificationEmptyData) {
       CreateCommand<hmi::OnDriverDistractionNotification>(message);
 
   EXPECT_CALL(app_mngr_, set_driver_distraction_state(state));
+  EXPECT_CALL(app_mngr_, GetPolicyHandler())
+      .WillOnce(ReturnRef(mock_policy_handler_));
   EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
   EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0);
   EXPECT_CALL(*app_ptr_, app_id()).Times(0);
@@ -1811,6 +1813,8 @@ TEST_F(HMICommandsNotificationsTest,
 
   ApplicationSharedPtr invalid_app;
   application_set_.insert(invalid_app);
+  EXPECT_CALL(app_mngr_, GetPolicyHandler())
+      .WillOnce(ReturnRef(mock_policy_handler_));
   EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
   EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0);
   EXPECT_CALL(*app_ptr_, app_id()).Times(0);
@@ -1826,6 +1830,8 @@ TEST_F(HMICommandsNotificationsTest, OnDriverDistractionNotificationValidApp) {
       CreateCommand<hmi::OnDriverDistractionNotification>(message);
 
   application_set_.insert(app_);
+  EXPECT_CALL(app_mngr_, GetPolicyHandler())
+      .WillOnce(ReturnRef(mock_policy_handler_));
   EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(applications_));
   policy::CheckPermissionResult result;
   result.hmi_level_permitted = policy::kRpcAllowed;

src/components/application_manager/src/application_manager_impl.cc

@@ -3387,6 +3387,14 @@ void ApplicationManagerImpl::SendDriverDistractionState(
       mobile_api::FunctionID::OnDriverDistractionID;
   (*on_driver_distraction)[strings::msg_params][mobile_notification::state] =
       driver_distraction_state();
+  auto lock_screen_dismissal = policy_handler_->LockScreenDismissalEnabledState();
+
+  if ( lock_screen_dismissal &&
+       hmi_apis::Common_DriverDistractionState::DD_ON ==  driver_distraction_state()) {
+    (*on_driver_distraction)[strings::msg_params]
+                            [mobile_notification::lock_screen_dismissal_enabled] = *lock_screen_dismissal;
+  }
+
   (*on_driver_distraction)[strings::params][strings::connection_key] =
       application->app_id();
 

src/components/application_manager/src/policies/policy_handler.cc

@@ -1600,6 +1600,11 @@ void PolicyHandler::OnSystemReady() {
   policy_manager_->OnSystemReady();
 }
 
+const utils::OptionalVal<bool> PolicyHandler::LockScreenDismissalEnabledState() const {
+  POLICY_LIB_CHECK(false);
+  return policy_manager_->LockScreenDismissalEnabledState();
+}
+
 void PolicyHandler::PTUpdatedAt(Counters counter, int value) {
   POLICY_LIB_CHECK_VOID();
   policy_manager_->PTUpdatedAt(counter, value);

src/components/application_manager/src/smart_object_keys.cc

@@ -379,6 +379,7 @@ namespace mobile_notification {
 const char* state = "state";
 const char* syncp_timeout = "Timeout";
 const char* syncp_url = "URL";
+const char* lock_screen_dismissal_enabled = "lockScreenDismissalEnabled";
 }  // namespace mobile_notification
 
 namespace hmi_levels {

src/components/include/application_manager/policies/policy_handler_interface.h

@@ -44,6 +44,7 @@
 #include "policy/usage_statistics/statistics_manager.h"
 #include "utils/custom_string.h"
 #include "utils/callable.h"
+#include "utils/optional.h"
 #include "policy/policy_settings.h"
 #include "smart_objects/smart_object.h"
 #include "policy/policy_types.h"
@@ -120,6 +121,7 @@ class PolicyHandlerInterface {
   virtual uint32_t TimeoutExchangeMSec() const = 0;
   virtual void OnExceededTimeout() = 0;
   virtual void OnSystemReady() = 0;
+  virtual const utils::OptionalVal<bool> LockScreenDismissalEnabledState() const = 0;
   virtual void PTUpdatedAt(Counters counter, int value) = 0;
   virtual void add_listener(PolicyHandlerObserver* listener) = 0;
   virtual void remove_listener(PolicyHandlerObserver* listener) = 0;

src/components/include/policy/policy_external/policy/policy_manager.h

@@ -36,6 +36,7 @@
 #include <vector>
 
 #include "utils/callable.h"
+#include "utils/optional.h"
 
 #include "policy/policy_types.h"
 #include "policy/policy_table/types.h"
@@ -155,6 +156,14 @@ class PolicyManager : public usage_statistics::StatisticsManager {
    */
   virtual void KmsChanged(int kilometers) = 0;
 
+  /**
+   * @brief Returns state of the lock screen that could be able to be dismissed
+   * while connected to SDL, allowing users the ability to interact with the
+   * app.
+   * @return bool True if lock screen is able to be dismissed.
+   */
+  virtual const utils::OptionalVal<bool> LockScreenDismissalEnabledState() const = 0;
+
   /**
    * @brief Increments counter of ignition cycles
    */

src/components/include/policy/policy_regular/policy/policy_manager.h

@@ -37,6 +37,8 @@
 #include <cstdint>
 
 #include "utils/callable.h"
+#include "utils/optional.h"
+
 #include "policy/policy_types.h"
 #include "policy/policy_table/types.h"
 #include "policy/policy_listener.h"
@@ -155,6 +157,14 @@ class PolicyManager : public usage_statistics::StatisticsManager {
    */
   virtual void KmsChanged(int kilometers) = 0;
 
+  /**
+   * @brief Returns state of the lock screen that could be able to be dismissed
+   * while connected to SDL, allowing users the ability to interact with the
+   * app.
+   * @return bool True if lock screen is able to be dismissed.
+   */
+  virtual const utils::OptionalVal<bool> LockScreenDismissalEnabledState() const = 0;
+
   /**
    * @brief Increments counter of ignition cycles
    */

src/components/include/test/application_manager/policies/mock_policy_handler_interface.h

@@ -108,6 +108,7 @@ class MockPolicyHandlerInterface : public policy::PolicyHandlerInterface {
   MOCK_CONST_METHOD0(TimeoutExchangeMSec, uint32_t());
   MOCK_METHOD0(OnExceededTimeout, void());
   MOCK_METHOD0(OnSystemReady, void());
+  MOCK_CONST_METHOD0(LockScreenDismissalEnabledState, const utils::OptionalVal<bool>());
   MOCK_METHOD2(PTUpdatedAt, void(policy::Counters counter, int value));
   MOCK_METHOD1(add_listener, void(policy::PolicyHandlerObserver* listener));
   MOCK_METHOD1(remove_listener, void(policy::PolicyHandlerObserver* listener));

src/components/include/test/policy/policy_external/policy/mock_cache_manager.h

@@ -76,6 +76,7 @@ class MockCacheManagerInterface : public ::policy::CacheManagerInterface {
   MOCK_METHOD1(SecondsBetweenRetries, bool(std::vector<int>& seconds));
   MOCK_CONST_METHOD1(IsDeviceConsentCached, bool(const std::string& device_id));
   MOCK_CONST_METHOD0(GetVehicleInfo, const VehicleInfo());
+  MOCK_CONST_METHOD0(LockScreenDismissalEnabledState, const utils::OptionalVal<bool>());
   MOCK_CONST_METHOD1(GetDeviceConsent,
                      DeviceConsent(const std::string& device_id));
   MOCK_METHOD2(SetDeviceConsent,

src/components/include/test/policy/policy_external/policy/mock_policy_manager.h

@@ -77,6 +77,7 @@ class MockPolicyManager : public PolicyManager {
   MOCK_METHOD0(ResetUserConsent, bool());
   MOCK_CONST_METHOD0(GetPolicyTableStatus, std::string());
   MOCK_METHOD1(KmsChanged, void(int kilometers));
+  MOCK_CONST_METHOD0(LockScreenDismissalEnabledState, const utils::OptionalVal<bool>());
   MOCK_METHOD0(IncrementIgnitionCycles, void());
   MOCK_METHOD0(ForcePTExchange, std::string());
   MOCK_METHOD0(ForcePTExchangeAtUserRequest, std::string());

src/components/include/test/policy/policy_regular/policy/mock_cache_manager.h

@@ -63,6 +63,7 @@ class MockCacheManagerInterface : public CacheManagerInterface {
   MOCK_METHOD0(TimeoutResponse, int());
   MOCK_METHOD1(SecondsBetweenRetries, bool(std::vector<int>& seconds));
   MOCK_CONST_METHOD0(GetVehicleInfo, const VehicleInfo());
+  MOCK_CONST_METHOD0(LockScreenDismissalEnabledState, const utils::OptionalVal<bool>());
   MOCK_METHOD1(SetVINValue, bool(const std::string& value));
   MOCK_METHOD2(GetUserFriendlyMsg,
                std::vector<UserFriendlyMessage>(

src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h

@@ -78,6 +78,7 @@ class MockPolicyManager : public PolicyManager {
   MOCK_METHOD0(ResetUserConsent, bool());
   MOCK_CONST_METHOD0(GetPolicyTableStatus, std::string());
   MOCK_METHOD1(KmsChanged, void(int kilometers));
+  MOCK_CONST_METHOD0(LockScreenDismissalEnabledState, const utils::OptionalVal<bool>());
   MOCK_METHOD0(IncrementIgnitionCycles, void());
   MOCK_METHOD0(ForcePTExchange, std::string());
   MOCK_METHOD0(ForcePTExchangeAtUserRequest, std::string());

src/components/interfaces/MOBILE_API.xml

@@ -6775,6 +6775,13 @@
         <param name="state" type="DriverDistractionState" mandatory="true">
             <description>Current State of Driver Distraction</description>
         </param>
+        <param name="lockScreenDismissalEnabled" type="Boolean" mandatory="false">
+            <description>
+                If enabled, the lock screen will be able to be dismissed while connected to SDL, allowing users 
+                the ability to interact with the app. Dismissals should include a warning to the user and ensure 
+                that they are not the driver.
+            </description>
+        </param>
     </function>
 
     <function name="OnPermissionsChange" functionID="OnPermissionsChangeID" messagetype="notification" since="2.0">

src/components/policy/policy_external/include/policy/cache_manager.h

@@ -158,6 +158,14 @@ class CacheManager : public CacheManagerInterface {
    */
   virtual const VehicleInfo GetVehicleInfo() const;
 
+  /**
+   * @brief Returns state of the lock screen that could be able to be dismissed
+   * while connected to SDL, allowing users the ability to interact with the
+   * app.
+   * @return bool True if lock screen is able to be dismissed.
+   */
+  const utils::OptionalVal<bool> LockScreenDismissalEnabledState() const OVERRIDE;
+
   /**
    * @brief Allows to update 'vin' field in module_meta table.
    *

src/components/policy/policy_external/include/policy/cache_manager_interface.h

@@ -35,6 +35,7 @@
 
 #include <string>
 #include <vector>
+#include "utils/optional.h"
 
 #include "policy/policy_table/types.h"
 #include "policy/pt_representation.h"
@@ -165,6 +166,14 @@ class CacheManagerInterface {
    */
   virtual const VehicleInfo GetVehicleInfo() const = 0;
 
+  /**
+   * @brief Returns state of the lock screen that could be able to be dismissed
+   * while connected to SDL, allowing users the ability to interact with the
+   * app.
+   * @return bool True if lock screen is able to be dismissed.
+   */
+  virtual const utils::OptionalVal<bool> LockScreenDismissalEnabledState() const = 0;
+
   /**
    * @brief Allows to update 'vin' field in module_meta table.
    *

src/components/policy/policy_external/include/policy/policy_manager_impl.h

@@ -148,6 +148,14 @@ class PolicyManagerImpl : public PolicyManager {
    */
   void KmsChanged(int kilometers) OVERRIDE;
 
+  /**
+   * @brief Returns state of the lock screen that could be able to be dismissed
+   * while connected to SDL, allowing users the ability to interact with the
+   * app.
+   * @return bool True if lock screen is able to be dismissed.
+   */
+  const utils::OptionalVal<bool> LockScreenDismissalEnabledState() const OVERRIDE;
+
   /**
    * @brief Increments counter of ignition cycles
    */

src/components/policy/policy_external/include/policy/policy_table/types.h

@@ -304,6 +304,7 @@ struct ModuleConfig : CompositeType {
   Optional<String<0, 65535> > certificate;
   Optional<Boolean> preloaded_pt;
   Optional<Boolean> full_app_id_supported;
+  Optional<Boolean> lock_screen_dismissal_enabled;
 
  public:
   ModuleConfig();

src/components/policy/policy_external/src/cache_manager.cc

@@ -42,6 +42,7 @@
 
 #include "utils/file_system.h"
 #include "utils/helpers.h"
+
 #include "json/reader.h"
 #include "json/features.h"
 #include "json/writer.h"
@@ -1389,6 +1390,16 @@ const policy::VehicleInfo CacheManager::GetVehicleInfo() const {
   return vehicle_info;
 }
 
+const utils::OptionalVal<bool> CacheManager::LockScreenDismissalEnabledState() const {
+  CACHE_MANAGER_CHECK(utils::OptionalVal<bool>(utils::OptionalVal<bool>::EMPTY));
+  sync_primitives::AutoLock auto_lock(cache_lock_);
+  policy_table::ModuleConfig& module_config = pt_->policy_table.module_config;
+  if (module_config.lock_screen_dismissal_enabled.is_initialized()) {
+    return utils::OptionalVal<bool>(*module_config.lock_screen_dismissal_enabled);
+  }
+  return utils::OptionalVal<bool>(utils::OptionalVal<bool>::EMPTY);
+}
+
 std::vector<UserFriendlyMessage> CacheManager::GetUserFriendlyMsg(
     const std::vector<std::string>& msg_codes,
     const std::string& language,

src/components/policy/policy_external/src/policy_manager_impl.cc

@@ -1656,6 +1656,11 @@ void PolicyManagerImpl::KmsChanged(int kilometers) {
   }
 }
 
+const utils::OptionalVal<bool> PolicyManagerImpl::LockScreenDismissalEnabledState() const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  return cache_->LockScreenDismissalEnabledState();
+}
+
 void PolicyManagerImpl::IncrementIgnitionCycles() {
   cache_->IncrementIgnitionCycles();
 }

src/components/policy/policy_external/src/policy_table/types.cc

@@ -570,8 +570,9 @@ ModuleConfig::ModuleConfig(const Json::Value* value__)
     , preloaded_date(impl::ValueMember(value__, "preloaded_date"))
     , certificate(impl::ValueMember(value__, "certificate"))
     , preloaded_pt(impl::ValueMember(value__, "preloaded_pt"))
-    , full_app_id_supported(
-          impl::ValueMember(value__, "full_app_id_supported")) {}
+    , full_app_id_supported(impl::ValueMember(value__, "full_app_id_supported"))
+    , lock_screen_dismissal_enabled(
+          impl::ValueMember(value__, "lock_screen_dismissal_enabled")) {}
 
 void ModuleConfig::SafeCopyFrom(const ModuleConfig& from) {
   exchange_after_x_days = from.exchange_after_x_days;
@@ -583,6 +584,7 @@ void ModuleConfig::SafeCopyFrom(const ModuleConfig& from) {
   endpoints = from.endpoints;
   notifications_per_minute_by_priority =
       from.notifications_per_minute_by_priority;
+  lock_screen_dismissal_enabled = from.lock_screen_dismissal_enabled;
 
   certificate.assign_if_valid(from.certificate);
   vehicle_make.assign_if_valid(from.vehicle_make);
@@ -665,6 +667,9 @@ bool ModuleConfig::is_valid() const {
   if (!preloaded_date.is_valid()) {
     return false;
   }
+  if (!lock_screen_dismissal_enabled.is_valid()) {
+    return false;
+  }
   return Validate();
 }
 

src/components/policy/policy_external/src/sql_pt_queries.cc

@@ -76,7 +76,8 @@ const std::string kCreateSchema =
     "  `vehicle_model` VARCHAR(45), "
     "  `vehicle_year` VARCHAR(4), "
     "  `preloaded_date` VARCHAR (10), "
-    "  `certificate` VARCHAR (45) "
+    "  `certificate` VARCHAR (45), "
+    "  `lock_screen_dismissal_enabled` BOOL"
     "); "
     "CREATE TABLE IF NOT EXISTS `functional_group`( "
     "  `id` INTEGER PRIMARY KEY NOT NULL, "
@@ -418,7 +419,7 @@ const std::string kInsertInitData =
     "  VALUES (0, 0, 0, 0); "
     "INSERT OR IGNORE INTO `module_config` (`preloaded_pt`, `is_first_run`,"
     "  `exchange_after_x_ignition_cycles`, `exchange_after_x_kilometers`, "
-    "  `exchange_after_x_days`, `timeout_after_x_seconds`) "
+    "  `exchange_after_x_days`, `timeout_after_x_seconds`)"
     "  VALUES(1, 0, 0, 0, 0, 0); "
     "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('EMERGENCY'); "
     "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('NAVIGATION'); "
@@ -668,7 +669,7 @@ const std::string kUpdateModuleConfig =
     "  `exchange_after_x_kilometers` = ?, `exchange_after_x_days` = ?, "
     "  `timeout_after_x_seconds` = ?, `vehicle_make` = ?, "
     "  `vehicle_model` = ?, `vehicle_year` = ?, `preloaded_date` = ?, "
-    "  `certificate` = ? ";
+    "  `certificate` = ?, lock_screen_dismissal_enabled = ?";
 
 const std::string kInsertEndpoint =
     "INSERT INTO `endpoint` (`service`, `url`, `application_id`) "
@@ -719,7 +720,8 @@ const std::string kSelectModuleConfig =
     "SELECT `preloaded_pt`, `exchange_after_x_ignition_cycles`, "
     " `exchange_after_x_kilometers`, `exchange_after_x_days`, "
     " `timeout_after_x_seconds`, `vehicle_make`,"
-    " `vehicle_model`, `vehicle_year`, `preloaded_date`, `certificate` "
+    " `vehicle_model`, `vehicle_year`, `preloaded_date`, `certificate`, "
+    " `lock_screen_dismissal_enabled` "
     " FROM `module_config`";
 
 const std::string kSelectEndpoints =