org.osgi.framework.ServiceListener#org.osgi.framework.BundleListener源码实例Demo

@Test
public void testSetOSGiModelField() throws Exception {
    ServiceReference ref1 = mock(ServiceReference.class);
    ServiceInterface service1 = mock(ServiceInterface.class);
    when(bundleContext.getService(ref1)).thenReturn(service1);
    ServiceReference ref2 = mock(ServiceReference.class);
    ServiceInterface service2 = mock(ServiceInterface.class);
    when(bundleContext.getService(ref2)).thenReturn(service2);

    when(bundleContext.getServiceReferences(ServiceInterface.class.getName(), null)).thenReturn(
            new ServiceReference[] { ref1, ref2 });

    Resource res = mock(Resource.class);

    SetOSGiModel model = factory.getAdapter(res, SetOSGiModel.class);
    assertNull(model);

    verify(bundleContext).registerService(eq(Runnable.class), eq(factory), any(Dictionary.class));
    verify(bundleContext).addBundleListener(any(BundleListener.class));
    verify(bundleContext).registerService(eq(Object.class), any(Object.class), any(Dictionary.class));
    verify(bundleContext).getBundles();
    verify(bundleContext).getBundle();
    verifyNoMoreInteractions(res, bundleContext);
}
 

/**
 * add a bundle listener.
 * 
 * @param listener
 *            a bundle listener.
 * @see org.osgi.framework.BundleContext#addBundleListener(org.osgi.framework.BundleListener)
 */
public void addBundleListener(final BundleListener listener) {
	checkValid();

	final List<BundleListener> registered = bundleListenerMap.get(this);

	if (registered == null || !registered.contains(listener)) {
		if (listener instanceof SynchronousBundleListener) {
			syncBundleListeners
					.add((SynchronousBundleListener) listener);
		} else {
			bundleListeners.add(listener);
		}
		bundleListenerMap.insert(this, listener);
	}
}
 

/**
 * This test will add a bundle listener to framework. Within bundle listener
 * it tries to read a resource from bundle when bundle event indicates
 * bundle has been INSTALLED. This is typically used in an extender pattern.
 */
@Test
//@Ignore("Does not work. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=467160")
public void testGetEntryFromBundleListenerInstalledEvent() throws Exception {
	SyntheticBundleBuilder builder = SyntheticBundleBuilder.newBuilder();
	builder.bundleSymbolicName("bundle");
	builder.addFile("plugin.properties", "# props");
	// register a bundle listener
	framework.getBundleContext().addBundleListener(new BundleListener() {
		public void bundleChanged(BundleEvent event) {
			if (event.getType() == BundleEvent.INSTALLED) {
				// get resources from bundle
				URL res1 = event.getBundle().getEntry("/plugin.properties");
				Assert.assertNotNull(res1);
				Assert.assertEquals("# props",
						TestUtils.getContentFromUrl(res1));

			}
		}
	});
	// now trigger install
	bundleUnderTest = installBundle(builder);
}
 

@Test
public void testGetEntryFromBundleListenerResolverEvent() throws Exception {
	SyntheticBundleBuilder builder = SyntheticBundleBuilder.newBuilder();
	builder.bundleSymbolicName("bundle");
	builder.addFile("plugin.properties", "# props");
	// register a bundle listener
	framework.getBundleContext().addBundleListener(new BundleListener() {
		public void bundleChanged(BundleEvent event) {
			if (event.getType() == BundleEvent.RESOLVED) {
				// get resources from bundle
				URL res1 = event.getBundle().getEntry("/plugin.properties");
				Assert.assertNotNull(res1);
				Assert.assertEquals("# props",
						TestUtils.getContentFromUrl(res1));

			}
		}
	});
	// now trigger install
	bundleUnderTest = installBundle(builder);
}
 

public boolean runTest() {
  BundleListener[] listeners = new BundleListener[NUM_LISTENERS];
  for (int i = 0; i < NUM_LISTENERS; i++) {
    listeners[i] = new MyBundleListener();
    bc.addBundleListener(listeners[i]);
  }
  try {
    bundle.stop();
    bundle.start();
  } catch (BundleException e) {
    return false;
  }
    
  for (int i = 0; i < NUM_LISTENERS; i++) {
    bc.removeBundleListener(listeners[i]);
  }
  
  return true;
}
 

