celix_bundle_context.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.
 */
 
#include "celix_types.h"
#include "celix_service_factory.h"
#include "celix_properties.h"
#include "celix_array_list.h"
#include "celix_filter.h"
 
#ifndef CELIX_BUNDLE_CONTEXT_H_
#define CELIX_BUNDLE_CONTEXT_H_
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifdef __cplusplus
#define CELIX_OPTS_INIT {}
#else
#define CELIX_OPTS_INIT
#endif
 
long celix_bundleContext_registerServiceAsync(celix_bundle_context_t *ctx, void *svc, const char *serviceName, celix_properties_t *properties);
 
long celix_bundleContext_registerService(celix_bundle_context_t *ctx, void *svc, const char *serviceName, celix_properties_t *properties);
 
long celix_bundleContext_registerServiceFactoryAsync(celix_bundle_context_t *ctx, celix_service_factory_t *factory, const char *serviceName, celix_properties_t *props);
 
long celix_bundleContext_registerServiceFactory(celix_bundle_context_t *ctx, celix_service_factory_t *factory, const char *serviceName, celix_properties_t *props);
 
typedef struct celix_service_registration_options {
    void *svc CELIX_OPTS_INIT;
 
    celix_service_factory_t *factory CELIX_OPTS_INIT;
 
    const char *serviceName CELIX_OPTS_INIT;
 
    celix_properties_t *properties CELIX_OPTS_INIT;
 
    const char *serviceLanguage CELIX_OPTS_INIT;
 
    const char *serviceVersion CELIX_OPTS_INIT;
 
     void *asyncData CELIX_OPTS_INIT;
 
    void (*asyncCallback)(void *data, long serviceId) CELIX_OPTS_INIT;
} celix_service_registration_options_t;
 
#ifndef __cplusplus
#define CELIX_EMPTY_SERVICE_REGISTRATION_OPTIONS { .svc = NULL, \
    .factory = NULL, \
    .serviceName = NULL, \
    .properties = NULL, \
    .serviceLanguage = NULL, \
    .serviceVersion = NULL, \
    .asyncData = NULL, \
    .asyncCallback = NULL }
#endif
 
long celix_bundleContext_registerServiceWithOptionsAsync(celix_bundle_context_t *ctx, const celix_service_registration_options_t *opts);
 
long celix_bundleContext_registerServiceWithOptions(celix_bundle_context_t *ctx, const celix_service_registration_options_t *opts);
 
void celix_bundleContext_waitForAsyncRegistration(celix_bundle_context_t* ctx, long serviceId);
 
bool celix_bundleContext_isServiceRegistered(celix_bundle_context_t* ctx, long serviceId);
 
 
void celix_bundleContext_unregisterService(celix_bundle_context_t *ctx, long serviceId);
 
 
void celix_bundleContext_unregisterServiceAsync(celix_bundle_context_t *ctx, long serviceId, void* doneData, void (*doneCallback)(void* doneData));
 
 
void celix_bundleContext_waitForAsyncUnregistration(celix_bundle_context_t* ctx, long serviceId);
 
 
 
 
long celix_bundleContext_findService(celix_bundle_context_t *ctx, const char *serviceName);
 
celix_array_list_t* celix_bundleContext_findServices(celix_bundle_context_t *ctx, const char *serviceName);
 
typedef struct celix_service_filter_options {
    const char* serviceName CELIX_OPTS_INIT;
 
    const char* versionRange CELIX_OPTS_INIT;
 
    const char* filter CELIX_OPTS_INIT;
 
    const char* serviceLanguage CELIX_OPTS_INIT;
 
 
    bool ignoreServiceLanguage CELIX_OPTS_INIT;
} celix_service_filter_options_t;
 
#ifndef __cplusplus
#define CELIX_EMPTY_SERVICE_FILTER_OPTIONS {.serviceName = NULL, .versionRange = NULL, .filter = NULL, .serviceLanguage = NULL, .ignoreServiceLanguage = false}
#endif
 
 
long celix_bundleContext_findServiceWithOptions(celix_bundle_context_t *ctx, const celix_service_filter_options_t *opts);
 
celix_array_list_t* celix_bundleContext_findServicesWithOptions(celix_bundle_context_t *ctx, const celix_service_filter_options_t *opts);
 
