Java Code Examples for org.osgi.framework.ServiceReference#getBundle()

public static boolean isAvailable(ServiceReference<?> serviceReference) {
    Bundle bundle = serviceReference.getBundle();

    if (bundle == null) {
        return false;
    }

    for (ServiceReference<?> registeredService :
        bundle.getRegisteredServices()) {

        if (registeredService.equals(serviceReference)) {
            return true;
        }
    }

    return false;
}
 

/**
 * The service event callback method inserts all service events into the
 * log.
 * 
 * Event of types REGISTERED, UNREGISTERED are assigned the log
 * level info.
 * 
 * Events of type MODIFIED are assigned the log level DEBUG.
 * 
 * @param se
 *            the service event that has occurred.
 */
public void serviceChanged(ServiceEvent se) {
    ServiceReference<?> sr = se.getServiceReference();
    Bundle bundle = sr.getBundle();
    String msg = null;
    int level = LogService.LOG_INFO;
    switch (se.getType()) {
    case ServiceEvent.REGISTERED:
        msg = "ServiceEvent REGISTERED";
        break;
    case ServiceEvent.UNREGISTERING:
        msg = "ServiceEvent UNREGISTERING";
        break;
    case ServiceEvent.MODIFIED:
        msg = "ServiceEvent MODIFIED";
        level = LogService.LOG_DEBUG;
        break;
    }
    lrsf.log(new LogEntryImpl(bundle, sr, level, msg));
}
 

/**
 * Get a loaded metatype provider, given a bundle.
 *
 * @return Provider if such provider is found, otherwise <tt>null</tt>.
 */
public MetaTypeInformation getMTP(Bundle b)
{
  final ServiceReference<?> cmSR = cmTracker.getServiceReference();

  MetaTypeInformation mti = null;

  if (cmSR != null && cmSR.getBundle() == b) {
    mti = cmMTP;
  } else if (b.getBundleId() == 0) {
    mti = this;
  } else {
    mti = providers.get(b);
  }

  return mti;
}
 

private ServiceReferenceDTO getServiceReferenceDTO(ServiceReference<?> sr) {
  ServiceReferenceDTO res = new ServiceReferenceDTO();
  res.properties = new HashMap<String, Object>();
  for (String key : sr.getPropertyKeys()) {
    Object val = safeDTOObject(sr.getProperty(key));
    res.properties.put(key, val);
  }
  res.id = ((Long)sr.getProperty(Constants.SERVICE_ID)).longValue();
  Bundle [] using = sr.getUsingBundles();
  if (using != null) {
    res.usingBundles = new long [using.length];
    for (int i = 0; i < using.length; i++) {
      res.usingBundles[i] = using[i].getBundleId();
    }
  } else {
    res.usingBundles = new long [0];
  }
  Bundle b = sr.getBundle();
  if (b == null) {
    return null;
  }
  res.bundle = b.getBundleId();
  return res;
}
 

private Set<String> removeFromLocationToPids(ServiceReference<?> sr)
{
  HashSet<String> res = new HashSet<String>();
  if (sr != null) {
    Bundle bundle = sr.getBundle();
    final String bundleLocation = bundle.getLocation();
    final Hashtable<String, TreeSet<ServiceReference<?>>> pidsForLocation =
      locationToPids.get(bundleLocation);
    for (final Iterator<Entry<String, TreeSet<ServiceReference<?>>>> it =
      pidsForLocation.entrySet().iterator(); it.hasNext();) {
      final Entry<String, TreeSet<ServiceReference<?>>> entry = it.next();
      TreeSet<ServiceReference<?>> ssrs = entry.getValue();
      if (ssrs.remove(sr)) {
        res.add(entry.getKey());
        if (ssrs.isEmpty()) {
          it.remove();
        }
      }
    }
    if (pidsForLocation.isEmpty()) {
      locationToPids.remove(bundleLocation);
    }
  }
  return res;
}
 

@Override
public Object convert(ServiceReference obj) {
    final Bundle bundle = obj.getBundle();
    if (bundle != null) {
        return bundle.getBundleContext().getService(obj);
    } else {
        return null;
    }
}
 