static void notifyBundleListeners(int event, Bundle bundle) {

        if (!syncBundleListeners.isEmpty() || !bundleListeners.isEmpty()) {
            BundleEvent bundleEvent = new BundleEvent(event, bundle);
            BundleListener[] bundleListenerArr = syncBundleListeners.toArray(new BundleListener[syncBundleListeners.size()]);
            for (BundleListener bundleChanged : bundleListenerArr) {
                bundleChanged.bundleChanged(bundleEvent);
            }
            if (!bundleListeners.isEmpty()) {
                bundleListenerArr = bundleListeners.toArray(new BundleListener[bundleListeners.size()]);
                for (BundleListener bundleListener : bundleListenerArr) {
                    bundleListener.bundleChanged(bundleEvent);
                }

            }
        }
    }
 

static void notifyBundleListeners(int i, Bundle bundle) {
    int i2 = 0;
    if (!syncBundleListeners.isEmpty() || !bundleListeners.isEmpty()) {
        BundleEvent bundleEvent = new BundleEvent(i, bundle);
        BundleListener[] bundleListenerArr = (BundleListener[]) syncBundleListeners.toArray(new BundleListener[syncBundleListeners.size()]);
        for (BundleListener bundleChanged : bundleListenerArr) {
            bundleChanged.bundleChanged(bundleEvent);
        }
        if (!bundleListeners.isEmpty()) {
            bundleListenerArr = (BundleListener[]) bundleListeners.toArray(new BundleListener[bundleListeners.size()]);
            while (i2 < bundleListenerArr.length) {
                bundleListenerArr[i2].bundleChanged(bundleEvent);
                i2++;
            }
        }
    }
}
 

private void addBundlerListener(BundleContext context) {
	// Listen for our STARTED event
	// Alternatively, we can get the bundle from org.osgi.framework.FrameworkUtil
	context.addBundleListener(new BundleListener() {
		public void bundleChanged(BundleEvent event) {
			String name = event.getBundle().getSymbolicName();
			if (name != null && name.equals(PLUGIN_ID)) {
				switch (event.getType()) {
					case BundleEvent.STARTED:
						bundleStarted();
						break;
					case BundleEvent.UNINSTALLED:
						emacsIds = null;
						break;
					default:
						break;
				}
			}
		}
	});
}
 

/**
 * Constructor.
 * 
 * @param context
 *            the {@link BundleContext}
 * @param classLoader
 *            the fall back {@link ClassLoader}
 */
public EclipseClassProvider(BundleContext context, ClassLoader classLoader) {
    super(classLoader);
    this.context = context;
    for (Bundle bundle : context.getBundles()) {
        bundles.put(bundle.getSymbolicName(), bundle);
    }
    listener = new BundleListener() {

        @Override
        public void bundleChanged(BundleEvent event) {
            switch (event.getType()) {
                case BundleEvent.INSTALLED:
                    bundles.put(event.getBundle().getSymbolicName(), event.getBundle());
                    break;

                case BundleEvent.UNINSTALLED:
                    bundles.remove(event.getBundle().getSymbolicName());
                    break;

                default:
                    // nothing to do here
                    break;
            }
        }
    };
    context.addBundleListener(listener);
}
 

/**
 * clear all traces of a bundle.
 * 
 * @param bundle
 *            the bundle.
 */
void clearBundleTrace(final AbstractBundle bundle) {
	// remove all registered listeners
	if (bundle.registeredFrameworkListeners != null) {
		frameworkListeners.removeAll(bundle.registeredFrameworkListeners);
		bundle.registeredFrameworkListeners = null;
	}
	if (bundle.registeredServiceListeners != null) {
		serviceListeners.removeAll(bundle.registeredServiceListeners);
		bundle.registeredServiceListeners = null;
	}
	final List<BundleListener> bundleListeners = bundleListenerMap
			.get(bundle.context);
	if (bundleListeners != null) {
		bundleListeners.removeAll(bundleListeners);
		syncBundleListeners.removeAll(bundleListeners);
		bundleListenerMap.remove(bundle.context);
	}

	// unregister registered services
	final ServiceReference<?>[] regs = bundle.getRegisteredServices();

	if (regs != null) {
		for (int i = 0; i < regs.length; i++) {
			unregisterService(regs[i]);
			((ServiceReferenceImpl<?>) regs[i]).invalidate();
		}
		bundle.registeredServices = null;
	}

	// unget all using services
	final ServiceReference<?>[] refs = bundle.getServicesInUse();
	if (refs != null) {
		for (int i = 0; i < refs.length; i++) {
			ServiceReferenceImpl<?> ref = ((ServiceReferenceImpl<?>) refs[i]); 
			ref.ungetAllServices(bundle);
		}
	}
}
 

