celix_status_t driverLoader_unloadDrivers(driver_loader_pt loader, driver_attributes_pt finalDriver) {
celix_status_t status = CELIX_SUCCESS;
service_reference_pt finalReference = NULL;
if (finalDriver != NULL) {
status = driverAttributes_getReference(finalDriver, &finalReference);
}
if (status == CELIX_SUCCESS) {
int i;
for (i = 0; i < arrayList_size(loader->loadedDrivers); i++) {
service_reference_pt reference = arrayList_get(loader->loadedDrivers, i);
bool equal = false;
status = serviceReference_equals(reference, finalReference, &equal);
if (status == CELIX_SUCCESS && !equal) {
bundle_pt bundle = NULL;
status = serviceReference_getBundle(reference, &bundle);
if (status == CELIX_SUCCESS) {
bundle_uninstall(bundle); // Ignore status
}
}
}
}
return status;
}
array_list_pt serviceRegistry_getUsingBundles(service_registry_pt registry, service_reference_pt reference) {
array_list_pt bundles = NULL;
hash_map_iterator_pt iter;
arrayList_create(&bundles);
celixThreadMutex_lock(®istry->mutex);
iter = hashMapIterator_create(registry->inUseMap);
while (hashMapIterator_hasNext(iter)) {
hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
bundle_pt bundle = hashMapEntry_getKey(entry);
array_list_pt usages = hashMapEntry_getValue(entry);
unsigned int i;
for (i = 0; i < arrayList_size(usages); i++) {
usage_count_pt usage = arrayList_get(usages, i);
bool equals = false;
serviceReference_equals(usage->reference, reference, &equals);
if (equals) {
arrayList_add(bundles, bundle);
}
}
}
hashMapIterator_destroy(iter);
celixThreadMutex_unlock(®istry->mutex);
return bundles;
}
static celix_status_t serviceTracker_track(service_tracker_pt tracker, service_reference_pt reference, service_event_pt event) {
celix_status_t status = CELIX_SUCCESS;
tracked_pt tracked = NULL;
int found = -1;
unsigned int i;
for (i = 0; i < arrayList_size(tracker->tracked); i++) {
bool equals;
tracked = (tracked_pt) arrayList_get(tracker->tracked, i);
serviceReference_equals(reference, tracked->reference, &equals);
if (equals) {
found = 0;
break;
}
}
if (found) {
void * service = NULL;
status = serviceTracker_addingService(tracker, reference, &service);
if (status == CELIX_SUCCESS) {
if (service != NULL) {
tracked = (tracked_pt) malloc(sizeof(*tracked));
tracked->reference = reference;
tracked->service = service;
arrayList_add(tracker->tracked, tracked);
if (tracker->customizer != NULL) {
void *handle = NULL;
added_callback_pt function = NULL;
serviceTrackerCustomizer_getHandle(tracker->customizer, &handle);
serviceTrackerCustomizer_getAddedFunction(tracker->customizer, &function);
if (function != NULL) {
function(handle, reference, service);
}
}
}
}
} else {
if (tracker->customizer != NULL) {
void *handle = NULL;
modified_callback_pt function = NULL;
serviceTrackerCustomizer_getHandle(tracker->customizer, &handle);
serviceTrackerCustomizer_getModifiedFunction(tracker->customizer, &function);
if (function != NULL) {
function(handle, reference, tracked->service);
}
}
}
framework_logIfError(logger, status, NULL, "Cannot track reference");
return status;
}
static celix_status_t refiningDriver_serviceChanged(service_listener_pt listener, service_event_pt event) {
celix_status_t status = CELIX_SUCCESS;
refining_driver_device_pt device = listener->handle;
if (event->type == OSGI_FRAMEWORK_SERVICE_EVENT_UNREGISTERING) {
bool equal = false;
status = serviceReference_equals(device->baseServiceReference, event->reference, &equal);
if (status == CELIX_SUCCESS && equal) {
refiningDriver_stopDevice(device);
}
}
return status;
}
void *serviceTracker_getServiceByReference(service_tracker_pt tracker, service_reference_pt reference) {
tracked_pt tracked;
unsigned int i;
for (i = 0; i < arrayList_size(tracker->tracked); i++) {
bool equals;
tracked = (tracked_pt) arrayList_get(tracker->tracked, i);
serviceReference_equals(reference, tracked->reference, &equals);
if (equals) {
return tracked->service;
}
}
return NULL;
}
static celix_status_t serviceRegistry_getUsageCount(service_registry_pt registry, bundle_pt bundle, service_reference_pt reference, usage_count_pt *usageCount) {
array_list_pt usages = (array_list_pt) hashMap_get(registry->inUseMap, bundle);
*usageCount = NULL;
unsigned int i;
for (i = 0; (usages != NULL) && (i < arrayList_size(usages)); i++) {
usage_count_pt usage = (usage_count_pt) arrayList_get(usages, i);
bool equals = false;
serviceReference_equals(usage->reference, reference, &equals);
if (equals) {
*usageCount = usage;
break;
}
}
return CELIX_SUCCESS;
}
static celix_status_t serviceTracker_untrack(service_tracker_pt tracker, service_reference_pt reference, service_event_pt event) {
celix_status_t status = CELIX_SUCCESS;
tracked_pt tracked = NULL;
unsigned int i;
bool result = false;
for (i = 0; i < arrayList_size(tracker->tracked); i++) {
bool equals;
tracked = (tracked_pt) arrayList_get(tracker->tracked, i);
serviceReference_equals(reference, tracked->reference, &equals);
if (equals) {
arrayList_remove(tracker->tracked, i);
if (status == CELIX_SUCCESS) {
if (tracker->customizer != NULL) {
void *handle = NULL;
removed_callback_pt function = NULL;
serviceTrackerCustomizer_getHandle(tracker->customizer, &handle);
serviceTrackerCustomizer_getRemovedFunction(tracker->customizer, &function);
if (function != NULL) {
status = function(handle, reference, tracked->service);
} else {
status = bundleContext_ungetService(tracker->context, reference, &result);
}
} else {
status = bundleContext_ungetService(tracker->context, reference, &result);
}
// ungetServiceReference
bundleContext_ungetServiceReference(tracker->context, reference);
//break;
}
free(tracked);
}
}
framework_logIfError(logger, status, NULL, "Cannot untrack reference");
return status;
}
static celix_status_t serviceRegistry_flushUsageCount(service_registry_pt registry, bundle_pt bundle, service_reference_pt reference) {
array_list_pt usages = hashMap_get(registry->inUseMap, bundle);
if (usages != NULL) {
array_list_iterator_pt iter = arrayListIterator_create(usages);
while (arrayListIterator_hasNext(iter)) {
usage_count_pt usage = arrayListIterator_next(iter);
bool equals = false;
serviceReference_equals(usage->reference, reference, &equals);
if (equals) {
arrayListIterator_remove(iter);
free(usage);
}
}
arrayListIterator_destroy(iter);
if (arrayList_size(usages) > 0) {
hashMap_put(registry->inUseMap, bundle, usages);
} else {
array_list_pt removed = hashMap_remove(registry->inUseMap, bundle);
arrayList_destroy(removed);
}
}
return CELIX_SUCCESS;
}
