Method stop

implementation/runtime/src/application_impl.cpp:536–589

}

void application_impl::stop() {
    std::scoped_lock its_lock_start_stop{start_stop_mutex_};

    VSOMEIP_INFO_P << "Stopping vsomeip application \"" << name_ << "\" (" << hex4(client_) << ").";

    if (stopping_) {
        VSOMEIP_WARNING_P << "Trying to stop an application that is already stopped, stopping_ = " << stopping_;
        return;
    }

    stopping_ = true;
    stop_caller_id_ = std::this_thread::get_id();

    // no need to pass a `shared_ptr`, because by definition the app must be alive if an io thread is still executing!
    boost::asio::post(io_, [this]() {
        // NOTE: quite a few assumptions baked here:
        // 1) if the application did not yet start, it will, and it will start, then stop due to this handler
        // 2) handler executes necessarily after `io.run()`, therefore after routing and dispatching starts

        auto its_plugins = configuration_->get_plugins(name_);
        auto its_app_plugin_info = its_plugins.find(plugin_type_e::APPLICATION_PLUGIN);
        if (its_app_plugin_info != its_plugins.end()) {
            for (const auto& its_library : its_app_plugin_info->second) {
                auto its_application_plugin = plugin_manager_->get_plugin(plugin_type_e::APPLICATION_PLUGIN, its_library);
                if (its_application_plugin) {
                    std::dynamic_pointer_cast<application_plugin>(its_application_plugin)
                            ->on_application_state_change(name_, application_plugin_state_e::STATE_STOPPED);
                }
            }
        }

        {
            std::scoped_lock its_handler_lock{handlers_mutex_};
            is_dispatching_ = false;
            dispatcher_condition_.notify_all();
        }

        if (routing_) {
            routing_->stop();
        }
        {
            // no new handlers can be invoked as the routing_->stop ensures
            // no io thread is pushing any task into the queue
            // -> now we can clear all pending tasks
            std::scoped_lock its_handler_lock{handlers_mutex_};
            subscription_handlers_.clear();
        }
        if (routing_app_) {
            routing_app_->stop();
        }

        io_.stop();
    });
}

void application_impl::process(int _number) {
    (void)_number;