Method on_subscription

implementation/runtime/src/application_impl.cpp:1006–1043

}

void application_impl::on_subscription(service_t _service, instance_t _instance, eventgroup_t _eventgroup, client_t _client,
                                       const vsomeip_sec_client_t* _sec_client, const std::string& _env, bool _subscribed,
                                       const std::function<void(bool)>& _accepted_cb) {

    // A sync_handler needs to be created to guarantee order of callback invocations,
    // irrespective of (un)registration of any handler
    auto its_sync_handler =
            std::make_shared<sync_handler>([this, _service, _instance, _eventgroup, _client, _subscribed, sec_client = *_sec_client,
                                            env = _env, continuation = _accepted_cb, weak_self = weak_from_this()] {
                if (auto self = weak_self.lock(); self) {
                    subscription_handler_sec_t handler;
                    async_subscription_handler_sec_t async_handler;
                    {
                        std::scoped_lock its_lock{subscription_mutex_};
                        if (auto found_si = subscription_.find({_service, _instance}); found_si != subscription_.end()) {
                            if (auto found_eventgroup = found_si->second.find(_eventgroup); found_eventgroup != found_si->second.end()) {
                                std::tie(handler, async_handler) = found_eventgroup->second;
                            }
                        }
                    }
                    if (handler) {
                        continuation(handler(_client, &sec_client, env, _subscribed));
                    } else if (async_handler) {
                        async_handler(_client, &sec_client, env, _subscribed, continuation);
                    } else {
                        continuation(true);
                    }
                }
            });
    its_sync_handler->service_id_ = _service;
    its_sync_handler->instance_id_ = _instance;
    its_sync_handler->eventgroup_id_ = _eventgroup;
    its_sync_handler->client_id_ = _client;
    its_sync_handler->handler_type_ = handler_type_e::SUBSCRIPTION;
    std::scoped_lock handlers_lock(handlers_mutex_);
    handlers_.push_back(its_sync_handler);
    dispatcher_condition_.notify_all();
}

void application_impl::register_subscription_handler(service_t _service, instance_t _instance, eventgroup_t _eventgroup,
                                                     const subscription_handler_t& _handler) {