Start the new PTU after a failed retry sequence

src/components/application_manager/include/application_manager/application_manager_impl.h

@@ -1598,6 +1598,8 @@ class ApplicationManagerImpl
 
   uint32_t apps_size_;
 
+  std::atomic<bool> registered_during_timer_execution_;
+
   volatile bool is_stopping_;
 
   std::unique_ptr<CommandHolder> commands_holder_;

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

@@ -183,9 +183,8 @@ class PolicyHandler : public PolicyHandlerInterface,
                          const std::string& policy_app_id,
                          const std::string& hmi_level) OVERRIDE;
 
-#ifndef EXTERNAL_PROPRIETARY_MODE
   void OnPTUTimeOut() OVERRIDE;
-#endif
+
   /**
    * Gets all allowed module types
    * @param app_id unique identifier of application
@@ -422,6 +421,18 @@ class PolicyHandler : public PolicyHandlerInterface,
    */
   uint32_t GetAppIdForSending() const OVERRIDE;
 
+  /**
+   * @brief Add application to PTU queue if no application with
+   * the same app id exists
+   * @param new_app_id app id new application
+   */
+  void PushAppIdToQueue(const uint32_t new_app_id);
+
+  /**
+   * @brief Remove the first application from applications queue
+   */
+  void PopAppIdFromQueue();
+
   custom_str::CustomString GetAppName(
       const std::string& policy_app_id) OVERRIDE;
 
@@ -583,6 +594,14 @@ class PolicyHandler : public PolicyHandlerInterface,
    */
   void OnAppsSearchCompleted(const bool trigger_ptu) OVERRIDE;
 