/**
 * remove a bundle listener.
 * 
 * @param listener
 *            a bundle listener.
 * @see org.osgi.framework.BundleContext#removeBundleListener(org.osgi.framework.BundleListener)
 * 
 */
public void removeBundleListener(final BundleListener listener) {
	checkValid();

	if (bundle == Concierge.this) {
		return;
	}

	(listener instanceof SynchronousBundleListener ? syncBundleListeners
			: bundleListeners).remove(listener);
	bundleListenerMap.remove(this, listener);
}
 

/**
 * Add a bundle listener to the current framework.
 *
 * @param bundle Who wants to add listener.
 * @param listener Object to add.
 */
void addBundleListener(BundleContextImpl bc, BundleListener listener) {
  final ListenerEntry le = new ListenerEntry(bc, listener);
  if (listener instanceof SynchronousBundleListener) {
    secure.checkListenerAdminPerm(bc.bundle);
    synchronized (syncBundleListeners) {
        syncBundleListeners.add(le);
    }
  }
  else {
    synchronized (bundleListeners) {
        bundleListeners.add(le);
    }
  }
}
 

/**
 * Remove bundle listener from current framework. Silently ignore
 * if listener doesn't exist. If listener is registered more than
 * once remove one instances.
 *
 * @param bundle Who wants to remove listener.
 * @param listener Object to remove.
 */
void removeBundleListener(BundleContextImpl bc, BundleListener listener) {
  final ListenerEntry le = new ListenerEntry(bc, listener);
  if (listener instanceof SynchronousBundleListener) {
    synchronized (syncBundleListeners) {
      secure.checkListenerAdminPerm(bc.bundle);
      syncBundleListeners.remove(le);
    }
  } else {
    synchronized (bundleListeners) {
      bundleListeners.remove(le);
    }
  }
}
 

/**
 *
 */
private void bundleChanged(final ListenerEntry le, final BundleEvent evt) {
  try {
    ((BundleListener)le.listener).bundleChanged(evt);
  } catch (final Throwable pe) {
    fwCtx.frameworkError(le.bc, pe);
  }
}
 

public void addBundleListener(BundleListener bundleListener) {
    checkValid();
    List list = bundleListener instanceof SynchronousBundleListener ? Framework.syncBundleListeners : Framework.bundleListeners;
    if (this.bundle.registeredBundleListeners == null) {
        this.bundle.registeredBundleListeners = new ArrayList();
    }
    if (!this.bundle.registeredBundleListeners.contains(bundleListener)) {
        list.add(bundleListener);
        this.bundle.registeredBundleListeners.add(bundleListener);
    }
}
 

public void removeBundleListener(BundleListener bundleListener) {
    checkValid();
    (bundleListener instanceof SynchronousBundleListener ? Framework.syncBundleListeners : Framework.bundleListeners).remove(bundleListener);
    this.bundle.registeredBundleListeners.remove(bundleListener);
    if (this.bundle.registeredBundleListeners.isEmpty()) {
        this.bundle.registeredBundleListeners = null;
    }
}
 

public void start(final BundleContext bundleContext) throws Exception {

		/*
         * Check for the services that should be deployed before this if there
		 * are any.
		 * if there are such services we wait for such bundles to deploy and
		 * gets the notification
		 * through a service listener.
		 */

        // first check whether there are such services and they have already
        // deployed.
        String pendingBundleName = null;
        final List<Bundle> pendingBundles = new ArrayList<Bundle>();
        for (Bundle bundle : bundleContext.getBundles()) {
            pendingBundleName = (String) bundle.getHeaders().get(DEPLOY_BEFORE);
            if ((pendingBundleName != null) && (pendingBundleName.equals(getName())) &&
                    (bundle.getState() != Bundle.ACTIVE)) {
                // i.e this bundle should be started before the user manager but
                // yet has not started
                pendingBundles.add(bundle);
            }
        }

        if (pendingBundles.isEmpty()) {
            startDeploy(bundleContext);
        } else {
            BundleListener bundleListener = new BundleListener() {
                public void bundleChanged(BundleEvent bundleEvent) {
                    synchronized (pendingBundles) {
                        if (bundleEvent.getType() == BundleEvent.STARTED) {

                            pendingBundles.remove(bundleEvent.getBundle());
                            if (pendingBundles.isEmpty()) {
                                // now start the user manager deployment
                                bundleContext.removeBundleListener(this);
                                try {
                                    startDeploy(bundleContext);
                                } catch (Exception e) {
                                    log.error("Can not start the bundle ", e);
                                }
                            }
                        }
                    }
                }
            };
            bundleContext.addBundleListener(bundleListener);
        }
    }
 