long celix_bundleContext_trackServiceAsync(
        celix_bundle_context_t* ctx,
        const char* serviceName,
        void* callbackHandle,
        void (*set)(void* handle, void* svc)
);
 
long celix_bundleContext_trackService(
        celix_bundle_context_t* ctx,
        const char* serviceName,
        void* callbackHandle,
        void (*set)(void* handle, void* svc)
); //__attribute__((deprecated("Use celix_bundleContext_trackServiceSync instead!")));
 
long celix_bundleContext_trackServicesAsync(
        celix_bundle_context_t* ctx,
        const char* serviceName,
        void* callbackHandle,
        void (*add)(void* handle, void* svc),
        void (*remove)(void* handle, void* svc)
);
 
long celix_bundleContext_trackServices(
        celix_bundle_context_t* ctx,
        const char* serviceName,
        void* callbackHandle,
        void (*add)(void* handle, void* svc),
        void (*remove)(void* handle, void* svc)
);
 
typedef struct celix_service_tracking_options {
    celix_service_filter_options_t filter CELIX_OPTS_INIT;
 
    void* callbackHandle CELIX_OPTS_INIT;
 
    void (*set)(void *handle, void *svc) CELIX_OPTS_INIT;
 
    void (*setWithProperties)(void *handle, void *svc, const celix_properties_t *props) CELIX_OPTS_INIT; //highest ranking
 
    void (*setWithOwner)(void *handle, void *svc, const celix_properties_t *props, const celix_bundle_t *svcOwner) CELIX_OPTS_INIT; //highest ranking
 
    void (*add)(void *handle, void *svc) CELIX_OPTS_INIT;
 
    void (*addWithProperties)(void *handle, void *svc, const celix_properties_t *props) CELIX_OPTS_INIT;
 
    void (*addWithOwner)(void *handle, void *svc, const celix_properties_t *props, const celix_bundle_t *svcOwner) CELIX_OPTS_INIT;
 
    void (*remove)(void *handle, void *svc) CELIX_OPTS_INIT;
 
    void (*removeWithProperties)(void *handle, void *svc, const celix_properties_t *props) CELIX_OPTS_INIT;
 
    void (*removeWithOwner)(void *handle, void *svc, const celix_properties_t *props, const celix_bundle_t *svcOwner) CELIX_OPTS_INIT;
 
 
    void *trackerCreatedCallbackData CELIX_OPTS_INIT;
 
    void (*trackerCreatedCallback)(void *trackerCreatedCallbackData) CELIX_OPTS_INIT;
} celix_service_tracking_options_t;
 
#ifndef __cplusplus
#define CELIX_EMPTY_SERVICE_TRACKING_OPTIONS { .filter.serviceName = NULL, \
    .filter.versionRange = NULL, \
    .filter.filter = NULL, \
    .filter.serviceLanguage = NULL, \
    .filter.ignoreServiceLanguage = false, \
    .callbackHandle = NULL, \
    .set = NULL, \
    .add = NULL, \
    .remove = NULL, \
    .setWithProperties = NULL, \
    .addWithProperties = NULL, \
    .removeWithProperties = NULL, \
    .setWithOwner = NULL, \
    .addWithOwner = NULL, \
    .removeWithOwner = NULL, \
    .trackerCreatedCallbackData = NULL, \
    .trackerCreatedCallback = NULL }
#endif
 
long celix_bundleContext_trackServicesWithOptionsAsync(celix_bundle_context_t *ctx, const celix_service_tracking_options_t *opts);
 
long celix_bundleContext_trackServicesWithOptions(celix_bundle_context_t *ctx, const celix_service_tracking_options_t *opts); //__attribute__((deprecated("Use celix_bundleContext_trackServicesWithOptionsAsync instead!")));
 
void celix_bundleContext_stopTrackerAsync(
        celix_bundle_context_t *ctx,
        long trackerId,
        void *doneCallbackData,
        void (*doneCallback)(void* doneCallbackData));
 
void celix_bundleContext_waitForAsyncTracker(celix_bundle_context_t* ctx, long trackerId);
 
void celix_bundleContext_waitForAsyncStopTracker(celix_bundle_context_t* ctx, long trackerId);
 
void celix_bundleContext_stopTracker(celix_bundle_context_t *ctx, long trackerId);
 
 
 