+  void OnAddedNewApplicationToAppList(const uint32_t new_app_id,
+                                      const std::string& policy_id) OVERRIDE;
+
+  /**
+   * @brief Queue applications for which PTU has not yet been completed
+   */
+  std::set<uint32_t> queue_applications_for_ptu_;
+
   /**
    * @brief OnAppRegisteredOnMobile allows to handle event when application were
    * succesfully registered on mobile device.
@@ -880,6 +899,7 @@ class PolicyHandler : public PolicyHandlerInterface,
   typedef std::list<PolicyHandlerObserver*> HandlersCollection;
   HandlersCollection listeners_;
   mutable sync_primitives::Lock listeners_lock_;
+  mutable sync_primitives::Lock app_id_queue_lock_;
 
   /**
    * @brief Application-to-device links are used for collecting their current
@@ -894,6 +914,8 @@ class PolicyHandler : public PolicyHandlerInterface,
   std::shared_ptr<StatisticManagerImpl> statistic_manager_impl_;
   const PolicySettings& settings_;
   application_manager::ApplicationManager& application_manager_;
+  std::string last_registered_policy_app_id_;
+
   friend class AppPermissionDelegate;
 
   /**

src/components/application_manager/src/application_manager_impl.cc

@@ -193,6 +193,7 @@ ApplicationManagerImpl::ApplicationManagerImpl(
               this, &ApplicationManagerImpl::OnTimerSendTTSGlobalProperties))
     , is_low_voltage_(false)
     , apps_size_(0)
+    , registered_during_timer_execution_(false)
     , is_stopping_(false) {
   std::srand(std::time(nullptr));
   AddPolicyObserver(this);
@@ -3782,7 +3783,7 @@ bool ApplicationManagerImpl::IsHMICooperating() const {
 
 void ApplicationManagerImpl::OnApplicationListUpdateTimer() {
   LOG4CXX_DEBUG(logger_, "Application list update timer finished");
-
+  registered_during_timer_execution_ = false;
   apps_to_register_list_lock_ptr_->Acquire();
   const bool trigger_ptu = apps_size_ != applications_.size();
   apps_to_register_list_lock_ptr_->Release();
@@ -4244,6 +4245,12 @@ void ApplicationManagerImpl::AddAppToRegisteredAppList(
       logger_,
       "App with app_id: " << application->app_id()
                           << " has been added to registered applications list");
+  if (application_list_update_timer_.is_running() &&
+      !registered_during_timer_execution_) {
+    GetPolicyHandler().OnAddedNewApplicationToAppList(
+        application->app_id(), application->policy_app_id());
+    registered_during_timer_execution_ = true;
+  }
   apps_size_ = static_cast<uint32_t>(applications_.size());
 }
 

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

@@ -301,7 +301,8 @@ PolicyHandler::PolicyHandler(const PolicySettings& settings,
     , last_activated_app_id_(0)
     , statistic_manager_impl_(std::make_shared<StatisticManagerImpl>(this))
     , settings_(settings)
-    , application_manager_(application_manager) {}
+    , application_manager_(application_manager)
+    , last_registered_policy_app_id_("") {}
 
 PolicyHandler::~PolicyHandler() {}
 
@@ -465,6 +466,26 @@ uint32_t PolicyHandler::GetAppIdForSending() const {
   return ChooseRandomAppForPolicyUpdate(apps_with_none_level);
 }
 
+void PolicyHandler::PushAppIdToQueue(const uint32_t app_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(app_id_queue_lock_);
+  const auto result = queue_applications_for_ptu_.insert(app_id);
+  if (result.second) {
+    policy_manager_->OnChangeApplicationCount(
+        queue_applications_for_ptu_.size());
+  }
+}
+
+void PolicyHandler::PopAppIdFromQueue() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(app_id_queue_lock_);
+  if (queue_applications_for_ptu_.size() > 0) {
+    queue_applications_for_ptu_.erase(queue_applications_for_ptu_.begin());
+    policy_manager_->OnChangeApplicationCount(
+        queue_applications_for_ptu_.size());
+  }
+}
+
 #ifdef EXTERNAL_PROPRIETARY_MODE
 PTURetryHandler& PolicyHandler::ptu_retry_handler() const {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -1116,7 +1137,7 @@ bool PolicyHandler::ReceiveMessageFromSDK(const std::string& file,
   const bool is_ptu_successful =
       load_pt_result == PolicyManager::PtProcessingResult::kSuccess;
   OnPTUFinished(is_ptu_successful);
-
+  PopAppIdFromQueue();
   if (is_ptu_successful) {
     LOG4CXX_INFO(logger_, "PTU was successful.");
     policy_manager_->CleanupUnpairedDevices();
@@ -1492,11 +1513,13 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& device_id,
                     << policy_app_id << " and connection_key "
                     << app->app_id());
 }
-#ifndef EXTERNAL_PROPRIETARY_MODE
+
 void PolicyHandler::OnPTUTimeOut() {
+  PopAppIdFromQueue();
+#ifndef EXTERNAL_PROPRIETARY_MODE
   application_manager_.protocol_handler().ProcessFailedPTU();
-}
 #endif
+}
 
 bool PolicyHandler::SaveSnapshot(const BinaryMessage& pt_string,
                                  std::string& snap_path) {
@@ -1539,9 +1562,11 @@ void PolicyHandler::OnSnapshotCreated(const BinaryMessage& pt_string,
   POLICY_LIB_CHECK_VOID();
 #ifdef PROPRIETARY_MODE
   std::string policy_snapshot_full_path;
-  if (!SaveSnapshot(pt_string, policy_snapshot_full_path)) {
-    LOG4CXX_ERROR(logger_, "Snapshot processing skipped.");
-    return;
+  if (PTUIterationType::RetryIteration != iteration_type) {
+    if (!SaveSnapshot(pt_string, policy_snapshot_full_path)) {
+      LOG4CXX_ERROR(logger_, "Snapshot processing skipped.");
+      return;
+    }
   }
 
   if (PTUIterationType::RetryIteration == iteration_type) {
@@ -1907,7 +1932,9 @@ void PolicyHandler::OnAuthTokenUpdated(const std::string& policy_app_id,
 void PolicyHandler::OnPTUFinished(const bool ptu_result) {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock lock(listeners_lock_);
-
+  if (!ptu_result) {
+    PopAppIdFromQueue();
+  }
   std::for_each(
       listeners_.begin(),
       listeners_.end(),
@@ -2205,6 +2232,16 @@ void PolicyHandler::OnAppsSearchCompleted(const bool trigger_ptu) {
   policy_manager_->OnAppsSearchCompleted(trigger_ptu);
 }
 
+void PolicyHandler::OnAddedNewApplicationToAppList(
+    const uint32_t new_app_id, const std::string& policy_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  if (policy_id == last_registered_policy_app_id_) {
+    return;
+  }
+  last_registered_policy_app_id_ = policy_id;
+  PushAppIdToQueue(new_app_id);
+}
+
 void PolicyHandler::OnAppRegisteredOnMobile(const std::string& device_id,
                                             const std::string& application_id) {
   POLICY_LIB_CHECK_VOID();

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

@@ -410,6 +410,14 @@ class PolicyHandlerInterface : public VehicleDataItemProvider {
    */
   virtual void OnAppsSearchCompleted(const bool trigger_ptu) = 0;
 