@Override
public Class<? extends Object> type(ServiceReference obj) {
    String[] arr = (String[])obj.getProperty(Constants.OBJECTCLASS);
    if (arr.length > 0) {
        final Bundle bundle = obj.getBundle();
        if (bundle != null) try {
            return (Class<?>)bundle.loadClass(arr[0]);
        } catch (ClassNotFoundException ex) {
            Netigso.LOG.log(Level.INFO, "Cannot load service class", arr[0]); // NOI18N
        }
    }
    return Object.class;
}
 

/**
 * unregister a service.
 * 
 * @param sref
 *            the service reference.
 */
void unregisterService(final ServiceReference<?> sref) {
	// remove all class entries
	final String[] clazzes = (String[]) sref
			.getProperty(Constants.OBJECTCLASS);
	serviceRegistry.removeAll(clazzes, sref);

	boolean isHook = false;

	for (int i = 0; i < clazzes.length; i++) {
		@SuppressWarnings("unchecked")
		final List<ServiceReference<?>> hookList = (List<ServiceReference<?>>) hooks
				.get(clazzes[i]);
		if (hookList != null) {
			isHook = true;
			hookList.remove(sref);
		}
		
		if(clazzes[i].equals(WovenClassListener.class.getName())){
			wovenClassListeners.remove(sref);
		}
	}

	final AbstractBundle bundle = (AbstractBundle) sref.getBundle();
	bundle.registeredServices.remove(sref);

	// dispose list, if empty
	if (bundle.registeredServices.isEmpty()) {
		bundle.registeredServices = null;
	}

	if (!isHook) {
		notifyServiceListeners(ServiceEvent.UNREGISTERING, sref, null);
	}

	if (LOG_ENABLED && DEBUG_SERVICES) {
		logger.log(LogService.LOG_INFO,
				"Framework: UNREGISTERED SERVICE " + sref);
	}
}
 

private String showDevice(ServiceReference<?> sr)
{
  final StringBuffer sb = new StringBuffer();
  Object o =
    sr.getProperty(org.osgi.service.device.Constants.DEVICE_CATEGORY);
  if (o instanceof String) {
    sb.append(o);
  } else if (o instanceof String[]) {
    final String[] dca = (String[]) o;
    for (int i = 0; i < dca.length; i++) {
      if (i > 0) {
        sb.append('_');
      }
      sb.append(dca[i]);
    }
  }
  o = sr.getProperty(org.osgi.framework.Constants.SERVICE_ID);
  if (o != null) {
    sb.append(", sid=");
    sb.append(o);
  }
  final Bundle b = sr.getBundle();
  if (b != null) {
    sb.append(", bid=");
    sb.append(b.getBundleId());
  }
  return sb.toString();
}
 

private String showDriver(ServiceReference<?> sr)
{
  final StringBuffer sb = new StringBuffer();
  final String s =
    (String) sr.getProperty(org.osgi.service.device.Constants.DRIVER_ID);
  sb.append(s != null ? s : "driver");
  final Bundle b = sr.getBundle();
  if (b != null) {
    sb.append(", bid=");
    sb.append(b.getBundleId());
  }
  return sb.toString();
}
 

private void log(TrackedEventHandler handler, String txt)
{
  final ServiceReference<EventHandler> sr = handler.getServiceReference();
  final Bundle b = sr.getBundle();
  String binfo = (b != null) ?
    "  bundle.id=" + b.getBundleId() + "  bundle.name=" + b.getSymbolicName()
    : " No bundle info";
  Activator.log.error(txt + "  Service.id="
                      + sr.getProperty(Constants.SERVICE_ID) + binfo +
                      " topic=" + event.getTopic(), sr);
}
 

public void prepare() {
  try {
    ServiceReference ref = bc.getServiceReference(Control.class.getName());
    bundle = ref.getBundle();
  } catch (Exception e) { 
    e.printStackTrace();
  }
}
 

