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 OPTS_INIT {}
#else
#define OPTS_INIT
#endif

long celix_bundleContext_registerService(celix_bundle_context_t *ctx, void *svc, const char *serviceName, celix_properties_t *properties);

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 OPTS_INIT;

    celix_service_factory_t *factory OPTS_INIT;

    const char *serviceName OPTS_INIT;

    celix_properties_t *properties OPTS_INIT;

    const char *serviceLanguage OPTS_INIT;

    const char *serviceVersion 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 }
#endif


long celix_bundleContext_registerServiceWithOptions(celix_bundle_context_t *ctx, const celix_service_registration_options_t *opts);


void celix_bundleContext_unregisterService(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 OPTS_INIT;

    const char* versionRange OPTS_INIT;

    const char* filter OPTS_INIT;

    const char* serviceLanguage OPTS_INIT;


    bool ignoreServiceLanguage 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_trackService(
        celix_bundle_context_t* ctx,
        const char* serviceName,
        void* callbackHandle,
        void (*set)(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 OPTS_INIT;

    void* callbackHandle OPTS_INIT;

    void (*set)(void *handle, void *svc) OPTS_INIT;

    void (*setWithProperties)(void *handle, void *svc, const celix_properties_t *props) OPTS_INIT; //highest ranking

    void (*setWithOwner)(void *handle, void *svc, const celix_properties_t *props, const celix_bundle_t *svcOwner) OPTS_INIT; //highest ranking

    void (*add)(void *handle, void *svc) OPTS_INIT;

    void (*addWithProperties)(void *handle, void *svc, const celix_properties_t *props) OPTS_INIT;

    void (*addWithOwner)(void *handle, void *svc, const celix_properties_t *props, const celix_bundle_t *svcOwner) OPTS_INIT;

    void (*remove)(void *handle, void *svc) OPTS_INIT;

    void (*removeWithProperties)(void *handle, void *svc, const celix_properties_t *props) OPTS_INIT;

    void (*removeWithOwner)(void *handle, void *svc, const celix_properties_t *props, const celix_bundle_t *svcOwner) 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}
#endif

long celix_bundleContext_trackServicesWithOptions(celix_bundle_context_t *ctx, const celix_service_tracking_options_t *opts);

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)
);

void 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 OPTS_INIT;

     double waitTimeoutInSeconds OPTS_INIT;

    void *callbackHandle OPTS_INIT;

    void (*use)(void *handle, void *svc) OPTS_INIT;

    void (*useWithProperties)(void *handle, void *svc, const celix_properties_t *props) OPTS_INIT;

    void (*useWithOwner)(void *handle, void *svc, const celix_properties_t *props, const celix_bundle_t *svcOwner) 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}
#endif

bool celix_bundleContext_useServiceWithOptions(
        celix_bundle_context_t *ctx,
        const celix_service_use_options_t *opts);


void 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);

bool celix_bundleContext_isBundleInstalled(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 bundleId);

bool celix_bundleContext_stopBundle(celix_bundle_context_t *ctx, long bundleId);

bool celix_bundleContext_startBundle(celix_bundle_context_t *ctx, long bundleId);

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)
);


typedef struct celix_bundle_tracker_options {
    void* callbackHandle OPTS_INIT;

    void (*onStarted)(void *handle, const celix_bundle_t *bundle) OPTS_INIT; //highest ranking

    void (*onStopped)(void *handle, const celix_bundle_t *bundle) OPTS_INIT;

    //TODO callback for on installed, resolved, uninstalled ??

    void (*onBundleEvent)(void *handle, const celix_bundle_event_t *event) OPTS_INIT;

    bool includeFrameworkBundle OPTS_INIT;
} celix_bundle_tracking_options_t;

#ifndef __cplusplus
#define CELIX_EMPTY_BUNDLE_TRACKING_OPTIONS {.callbackHandle = NULL, .onStarted = NULL, .onStopped = NULL, .onBundleEvent = NULL}
#endif

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)
);



//TODO add useBundleWithOptions (e.g. which state)
//TODO findBundles

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_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));

celix_dependency_manager_t* celix_bundleContext_getDependencyManager(celix_bundle_context_t *ctx);


celix_bundle_t* celix_bundleContext_getBundle(celix_bundle_context_t *ctx);


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);

//TODO getPropertyAs for int, uint, ulong, bool, etc

#undef OPTS_INIT

#ifdef __cplusplus
}
#endif

#endif //CELIX_BUNDLE_CONTEXT_H_