+  /**
+   * @brief Notify that new applocation was added to application list
+   * @param new_app_id app_id for this application
+   * @param policy_id policy_id for this application
+   */
+  virtual void OnAddedNewApplicationToAppList(const uint32_t new_app_id,
+                                              const std::string& policy_id) = 0;
+
   /**
    * @brief OnAppRegisteredOnMobile allows to handle event when application were
    * succesfully registered on mobile device.
@@ -652,6 +660,12 @@ class PolicyHandlerInterface : public VehicleDataItemProvider {
                                  const std::string& policy_app_id,
                                  const std::string& hmi_level) = 0;
 
+  /**
+   * @brief OnPTUTimeOut the callback which is performed when PTU timeout
+   * occurred
+   */
+  virtual void OnPTUTimeOut() = 0;
+
   /**
    * Gets all allowed module types
    * @param app_id unique identifier of application

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

@@ -533,6 +533,12 @@ class PolicyManager : public usage_statistics::StatisticsManager,
    */
   virtual void OnAppsSearchCompleted(const bool trigger_ptu) = 0;
 
+  /**
+   * @brief Change applications count ready for PTU
+   * @param new_app_count new applications count for PTU
+   */
+  virtual void OnChangeApplicationCount(const uint32_t new_app_count) = 0;
+
   /**
    * @brief OnAppRegisteredOnMobile allows to handle event when application were
    * succesfully registered on mobile device.

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

@@ -121,7 +121,8 @@ class PolicyListener {
   virtual void OnCertificateUpdated(const std::string& certificate_data) = 0;
 
   /**
-   * @brief OnPTUTimeOut the callback which signals if PTU timeout occured
+   * @brief OnPTUTimeOut the callback which is performed when PTU timeout
+   * occurred
    */
   virtual void OnPTUTimeOut() = 0;
 

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

@@ -524,6 +524,12 @@ class PolicyManager : public usage_statistics::StatisticsManager,
    */
   virtual void OnAppsSearchCompleted(const bool trigger_ptu) = 0;
 