bool celix_bundleContext_useServiceWithId(
        celix_bundle_context_t *ctx,
        long serviceId,
        const char *serviceName /*sanity check*/,
        void *callbackHandle,
        void (*use)(void *handle, void* svc)
);
 
bool celix_bundleContext_useService(
        celix_bundle_context_t *ctx,
        const char* serviceName,
        void *callbackHandle,
        void (*use)(void *handle, void *svc)
);
 
size_t celix_bundleContext_useServices(
        celix_bundle_context_t *ctx,
        const char* serviceName,
        void *callbackHandle,
        void (*use)(void *handle, void *svc)
);
 
typedef struct celix_service_use_options {
    celix_service_filter_options_t filter CELIX_OPTS_INIT;
 
     double waitTimeoutInSeconds CELIX_OPTS_INIT;
 
    void *callbackHandle CELIX_OPTS_INIT;
 
    void (*use)(void *handle, void *svc) CELIX_OPTS_INIT;
 
    void (*useWithProperties)(void *handle, void *svc, const celix_properties_t *props) CELIX_OPTS_INIT;
 
    void (*useWithOwner)(void *handle, void *svc, const celix_properties_t *props, const celix_bundle_t *svcOwner) CELIX_OPTS_INIT;
#define CELIX_SERVICE_USE_DIRECT              (1)
 
#define CELIX_SERVICE_USE_SOD                 (2)
    int flags CELIX_OPTS_INIT;
} celix_service_use_options_t;
 
#ifndef __cplusplus
#define CELIX_EMPTY_SERVICE_USE_OPTIONS {.filter.serviceName = NULL, \
    .filter.versionRange = NULL, \
    .filter.filter = NULL, \
    .filter.serviceLanguage = NULL, \
    .waitTimeoutInSeconds = 0.0F, \
    .callbackHandle = NULL, \
    .use = NULL, \
    .useWithProperties = NULL, \
    .useWithOwner = NULL, \
    .flags=0}
#endif
 
bool celix_bundleContext_useServiceWithOptions(
        celix_bundle_context_t *ctx,
        const celix_service_use_options_t *opts);
 
 
size_t celix_bundleContext_useServicesWithOptions(
        celix_bundle_context_t *ctx,
        const celix_service_use_options_t *opts);
 
 
celix_array_list_t* celix_bundleContext_listBundles(celix_bundle_context_t *ctx);
 
celix_array_list_t* celix_bundleContext_listInstalledBundles(celix_bundle_context_t *ctx);
 
 
bool celix_bundleContext_isBundleInstalled(celix_bundle_context_t *ctx, long bndId);
 
bool celix_bundleContext_isBundleActive(celix_bundle_context_t *ctx, long bndId);
 
 
long celix_bundleContext_installBundle(celix_bundle_context_t *ctx, const char *bundleLoc, bool autoStart);
 
bool celix_bundleContext_uninstallBundle(celix_bundle_context_t *ctx, long bndId);
 
bool celix_bundleContext_stopBundle(celix_bundle_context_t *ctx, long bndId);
 
bool celix_bundleContext_startBundle(celix_bundle_context_t *ctx, long bndId);
 
char* celix_bundleContext_getBundleSymbolicName(celix_bundle_context_t *ctx, long bndId);
 
 
long celix_bundleContext_trackBundlesAsync(
        celix_bundle_context_t* ctx,
        void* callbackHandle,
        void (*onStarted)(void* handle, const celix_bundle_t *bundle),
        void (*onStopped)(void *handle, const celix_bundle_t *bundle)
);
 
long celix_bundleContext_trackBundles(
        celix_bundle_context_t* ctx,
        void* callbackHandle,
        void (*onStarted)(void* handle, const celix_bundle_t *bundle),
        void (*onStopped)(void *handle, const celix_bundle_t *bundle)
); //__attribute__((deprecated("Use celix_bundleContext_trackBundlesAsync instead!")));
 
 
typedef struct celix_bundle_tracker_options {
    void* callbackHandle CELIX_OPTS_INIT;
 
    void (*onInstalled)(void *handle, const celix_bundle_t *bundle) CELIX_OPTS_INIT;
 
    void (*onStarted)(void *handle, const celix_bundle_t *bundle) CELIX_OPTS_INIT;
 
    void (*onStopped)(void *handle, const celix_bundle_t *bundle) CELIX_OPTS_INIT;
 
    void (*onBundleEvent)(void *handle, const celix_bundle_event_t *event) CELIX_OPTS_INIT;
 
    bool includeFrameworkBundle CELIX_OPTS_INIT;
 
    void *trackerCreatedCallbackData CELIX_OPTS_INIT;
 
    void (*trackerCreatedCallback)(void *trackerCreatedCallbackData) CELIX_OPTS_INIT;
} celix_bundle_tracking_options_t;
 