static void unregisterService(ServiceReference serviceReference) {
    services.remove(serviceReference);
    removeValue(classes_services, (String[]) serviceReference.getProperty(Constants.OBJECTCLASS), serviceReference);
    BundleImpl bundleImpl = (BundleImpl) serviceReference.getBundle();
    bundleImpl.registeredServices.remove(serviceReference);
    if (bundleImpl.registeredServices.isEmpty()) {
        bundleImpl.registeredServices = null;
    }
    notifyServiceListeners(4, serviceReference);
    if (DEBUG_SERVICES && log.isInfoEnabled()) {
        log.info("Framework: UNREGISTERED SERVICE " + serviceReference);
    }
}
 

public void prepare() {
  ServiceReference ref = bc.getServiceReference(Control.class.getName());
  bundle = ref.getBundle();
}
 

@Override
public Object addingService(ServiceReference<Object> reference) {
    Object serviceObject = DataHolder.getInstance().getBundleContext().getService(reference);
    String serviceInterfaceClassName = ((String[]) reference.getProperty(OBJECT_CLASS))[0];
    String serviceImplClassName = serviceObject.getClass().getName();
    Bundle bundle = reference.getBundle();

    if (RequiredCapabilityListener.class.getName().equals(serviceInterfaceClassName)) {
        String componentKey = getNonEmptyStringAfterTrim((String) reference.getProperty(COMPONENT_NAME))
                .orElseThrow(() -> new StartOrderResolverException(COMPONENT_NAME + " value is missing in " +
                        "the services registered with the key " + serviceInterfaceClassName + ", " +
                        "implementation class name is " + serviceImplClassName));

        startupComponentManager.addRequiredCapabilityListener(
                (RequiredCapabilityListener) serviceObject, componentKey, reference.getBundle());

    } else if (CapabilityProvider.class.getName().equals(serviceInterfaceClassName)) {
        String capabilityName = getNonEmptyStringAfterTrim((String) reference.getProperty(CAPABILITY_NAME))
                .orElseThrow(() -> new StartOrderResolverException(CAPABILITY_NAME + " value is missing in " +
                        "the services registered with the key " + serviceInterfaceClassName + ", " +
                        "implementation class name is " + serviceImplClassName));

        CapabilityProviderCapability capabilityProvider = new CapabilityProviderCapability(
                CapabilityProvider.class.getName(),
                Capability.CapabilityType.OSGi_SERVICE,
                Capability.CapabilityState.AVAILABLE,
                capabilityName.trim(),
                bundle);

        startupComponentManager.addExpectedOrAvailableCapabilityProvider(capabilityProvider);

        CapabilityProvider provider = (CapabilityProvider) serviceObject;
        IntStream.range(0, provider.getCount())
                .forEach(count -> startupComponentManager.addExpectedCapability(
                        new OSGiServiceCapability(
                                capabilityName.trim(),
                                Capability.CapabilityType.OSGi_SERVICE,
                                Capability.CapabilityState.EXPECTED,
                                bundle,
                                true)));
    } else {
        if (Boolean.TRUE.equals(reference.getProperty(SKIP_CARBON_STARTUP_RESOLVER))) {
            logger.debug("Skipping tracking of service {} which implements {}.", serviceImplClassName,
                         serviceInterfaceClassName);
            return null;
        }

        logger.debug("Updating indirect dependencies in components for interface={} via the implementation={}",
                serviceInterfaceClassName, serviceImplClassName);
        startupComponentManager.updateCapability(new OSGiServiceCapability(
                serviceInterfaceClassName,
                Capability.CapabilityType.OSGi_SERVICE,
                Capability.CapabilityState.AVAILABLE,
                bundle,
                false));
    }

    return serviceObject;
}
 

public ProcessApplicationInterface addProcessApplication(ServiceReference<ProcessApplicationInterface> reference) {

    Bundle bundle = reference.getBundle();
    BundleContext bundleContext = bundle.getBundleContext();

    ClassLoader previous = Thread.currentThread().getContextClassLoader();

    try {
      ClassLoader cl = new BundleDelegatingClassLoader(bundle);

      Thread.currentThread().setContextClassLoader(
          new ClassLoaderWrapper(cl, ProcessEngineFactory.class.getClassLoader(), ProcessEngineConfiguration.class.getClassLoader(), previous));

      ProcessApplicationInterface app = bundleContext.getService(reference);

      app.deploy();
      return app;

    } finally {
      Thread.currentThread().setContextClassLoader(previous);
    }

  }