+  /**
+   * @brief Change applications count ready for PTU
+   * @param new_app_count new applications count for PTU
+   */
+  virtual void OnChangeApplicationCount(const uint32_t new_app_count) = 0;
+
   /**
    * @brief Get state of request types for given application
    * @param policy_app_id Unique application id

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

@@ -219,6 +219,8 @@ class MockPolicyHandlerInterface : public policy::PolicyHandlerInterface {
   MOCK_CONST_METHOD1(HeartBeatTimeout, uint32_t(const std::string& app_id));
   MOCK_METHOD0(OnAppsSearchStarted, void());
   MOCK_METHOD1(OnAppsSearchCompleted, void(const bool trigger_ptu));
+  MOCK_METHOD2(OnAddedNewApplicationToAppList,
+               void(const uint32_t new_app_id, const std::string& policy_id));
   MOCK_METHOD2(OnAppRegisteredOnMobile,
                void(const std::string& device_id,
                     const std::string& application_id));
@@ -316,6 +318,7 @@ class MockPolicyHandlerInterface : public policy::PolicyHandlerInterface {
                void(const std::string& device_id,
                     const std::string& policy_app_id,
                     const std::string& hmi_level));
+  MOCK_METHOD0(OnPTUTimeOut, void());
   MOCK_CONST_METHOD2(GetModuleTypes,
                      bool(const std::string& policy_app_id,
                           std::vector<std::string>* modules));

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

@@ -212,6 +212,7 @@ class MockPolicyManager : public PolicyManager {
   MOCK_METHOD1(SaveUpdateStatusRequired, void(bool is_update_needed));
   MOCK_METHOD0(OnAppsSearchStarted, void());
   MOCK_METHOD1(OnAppsSearchCompleted, void(const bool trigger_ptu));
+  MOCK_METHOD1(OnChangeApplicationCount, void(const uint32_t new_app_count));
   MOCK_METHOD2(OnAppRegisteredOnMobile,
                void(const std::string& device_id,
                     const std::string& application_id));

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

@@ -210,6 +210,7 @@ class MockPolicyManager : public PolicyManager {
   MOCK_METHOD1(SaveUpdateStatusRequired, void(bool is_update_needed));
   MOCK_METHOD0(OnAppsSearchStarted, void());
   MOCK_METHOD1(OnAppsSearchCompleted, void(const bool trigger_ptu));
+  MOCK_METHOD1(OnChangeApplicationCount, void(const uint32_t new_app_count));
   MOCK_METHOD2(OnAppRegisteredOnMobile,
                void(const std::string& device_id,
                     const std::string& application_id));

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

@@ -608,6 +608,12 @@ class PolicyManagerImpl : public PolicyManager {
    */
   void OnAppsSearchCompleted(const bool trigger_ptu) OVERRIDE;
 
+  /**
+   * @brief Change applications count ready for PTU
+   * @param new_app_count new applications count for PTU
+   */
+  void OnChangeApplicationCount(const uint32_t new_app_count) OVERRIDE;
+
   /**
    * @brief Get state of request types for given application
    * @param policy_app_id Unique application id
@@ -1096,6 +1102,11 @@ class PolicyManagerImpl : public PolicyManager {
   bool IsPTValid(std::shared_ptr<policy_table::Table> policy_table,
                  policy_table::PolicyTableType type) const;
 
+  /**
+   * @brief Check that new applications for PTU were registered
+   */
+  bool HasApplicationForPTU() const;
+
   /**
    * @brief Get resulting RPCs permissions for application which started on
    * specific device
@@ -1305,6 +1316,11 @@ class PolicyManagerImpl : public PolicyManager {
    */
   uint32_t retry_sequence_index_;
 
+  /**
+   * @brief Applications pending count ready for PTU
+   */
+  uint32_t applications_pending_ptu_count_;
+
   /**
    * @brief Lock for guarding retry sequence
    */
@@ -1344,6 +1360,11 @@ class PolicyManagerImpl : public PolicyManager {
    */
   bool trigger_ptu_;
 
+  /**
+   * @brief Flag for notifying that PTU was requested
+   */
+  bool ptu_requested_;
+
   /**
    * @brief Flag that indicates whether a PTU sequence (including retries) is in
    * progress

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

@@ -55,7 +55,8 @@ enum UpdateEvent {
   kPendingUpdate,
   kScheduleManualUpdate,
   kOnResetRetrySequence,
-  kNoEvent
+  kNoEvent,
+  kUpdateForNextInQueue
 };
 
 const std::string kUpToDate = "UP_TO_DATE";

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

@@ -91,6 +91,12 @@ class UpdateStatusManager {
    */
   void OnUpdateTimeoutOccurs();
 
+  /**
+   * @brief Update status for next in queue application
+   * after previous update been has finished
+   */
+  void OnUpdateForNextInQueue();
+
   /**
    * @brief Update status handler for valid PTU receiving
    */