celix_status_t serviceTracker_open(service_tracker_pt tracker) {
service_listener_pt listener;
array_list_pt initial = NULL;
celix_status_t status = CELIX_SUCCESS;
listener = (service_listener_pt) malloc(sizeof(*listener));
status = bundleContext_getServiceReferences(tracker->context, NULL, tracker->filter, &initial);
if (status == CELIX_SUCCESS) {
service_reference_pt initial_reference;
unsigned int i;
listener->handle = tracker;
listener->serviceChanged = (void *) serviceTracker_serviceChanged;
status = bundleContext_addServiceListener(tracker->context, listener, tracker->filter);
if (status == CELIX_SUCCESS) {
tracker->listener = listener;
for (i = 0; i < arrayList_size(initial); i++) {
initial_reference = (service_reference_pt) arrayList_get(initial, i);
serviceTracker_track(tracker, initial_reference, NULL);
}
arrayList_clear(initial);
arrayList_destroy(initial);
initial = NULL;
}
}
framework_logIfError(logger, status, NULL, "Cannot open tracker");
return status;
}
celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
celix_status_t status;
shell_tui_activator_pt act = (shell_tui_activator_pt) userData;
service_listener_pt listener = (service_listener_pt) malloc(sizeof(*listener));
act->context = context;
act->running = true;
act->listener = listener;
act->listener->handle = act;
act->listener->serviceChanged = (void *) shellTui_serviceChanged;
status = bundleContext_addServiceListener(context, act->listener, "(objectClass=shellService)");
if (status == CELIX_SUCCESS) {
shellTui_initializeService(act);
apr_thread_create(&act->runnable, NULL, shellTui_runnable, act, act->pool);
}
return status;
}
celix_status_t refiningDriver_createDevice(refining_driver_pt driver, service_reference_pt reference, base_driver_device_service_pt baseService, refining_driver_device_pt *device) {
celix_status_t status = CELIX_SUCCESS;
(*device) = calloc(1, sizeof(**device));
if ((*device) != NULL) {
(*device)->driver=driver;
(*device)->baseDriverDeviceService=baseService;
(*device)->baseServiceReference=reference;
(*device)->deviceRegistration=NULL;
(*device)->listener=NULL;
service_listener_pt listener = calloc(1, sizeof(*listener));
listener->handle=(void *)(*device);
listener->serviceChanged=(celix_status_t (*)(void * listener, service_event_pt event))refiningDriver_serviceChanged;
bundleContext_addServiceListener(driver->context, listener, NULL);
(*device)->listener=listener;
arrayList_add(driver->devices, (*device));
} else {
status = CELIX_ENOMEM;
}
return status;
}
celix_status_t bundleActivator_start(void * userData, bundle_context_pt context) {
celix_status_t status;
struct activator *activator = userData;
endpoint_listener_pt endpointListener = malloc(sizeof(*endpointListener));
endpointListener->handle = activator->manager;
endpointListener->endpointAdded = topologyManager_addImportedService;
endpointListener->endpointRemoved = topologyManager_removeImportedService;
activator->endpointListener = endpointListener;
char *uuid = NULL;
status = bundleContext_getProperty(activator->context, (char *) OSGI_FRAMEWORK_FRAMEWORK_UUID, &uuid);
if (!uuid) {
logHelper_log(activator->loghelper, OSGI_LOGSERVICE_ERROR, "TOPOLOGY_MANAGER: no framework UUID defined?!");
return CELIX_ILLEGAL_STATE;
}
size_t len = 14 + strlen(OSGI_FRAMEWORK_OBJECTCLASS) + strlen(OSGI_RSA_ENDPOINT_FRAMEWORK_UUID) + strlen(uuid);
char *scope = malloc(len);
if (!scope) {
return CELIX_ENOMEM;
}
snprintf(scope, len, "(&(%s=*)(!(%s=%s)))", OSGI_FRAMEWORK_OBJECTCLASS, OSGI_RSA_ENDPOINT_FRAMEWORK_UUID, uuid);
logHelper_log(activator->loghelper, OSGI_LOGSERVICE_INFO, "TOPOLOGY_MANAGER: endpoint listener scope is %s", scope);
properties_pt props = properties_create();
properties_set(props, (char *) OSGI_ENDPOINT_LISTENER_SCOPE, scope);
// We can release the scope, as properties_set makes a copy of the key & value...
free(scope);
bundleContext_registerService(context, (char *) OSGI_ENDPOINT_LISTENER_SERVICE, endpointListener, props, &activator->endpointListenerService);
listener_hook_service_pt hookService = malloc(sizeof(*hookService));
hookService->handle = activator->manager;
hookService->added = topologyManager_listenerAdded;
hookService->removed = topologyManager_listenerRemoved;
activator->hookService = hookService;
bundleContext_registerService(context, (char *) OSGI_FRAMEWORK_LISTENER_HOOK_SERVICE_NAME, hookService, NULL, &activator->hook);
bundleContext_addServiceListener(context, activator->serviceListener, "(service.exported.interfaces=*)");
if (status == CELIX_SUCCESS) {
serviceTracker_open(activator->remoteServiceAdminTracker);
}
if (status == CELIX_SUCCESS) {
status = serviceTracker_open(activator->endpointListenerTracker);
}
bundleContext_registerService(context, (char *) TOPOLOGYMANAGER_SCOPE_SERVICE, activator->scopeService, NULL, &activator->scopeReg);
array_list_pt references = NULL;
bundleContext_getServiceReferences(context, NULL, "(service.exported.interfaces=*)", &references);
int i;
for (i = 0; i < arrayList_size(references); i++) {
service_reference_pt reference = arrayList_get(references, i);
char *serviceId = NULL;
status = CELIX_DO_IF(status, serviceReference_getProperty(reference, (char *)OSGI_FRAMEWORK_SERVICE_ID, &serviceId));
CELIX_DO_IF(status, topologyManager_addExportedService(activator->manager, reference, serviceId));
}
arrayList_destroy(references);
return status;
}
