BundleContext.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#pragma once
 
#include <memory>
#include <mutex>
#include <thread>
#include <cstdarg>
 
#include "celix_bundle_context.h"
 
#include "celix/ServiceRegistrationBuilder.h"
#include "celix/UseServiceBuilder.h"
#include "celix/TrackerBuilders.h"
#include "celix/ScheduledEventBuilder.h"
#include "celix/Bundle.h"
#include "celix/Framework.h"
 
#include "celix/dm/DependencyManager.h"
 
namespace celix {
 
    class BundleContext {
    public:
        explicit BundleContext(celix_bundle_context_t* _cCtx) :
            cCtx{_cCtx, [](celix_bundle_context_t*){/*nop*/}},
            dm{std::make_shared<celix::dm::DependencyManager>(_cCtx)},
            bnd{celix_bundleContext_getBundle(_cCtx)} {}
 
        template<typename I, typename Implementer>
        ServiceRegistrationBuilder<I> registerService(std::shared_ptr<Implementer> implementer, const std::string& name = {}) {
            std::shared_ptr<I> svc = implementer; //note Implement should be derived from I
            return ServiceRegistrationBuilder<I>{cCtx, std::move(svc), celix::typeName<I>(name)};
        }
 
        template<typename I, typename Implementer>
        ServiceRegistrationBuilder<I> registerUnmanagedService(Implementer* svc, const std::string& name = {}) {
            auto unmanagedSvc = std::shared_ptr<I>{svc, [](I*){/*nop*/}};
            return ServiceRegistrationBuilder<I>{cCtx, std::move(unmanagedSvc), celix::typeName<I>(name), true, false};
        }
 
        //TODO registerServiceFactory<I>()
 
        template<typename I>
        UseServiceBuilder<I> useService(const std::string& name = {}) {
            return UseServiceBuilder<I>{cCtx, celix::typeName<I>(name), true};
        }
 
        template<typename I>
        UseServiceBuilder<I> useServices(const std::string& name = {}) {
            return UseServiceBuilder<I>{cCtx, celix::typeName<I>(name), false};
        }
 
        template<typename I>
        long findService(const std::string& filter = {}, const std::string& versionRange = {}) {
            return findServiceWithName(celix::typeName<I>(), filter, versionRange);
        }
 
        long findServiceWithName(const std::string& name, const std::string& filter = {}, const std::string& versionRange = {}) {
            waitIfAbleForEvents();
            celix_service_filter_options_t opts{};
            opts.serviceName = name.empty() ? nullptr : name.data();
            opts.filter = filter.empty() ? nullptr : filter.data();
            opts.versionRange = versionRange.empty() ? nullptr : versionRange.data();
            return celix_bundleContext_findServiceWithOptions(cCtx.get(), &opts);
        }
 
        template<typename I>
        std::vector<long> findServices(const std::string& filter = {}, const std::string& versionRange = {}) {
            return findServicesWithName(celix::typeName<I>(), filter, versionRange);
        }
 
        std::vector<long> findServicesWithName(const std::string& name, const std::string& filter = {}, const std::string& versionRange = {}) {
            return findServicesWithNameInternal(
                    name.empty() ? nullptr : name.c_str(),
                    filter.empty() ? nullptr : filter.c_str(),
                    versionRange.empty() ? nullptr : versionRange.c_str());
        }
 
        template<typename I>
        ServiceTrackerBuilder<I> trackServices(const std::string& name = {}) {
            return ServiceTrackerBuilder<I>{cCtx, celix::typeName<I>(name)};
        }
 
        ServiceTrackerBuilder<void> trackAnyServices() {
            return ServiceTrackerBuilder<void>{cCtx, {}};
        }
 
        //TODO UseBundleBuilder useBundles()
 
        BundleTrackerBuilder trackBundles() {
            return BundleTrackerBuilder{cCtx};
        }
 
        template<typename I>
        MetaTrackerBuilder trackServiceTrackers(const std::string& name = {}) {
            return MetaTrackerBuilder(cCtx, celix::typeName<I>(name));
        }
 
        MetaTrackerBuilder trackAnyServiceTrackers() {
            return MetaTrackerBuilder(cCtx, {});
        }
 
        ScheduledEventBuilder scheduledEvent() {
            return ScheduledEventBuilder{cCtx};
        }
 
        long installBundle(const std::string& bndLocation, bool autoStart = true) {
            return celix_bundleContext_installBundle(cCtx.get(), bndLocation.c_str(), autoStart);
        }
 
        bool uninstallBundle(long bndId) {
            return celix_bundleContext_uninstallBundle(cCtx.get(), bndId);
        }
 
        bool startBundle(long bndId) {
            return celix_bundleContext_startBundle(cCtx.get(), bndId);
        }
 
        bool stopBundle(long bndId) {
            return celix_bundleContext_stopBundle(cCtx.get(), bndId);
        }
 
        bool updateBundle(long bndId, const std::string& updatedBundleUrl = {}) {
            return celix_bundleContext_updateBundle(cCtx.get(), bndId, updatedBundleUrl.empty() ? nullptr : updatedBundleUrl.data());
        }
 
        std::vector<long> listBundleIds() const {
            return listBundlesInternal(true);
        }
 
        std::vector<long> listInstalledBundleIds() {
            return listBundlesInternal(false);
        }
 