public void addBundleListener(BundleListener bl) {
}
 

public void removeBundleListener(BundleListener bl) {
}
 

public void removeBundleListener(BundleListener bl) {
    delegate.removeBundleListener(bl);
}
 

public void addBundleListener(BundleListener bl) {
    delegate.addBundleListener(bl);
}
 

@Override
public void addBundleListener(BundleListener listener) {
}
 

@Override
public void removeBundleListener(BundleListener listener) {
}
 

/**
 * notify all bundle listeners.
 * 
 * @param state
 *            the new state.
 * @param bundle
 *            the bundle.
 */
void notifyBundleListeners(final int state, final Bundle bundle,
		final Bundle origin) {
	if (syncBundleListeners.isEmpty() && bundleListeners.isEmpty()) {
		return;
	}

	final BundleEvent event = new BundleEvent(state, bundle, origin);

	final SynchronousBundleListener[] syncs;
	final BundleListener[] asyncs;

	// call the hooks, if any
	if (!bundleEventHooks.isEmpty()) {
		final ArrayList<SynchronousBundleListener> syncListeners = new ArrayList<SynchronousBundleListener>(
				syncBundleListeners);
		final ArrayList<BundleListener> asyncListeners = new ArrayList<BundleListener>(
				bundleListeners);

		final ConciergeCollections.DeltaTrackingRemoveOnlyList<BundleContext> contexts = new ConciergeCollections.DeltaTrackingRemoveOnlyList<BundleContext>(
				bundleListenerMap.keySet());

		for (final ServiceReferenceImpl<org.osgi.framework.hooks.bundle.EventHook> sref : bundleEventHooks) {
			final org.osgi.framework.hooks.bundle.EventHook eventHook = sref
					.getService(Concierge.this);
			if (eventHook != null) {
				try {
					eventHook.event(event, contexts);
				} catch (final Throwable t) {
					// TODO: to log?
				}
			}
			sref.ungetService(Concierge.this);
		}

		for (final BundleContext removed : contexts.getRemoved()) {
			if(removed != this.context){ // system bundle contexts listeners always gets events
				for (final BundleListener listener : bundleListenerMap
					.get(removed)) {
					syncListeners.remove(listener);
					asyncListeners.remove(listener);
				}
			}
		}

		syncs = syncListeners.toArray(
				new SynchronousBundleListener[syncListeners.size()]);
		asyncs = asyncListeners
				.toArray(new BundleListener[asyncListeners.size()]);
	} else {
		syncs = syncBundleListeners.toArray(
				new SynchronousBundleListener[syncBundleListeners.size()]);
		asyncs = bundleListeners
				.toArray(new BundleListener[bundleListeners.size()]);
	}

	for (int i = 0; i < syncs.length; i++) {
		syncs[i].bundleChanged(event);
	}

	// asynchronous listeners do not get these events
	final int type = event.getType();
	if (bundleListeners.isEmpty() || (type & (BundleEvent.STARTING
			| BundleEvent.STOPPING | BundleEvent.LAZY_ACTIVATION)) > 0) {
		return;
	}

	for (int i = 0; i < asyncs.length; i++) {
		asyncs[i].bundleChanged(event);
	}
}
 

public void addBundleListener(BundleListener bundleListener) {
    Framework.addBundleListener(bundleListener);
}
 

public void removeBundleListener(BundleListener bundleListener) {
    Framework.removeBundleListener(bundleListener);
}
 

static void addBundleListener(BundleListener bundleListener) {
    bundleListeners.add(bundleListener);
}
 

static void removeBundleListener(BundleListener bundleListener) {
    bundleListeners.remove(bundleListener);
}
 

public void addBundleListener(BundleListener bundleListener) {
    Framework.addBundleListener(bundleListener);
}
 

public void removeBundleListener(BundleListener bundleListener) {
    Framework.removeBundleListener(bundleListener);
}