#ifndef __cplusplus
#define CELIX_EMPTY_BUNDLE_TRACKING_OPTIONS {.callbackHandle = NULL, .onInstalled = NULL, .onStarted = NULL, .onStopped = NULL, .onBundleEvent = NULL, .includeFrameworkBundle = false, .trackerCreatedCallbackData = NULL, .trackerCreatedCallback = NULL}
#endif
 
long celix_bundleContext_trackBundlesWithOptionsAsync(
        celix_bundle_context_t* ctx,
        const celix_bundle_tracking_options_t *opts
);
 
long celix_bundleContext_trackBundlesWithOptions(
        celix_bundle_context_t* ctx,
        const celix_bundle_tracking_options_t *opts
);
 
bool celix_bundleContext_useBundle(
        celix_bundle_context_t *ctx,
        long bundleId,
        void *callbackHandle,
        void (*use)(void *handle, const celix_bundle_t *bundle)
);
 
void celix_bundleContext_useBundles(
        celix_bundle_context_t *ctx,
        void *callbackHandle,
        void (*use)(void *handle, const celix_bundle_t *bundle)
);
 
typedef struct celix_service_tracker_info {
    celix_filter_t *filter;
 
    const char *serviceName;
 
    const char *serviceLanguage;
 
    long bundleId;
} celix_service_tracker_info_t;
 
long celix_bundleContext_trackServiceTrackersAsync(
        celix_bundle_context_t *ctx,
        const char *serviceName,
        void *callbackHandle,
        void (*trackerAdd)(void *handle, const celix_service_tracker_info_t *info),
        void (*trackerRemove)(void *handle, const celix_service_tracker_info_t *info),
        void *doneCallbackData,
        void (*doneCallback)(void* doneCallbackData));
 
long celix_bundleContext_trackServiceTrackers(
        celix_bundle_context_t *ctx,
        const char *serviceName,
        void *callbackHandle,
        void (*trackerAdd)(void *handle, const celix_service_tracker_info_t *info),
        void (*trackerRemove)(void *handle, const celix_service_tracker_info_t *info)); //__attribute__((deprecated("Use celix_bundleContext_trackServiceTrackersAsync instead!")));
 
celix_dependency_manager_t* celix_bundleContext_getDependencyManager(celix_bundle_context_t *ctx);
 
 
void celix_bundleContext_waitForEvents(celix_bundle_context_t* ctx);
 
 
celix_bundle_t* celix_bundleContext_getBundle(const celix_bundle_context_t *ctx);
 
 
long celix_bundleContext_getBundleId(const celix_bundle_context_t *ctx);
 
celix_framework_t* celix_bundleContext_getFramework(const celix_bundle_context_t* ctx);
 
void celix_bundleContext_log(const celix_bundle_context_t* ctx, celix_log_level_e level, const char* format, ...);
 
void celix_bundleContext_vlog(const celix_bundle_context_t* ctx, celix_log_level_e level, const char* format, va_list formatArgs);
 
 
const char* celix_bundleContext_getProperty(celix_bundle_context_t *ctx, const char *key, const char *defaultVal);
 
long celix_bundleContext_getPropertyAsLong(celix_bundle_context_t *ctx, const char *key, long defaultValue);
 
double celix_bundleContext_getPropertyAsDouble(celix_bundle_context_t *ctx, const char *key, double defaultValue);
 
bool celix_bundleContext_getPropertyAsBool(celix_bundle_context_t *ctx, const char *key, bool defaultValue);
 
#undef CELIX_OPTS_INIT
 
#ifdef __cplusplus
}
#endif
 
#endif //CELIX_BUNDLE_CONTEXT_H_