        std::string getConfigProperty(const std::string& name, const std::string& defaultValue) const {
            return std::string{celix_bundleContext_getProperty(cCtx.get(), name.c_str(), defaultValue.c_str())};
        }
 
        long getConfigPropertyAsLong(const std::string& name, long defaultValue) const {
            return celix_bundleContext_getPropertyAsLong(cCtx.get(), name.c_str(), defaultValue);
        }
 
        double getConfigPropertyAsDouble(const std::string& name, double defaultValue) const {
            return celix_bundleContext_getPropertyAsDouble(cCtx.get(), name.c_str(), defaultValue);
        }
 
        long getConfigPropertyAsBool(const std::string& name, bool defaultValue) const {
            return celix_bundleContext_getPropertyAsBool(cCtx.get(), name.c_str(), defaultValue);
        }
 
        const Bundle& getBundle() const {
            return bnd;
        }
 
        long getBundleId() const {
             return bnd.getId();
         }
 
        std::shared_ptr<Framework> getFramework() const {
            auto* cFw = celix_bundleContext_getFramework(cCtx.get());
            auto fwCtx = std::make_shared<celix::BundleContext>(celix_framework_getFrameworkContext(cFw));
            return std::make_shared<Framework>(fwCtx, cFw);
        }
 
        std::shared_ptr<dm::DependencyManager> getDependencyManager() const {
            return dm;
        }
 
        celix_bundle_context_t* getCBundleContext() const {
            return cCtx.get();
        }
 
        void logTrace(const char* format...) __attribute__((format(printf,2,3))) {
            va_list args;
            va_start(args, format);
            celix_bundleContext_vlog(cCtx.get(), CELIX_LOG_LEVEL_TRACE, format, args);
            va_end(args);
        }
 
        void logDebug(const char* format...) __attribute__((format(printf,2,3))) {
            va_list args;
            va_start(args, format);
            celix_bundleContext_vlog(cCtx.get(), CELIX_LOG_LEVEL_DEBUG, format, args);
            va_end(args);
        }
 
        void logInfo(const char* format...) __attribute__((format(printf,2,3))) {
            va_list args;
            va_start(args, format);
            celix_bundleContext_vlog(cCtx.get(), CELIX_LOG_LEVEL_INFO, format, args);
            va_end(args);
        }
 
        void logWarn(const char* format...) __attribute__((format(printf,2,3))) {
            va_list args;
            va_start(args, format);
            celix_bundleContext_vlog(cCtx.get(), CELIX_LOG_LEVEL_WARNING, format, args);
            va_end(args);
        }
 
        void logError(const char* format...) __attribute__((format(printf,2,3))) {
            va_list args;
            va_start(args, format);
            celix_bundleContext_vlog(cCtx.get(), CELIX_LOG_LEVEL_ERROR, format, args);
            va_end(args);
        }
 
        void logFatal(const char* format...) __attribute__((format(printf,2,3))) {
            va_list args;
            va_start(args, format);
            celix_bundleContext_vlog(cCtx.get(), CELIX_LOG_LEVEL_FATAL, format, args);
            va_end(args);
        }
 
        void logTssErrors(celix_log_level_e level) {
            celix_bundleContext_logTssErrors(cCtx.get(), level);
        }
 
        void waitForEvents() const {
            celix_bundleContext_waitForEvents(cCtx.get());
        }
 
        void waitIfAbleForEvents() const {
            auto* fw = celix_bundleContext_getFramework(cCtx.get());
            if (!celix_framework_isCurrentThreadTheEventLoop(fw)) {
                celix_bundleContext_waitForEvents(cCtx.get());
            }
        }
 
        void waitForAllEvents() const {
            auto* fw = celix_bundleContext_getFramework(cCtx.get());
            celix_framework_waitForEmptyEventQueue(fw);
        }
 
         void waitIfAbleForAllEvents() const {
            auto* fw = celix_bundleContext_getFramework(cCtx.get());
            if (!celix_framework_isCurrentThreadTheEventLoop(fw)) {
                celix_framework_waitForEmptyEventQueue(fw);
            }
         }
    private:
        std::vector<long> listBundlesInternal(bool activeOnly) const {
            std::vector<long> result{};
            auto* ids = activeOnly ?
                        celix_bundleContext_listBundles(getCBundleContext()) :
                        celix_bundleContext_listInstalledBundles(getCBundleContext());
            result.reserve(celix_arrayList_size(ids));
            for (int i = 0; i < celix_arrayList_size(ids); ++i) {
                result.push_back(celix_arrayList_getLong(ids, i));
            }
            celix_arrayList_destroy(ids);
            return result;
        }
 
        std::vector<long> findServicesWithNameInternal(const char* name, const char* filter, const char* versionRange) {
            waitIfAbleForEvents();
            celix_service_filter_options_t opts{};
            opts.serviceName = name;
            opts.filter = filter;
            opts.versionRange = versionRange;
 
            std::vector<long> result{};
            auto cList = celix_bundleContext_findServicesWithOptions(cCtx.get(), &opts);
            for (int i = 0; i < celix_arrayList_size(cList); ++i) {
                long svcId = celix_arrayList_getLong(cList, i);
                result.push_back(svcId);
            }
            celix_arrayList_destroy(cList);
            return result;
        }
 
        const std::shared_ptr<celix_bundle_context_t> cCtx;
        const std::shared_ptr<celix::dm::DependencyManager> dm;
        const Bundle bnd;
    };
}