Add background timeouts for iOS (#1531)

It is expected the background downloading is longer than the foreground
one. And even more on iOS the app is not really performing background
downloading. So it is better to have separate timeouts.

Relates-To: DATASDK-19

Signed-off-by: Rustam Gamidov <ext-rustam.gamidov@here.com>

Author: rustam-gamidov-here

olp-cpp-sdk-core/CMakeLists.txt

@@ -413,7 +413,7 @@ add_library(${PROJECT_NAME} ${OLP_SDK_CORE_SOURCES} ${OLP_SDK_CORE_HEADERS})
 
 if (OLP_SDK_ENABLE_IOS_BACKGROUND_DOWNLOAD)
     target_compile_definitions(${PROJECT_NAME}
-        PRIVATE OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD)
+        PUBLIC OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD)
 endif()
 
 if (OLP_SDK_DISABLE_DEBUG_LOGGING)

olp-cpp-sdk-core/include/olp/core/client/RetrySettings.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2023 HERE Europe B.V.
+ * Copyright (C) 2021-2024 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -76,6 +76,18 @@ struct CORE_API RetrySettings {
    */
   int timeout = 60;
 
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+  /**
+   * @brief Maximum time for background request to complete (in seconds).
+   *
+   * The default value is 600.
+   *
+   * @note Connection or data transfer will be interrupted after specified
+   * period of time ignoring `connection_timeout` and `transfer_timeout` values.
+   */
+  int background_timeout = 600;
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
   /**
    * @brief Time allowed to wait for connection to establish (in milliseconds).
    *
@@ -86,6 +98,20 @@ struct CORE_API RetrySettings {
    */
   std::chrono::milliseconds connection_timeout = std::chrono::seconds(30);
 
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+  /**
+   * @brief Time allowed to wait for background connection to establish (in
+   * milliseconds).
+   *
+   * The default value is 600 seconds.
+   *
+   * @note The value should be smaller than `timeout`, @see `timeout` for more
+   * details.
+   */
+  std::chrono::milliseconds background_connection_timeout =
+      std::chrono::seconds(600);
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
   /**
    * @brief Time allowed to wait without data transfer (in milliseconds).
    *

olp-cpp-sdk-core/include/olp/core/http/NetworkSettings.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 HERE Europe B.V.
+ * Copyright (C) 2019-2024 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -71,6 +71,15 @@ class CORE_API NetworkSettings final {
    */
   std::chrono::milliseconds GetConnectionTimeoutDuration() const;
 
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+  /**
+   * @brief Gets the background connection timeout.
+   *
+   * @return The background connection timeout.
+   */
+  std::chrono::milliseconds GetBackgroundConnectionTimeoutDuration() const;
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
   /**
    * @brief Sets the connection timeout in seconds.
    *
@@ -92,6 +101,18 @@ class CORE_API NetworkSettings final {
    */
   NetworkSettings& WithConnectionTimeout(std::chrono::milliseconds timeout);
 
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+  /**
+   * @brief Sets the background connection timeout.
+   *
+   * @param[in] timeout The background connection timeout.
+   *
+   * @return A reference to *this.
+   */
+  NetworkSettings& WithBackgroundConnectionTimeout(
+      std::chrono::milliseconds timeout);
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
   /**
    * @brief Gets the transfer timeout in seconds.
    *
@@ -186,6 +207,11 @@ class CORE_API NetworkSettings final {
   std::size_t retries_{3};
   /// The connection timeout.
   std::chrono::milliseconds connection_timeout_ = std::chrono::seconds(60);
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+  /// The background connection timeout.
+  std::chrono::milliseconds background_connection_timeout_ =
+      std::chrono::seconds(600);
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
   /// The transfer timeout.
   std::chrono::milliseconds transfer_timeout_ = std::chrono::seconds(30);
   /// The max lifetime since creation allowed for reusing a connection.

olp-cpp-sdk-core/src/client/OlpClient.cpp

@@ -35,6 +35,11 @@
 #include "olp/core/thread/Atomic.h"
 #include "olp/core/utils/Url.h"
 
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+#include "context/ContextInternal.h"
+#include "olp/core/context/EnterBackgroundSubscriber.h"
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
 namespace {
 constexpr auto kLogTag = "OlpClient";
 constexpr auto kApiKeyParam = "apiKey=";
@@ -52,6 +57,75 @@ struct RequestSettings {
   std::chrono::milliseconds current_backdown_period{0};
   const std::chrono::milliseconds max_wait_time{0};
 };
+
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+class EnterBackgroundSubscriberImpl
+    : public olp::context::EnterBackgroundSubscriber {
+ public:
+  struct Timeouts {
+    std::chrono::seconds foreground_timeout{0};
+    std::chrono::seconds background_timeout{0};
+  };
+
+  void OnEnterBackground() override {
+    std::lock_guard<std::mutex> lock(mutex_);
+    in_background_ = true;
+    std::for_each(states_.begin(), states_.end(),
+                  [&](bool value) { value = true; });
+  }
+
+  void OnExitBackground() override {
+    std::lock_guard<std::mutex> lock(mutex_);
+    in_background_ = false;
+  }
+
+  bool Wait(olp::client::Condition& client_condition, Timeouts timeouts) {
+    std::list<bool>::iterator state_itr;
+
+    auto init_state = [&]() -> bool {
+      std::lock_guard<std::mutex> lock(mutex_);
+      state_itr = states_.insert(states_.end(), in_background_);
+      return in_background_;
+    };
+
+    auto pop_state = [&]() -> bool {
+      std::lock_guard<std::mutex> lock(mutex_);
+      bool state = *state_itr;
+      states_.erase(state_itr);
+      return state;
+    };
+
+    const bool started_in_background = init_state();
+    const auto condition_triggered = client_condition.Wait(
+        started_in_background ? timeouts.background_timeout
+                              : timeouts.foreground_timeout);
+
+    const bool stored_state = pop_state();
+    if ((condition_triggered &&
+         (started_in_background || started_in_background == stored_state)) ||
+        timeouts.background_timeout <= timeouts.foreground_timeout) {
+      return condition_triggered;
+    }
+
+    return client_condition.Wait(timeouts.background_timeout -
+                                 timeouts.foreground_timeout);
+  }
+
+ private:
+  std::mutex mutex_;
+  bool in_background_ = false;
+  std::list<bool> states_;
+};
+
+static std::shared_ptr<EnterBackgroundSubscriberImpl> gBackgroundSubscriber =
+    []() {
+      auto impl = std::make_shared<EnterBackgroundSubscriberImpl>();
+      olp::context::ContextInternal::SubscribeEnterBackground(impl);
+      return impl;
+    }();
+
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
 }  // namespace
 
 namespace olp {
@@ -285,6 +359,10 @@ HttpResponse SendRequest(const http::NetworkRequest& request,
 
   http::SendOutcome outcome{http::ErrorCode::CANCELLED_ERROR};
   const auto timeout = std::chrono::seconds(retry_settings.timeout);
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+  const auto background_timeout =
+      std::chrono::seconds(retry_settings.background_timeout);
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
 
   context.ExecuteOrCancelled(
       [&]() {
@@ -321,7 +399,14 @@ HttpResponse SendRequest(const http::NetworkRequest& request,
     return ToHttpResponse(outcome);
   }
 
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+  auto backgroundSubscriber = gBackgroundSubscriber;
+  const auto condition_triggered = backgroundSubscriber->Wait(
+      response_data->condition, {timeout, background_timeout});
+#else
   const auto condition_triggered = response_data->condition.Wait(timeout);
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
   if (!condition_triggered) {
     OLP_SDK_LOG_WARNING_F(
         kLogTag,
@@ -605,6 +690,10 @@ CancellationToken OlpClient::OlpClientImpl::CallApi(
   network_request->WithSettings(
       http::NetworkSettings()
           .WithConnectionTimeout(retry_settings.connection_timeout)
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+          .WithBackgroundConnectionTimeout(
+              retry_settings.background_connection_timeout)
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
           .WithTransferTimeout(retry_settings.transfer_timeout)
           .WithProxySettings(std::move(proxy)));
 
@@ -642,6 +731,10 @@ HttpResponse OlpClient::OlpClientImpl::CallApi(
       http::NetworkSettings()
           .WithTransferTimeout(retry_settings.transfer_timeout)
           .WithConnectionTimeout(retry_settings.connection_timeout)
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+          .WithBackgroundConnectionTimeout(
+              retry_settings.background_connection_timeout)
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
           .WithProxySettings(
               settings_.proxy_settings.value_or(http::NetworkProxySettings()));
 

olp-cpp-sdk-core/src/http/NetworkSettings.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 HERE Europe B.V.
+ * Copyright (C) 2019-2024 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,6 +35,13 @@ std::chrono::milliseconds NetworkSettings::GetConnectionTimeoutDuration()
   return connection_timeout_;
 }
 
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+std::chrono::milliseconds
+NetworkSettings::GetBackgroundConnectionTimeoutDuration() const {
+  return background_connection_timeout_;
+}
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
 int NetworkSettings::GetTransferTimeout() const {
   return static_cast<int>(std::chrono::duration_cast<std::chrono::seconds>(
                               GetTransferTimeoutDuration())
@@ -72,6 +79,14 @@ NetworkSettings& NetworkSettings::WithConnectionTimeout(
   return *this;
 }
 
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+NetworkSettings& NetworkSettings::WithBackgroundConnectionTimeout(
+    std::chrono::milliseconds timeout) {
+  background_connection_timeout_ = timeout;
+  return *this;
+}
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
 NetworkSettings& NetworkSettings::WithTransferTimeout(int timeout) {
   return WithTransferTimeout(std::chrono::seconds(timeout));
 }

olp-cpp-sdk-core/src/http/ios/OLPHttpTask.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2023 HERE Europe B.V.
+ * Copyright (C) 2019-2024 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -80,6 +80,10 @@ typedef void (^OLPHttpTaskCompletionHandler)(NSError* error,
 
 @property(nonatomic) NSUInteger connectionTimeout;
 
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+@property(nonatomic) NSUInteger backgroundConnectionTimeout;
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
 @property(nonatomic) std::shared_ptr<std::ostream> payload;
 
 // Readonly

olp-cpp-sdk-core/src/http/ios/OLPHttpTask.mm

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2023 HERE Europe B.V.
+ * Copyright (C) 2019-2024 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,7 +27,6 @@
 
 namespace {
 constexpr auto kLogTag = "OLPHttpTask";
-constexpr auto kBackgroundTimeoutMultiplicator = 100u;
 }  // namespace
 
 #pragma mark - OLPHttpTaskResponseData
@@ -106,9 +105,11 @@ - (OLPHttpTaskStatus)restart {
   NSMutableURLRequest* request =
       [NSMutableURLRequest requestWithURL:[NSURL URLWithString:self.url]];
   request.timeoutInterval = self.connectionTimeout;
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
   if (self.backgroundMode) {
-    request.timeoutInterval *= kBackgroundTimeoutMultiplicator;
+    request.timeoutInterval = self.backgroundConnectionTimeout;
   }
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
   request.HTTPMethod = self.HTTPMethod;
   if (self.body.length) {
     request.HTTPBody = self.body;

olp-cpp-sdk-core/src/http/ios/OLPNetworkIOS.mm

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2023 HERE Europe B.V.
+ * Copyright (C) 2019-2024 HERE Europe B.V.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -181,6 +181,15 @@
     task.headers = ParseHeadersDictionaryFromRequest(request);
     task.responseData = [[OLPHttpTaskResponseData alloc] init];
 
+#ifdef OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+    const auto backgroundConnectionTimeoutSeconds =
+        std::chrono::duration_cast<std::chrono::seconds>(
+            settings.GetBackgroundConnectionTimeoutDuration())
+            .count();
+    task.backgroundConnectionTimeout =
+        static_cast<int>(backgroundConnectionTimeoutSeconds);
+#endif  // OLP_SDK_NETWORK_IOS_BACKGROUND_DOWNLOAD
+
     __weak OLPHttpTask* weak_task = task;
     auto requestId = task.requestId;