add support for task auto start using zenoh-pico options

Author: DenisBiryukov91

docs/Doxyfile

@@ -2353,7 +2353,7 @@ INCLUDE_FILE_PATTERNS  =
 # recursively expanded use the := operator instead of the = operator.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-PREDEFINED             = ZENOHCXX_ZENOHPICO ZENOHCXX_ZENOHC Z_FEATURE_SHARED_MEMORY Z_FEATURE_UNSTABLE_API __DOXYGEN__
+PREDEFINED             = ZENOHCXX_ZENOHPICO ZENOHCXX_ZENOHC Z_FEATURE_SHARED_MEMORY Z_FEATURE_UNSTABLE_API Z_FEATURE_MULTI_THREAD=1 __DOXYGEN__
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The

include/zenoh/api/session.hxx

@@ -68,21 +68,69 @@ class Session : public Owned<::z_owned_session_t> {
     /// @brief Options to be passed when opening a ``Session``.
     struct SessionOptions {
         /// @name Fields
-#ifdef ZENOHCXX_ZENOHPICO
+#if defined(ZENOHCXX_ZENOHPICO) && Z_FEATURE_MULTI_THREAD == 1
+        /// @brief List of background tasks to auto-start, enabling per task granularity.
+        /// @note Zenoh-pico only.
+        struct BackgroundTasksAutoStartOptions {
+            /// @name Fields
+
+            /// Auto-start read task
+            bool auto_start_read_task = true;
+            /// Auto-start lease task
+            bool auto_start_lease_task = true;
+#if defined(Z_FEATURE_UNSTABLE_API) && Z_FEATURE_PERIODIC_TASKS == 1
+            /// Auto-start periodic scheduler task
+            bool auto_start_periodic_task = true;
+#endif
+            /// @brief Create default auto-start settings.
+            static BackgroundTasksAutoStartOptions create_default() { return {}; }
+        };
+
         /// @brief If ``true``, start background threads which handle the network
         /// traffic. If false, the threads should be called manually with ``Session::start_read_task``,
         /// ``Session::start_lease_task`` and ``Session::start_periodic_scheduler_task``
         /// or methods ``Session::read``, ``Session::send_keep_alive``,
         /// ``Session::send_join`` and ``Session::process_periodic_tasks`` should be called in loop.
+        /// If contains ``BackgroundTasksAutoStartOptions`` value, only enabled tasks will start and the
+        /// remaining ones will need to be started or triggered manually.
         /// @note Zenoh-pico only.
-        bool start_background_tasks = true;
+        std::variant<bool, BackgroundTasksAutoStartOptions> start_background_tasks = true;
 #endif
+        /// @name Methods
+
+        /// @brief Create default option settings.
         static SessionOptions create_default() { return {}; }
+
+       private:
+        friend struct interop::detail::Converter;
+        ::z_open_options_t to_c_opts() {
+            z_open_options_t opts;
+            z_open_options_default(&opts);
+#if defined(ZENOHCXX_ZENOHPICO) && Z_FEATURE_MULTI_THREAD == 1
+            std::visit(
+                detail::commons::overloaded{[&opts](const SessionOptions::BackgroundTasksAutoStartOptions& tasks) {
+                                                opts.auto_start_read_task = tasks.auto_start_read_task;
+                                                opts.auto_start_lease_task = tasks.auto_start_lease_task;
+#if defined(Z_FEATURE_UNSTABLE_API) && Z_FEATURE_PERIODIC_TASKS == 1
+                                                opts.auto_start_periodic_task = tasks.auto_start_periodic_task;
+#endif
+                                            },
+                                            [&opts](const bool& start_all) {
+                                                opts.auto_start_read_task = start_all;
+                                                opts.auto_start_lease_task = start_all;
+#if defined(Z_FEATURE_UNSTABLE_API) && Z_FEATURE_PERIODIC_TASKS == 1
+                                                opts.auto_start_periodic_task = start_all;
+#endif
+                                            }},
+                start_background_tasks);
+#endif
+            return opts;
+        }
     };
 
     /// @brief Options to be passed when closing a ``Session``.
     struct SessionCloseOptions {
-        /// @name Fields
+        /// @name Methods
         static SessionCloseOptions create_default() { return {}; }
     };
 
@@ -95,28 +143,9 @@ class Session : public Owned<::z_owned_session_t> {
     /// thrown in case of error.
     Session(Config&& config, SessionOptions&& options = SessionOptions::create_default(), ZResult* err = nullptr)
         : Owned(nullptr) {
-        __ZENOH_RESULT_CHECK(::z_open(&this->_0, interop::as_moved_c_ptr(config), nullptr), err,
+        z_open_options_t opts = interop::detail::Converter::to_c_opts(options);
+        __ZENOH_RESULT_CHECK(::z_open(&this->_0, interop::as_moved_c_ptr(config), &opts), err,
                              "Failed to open session");
-#ifdef ZENOHCXX_ZENOHPICO
-        if (err != nullptr && *err != Z_OK) return;
-        if (options.start_background_tasks) {
-            ZResult err_inner;
-            this->start_read_task(&err_inner);
-            if (err_inner == Z_OK) {
-                this->start_lease_task(&err_inner);
-            }
-#if defined(Z_FEATURE_UNSTABLE_API) && Z_FEATURE_PERIODIC_TASKS == 1
-            if (err_inner == Z_OK) {
-                this->start_periodic_scheduler_task(&err_inner);
-            }
-#endif
-            if (err_inner == Z_OK) return;
-            ::z_drop(::z_move(this->_0));
-            __ZENOH_RESULT_CHECK(err_inner, err, "Failed to start background tasks");
-        }
-#else
-        (void)options;
-#endif
     }
 
 #if defined(ZENOHCXX_ZENOHC) && defined(Z_FEATURE_SHARED_MEMORY) && defined(Z_FEATURE_UNSTABLE_API)

include/zenoh/detail/commons.hxx

@@ -54,4 +54,13 @@ auto make_transform_iterator(It const& it, F&& f) {
     return TransformIterator<It, F>(it, std::forward<F>(f));
 }
 
+template <class... Ts>
+struct overloaded : Ts... {
+    using Ts::operator()...;
+};
+
+// Some compilers might require this explicit deduction guide
+template <class... Ts>
+overloaded(Ts...) -> overloaded<Ts...>;
+
 }  // namespace zenoh::detail::commons