Java Bundle.STARTING屬性代碼示例

@Activate
void activate(BundleContext ctx) {
    this.base = new File("").toURI();
    // Find the resolved vaadin bundle
    this.vaadinResourceBundles = new BundleTracker<Bundle>(ctx, Bundle.RESOLVED |
            Bundle.STARTING | Bundle.ACTIVE | Bundle.STOPPING,
                new BundleTrackerCustomizer<Bundle>() {
                    @Override
                    public Bundle addingBundle(Bundle bundle, BundleEvent event) {
                        return VAADIN_SERVER_BUNDLE.equals(bundle.getSymbolicName()) ?
                                bundle : null;
                    }

                    @Override
                    public void modifiedBundle(Bundle bundle, BundleEvent event, Bundle object) {

                    }

                    @Override
                    public void removedBundle(Bundle bundle, BundleEvent event, Bundle object) {
                    }
            });
    this.vaadinResourceBundles.open();
}
 

void addEvent(BlueprintEvent event) {
	// copy event
	BlueprintEvent replay = new BlueprintEvent(event, true);
	Bundle bnd = replay.getBundle();
	if (bnd.getState() == Bundle.ACTIVE || bnd.getState() == Bundle.STARTING || bnd.getState() == Bundle.STOPPING) {
		events.put(bnd, replay);
		if (log.isTraceEnabled())
			log.trace("Adding replay event  " + replay.getType() + " for bundle " + replay.getBundle());
	} else {
		if (log.isTraceEnabled()) {
			log.trace("Replay event " + replay.getType() + " ignored; " + "owning bundle has been uninstalled "
					+ bnd);
			events.remove(bnd);
		}
	}
}
 

/**
 * Indicates if the given bundle is lazily activated or not. That is, the
 * bundle has a lazy activation policy and a STARTING state. Bundles that
 * have been lazily started but have been activated will return false.
 * 
 * <p/>
 * On OSGi R4.0 platforms, this method will always return false.
 * 
 * @param bundle OSGi bundle
 * @return true if the bundle is lazily activated, false otherwise.
 */
@SuppressWarnings("unchecked")
public static boolean isBundleLazyActivated(Bundle bundle) {
	Assert.notNull(bundle, "bundle is required");

	if (OsgiPlatformDetector.isR41()) {
		if (bundle.getState() == Bundle.STARTING) {
			Dictionary<String, String> headers = bundle.getHeaders();
			if (headers != null) {
				Object val = headers.get(Constants.BUNDLE_ACTIVATIONPOLICY);
				if (val != null) {
					String value = ((String) val).trim();
					return (value.startsWith(Constants.ACTIVATION_LAZY));
				}
			}
		}
	}
	return false;
}
 

public void testIsBundleResolved() throws Exception {
	OsgiBundleUtilsTest.state = Bundle.UNINSTALLED;
	assertFalse(OsgiBundleUtils.isBundleResolved(bundle));

	OsgiBundleUtilsTest.state = Bundle.INSTALLED;
	assertFalse(OsgiBundleUtils.isBundleResolved(bundle));

	OsgiBundleUtilsTest.state = Bundle.ACTIVE;
	assertTrue(OsgiBundleUtils.isBundleResolved(bundle));

	OsgiBundleUtilsTest.state = Bundle.RESOLVED;
	assertTrue(OsgiBundleUtils.isBundleResolved(bundle));
	
	OsgiBundleUtilsTest.state = Bundle.STOPPING;
	assertTrue(OsgiBundleUtils.isBundleResolved(bundle));

	OsgiBundleUtilsTest.state = Bundle.STARTING;
	assertTrue(OsgiBundleUtils.isBundleResolved(bundle));

}
 

public @Override boolean isEnabled() {
    switch (b.getState()) {
    case Bundle.RESOLVED:
    case Bundle.ACTIVE:
    case Bundle.STARTING:
    case Bundle.STOPPING:
        return true;
    default:
        return false;
    }
}
 

public @Override void start(final BundleContext context) throws Exception {
        if (System.getProperty("netbeans.home") != null) {
            throw new IllegalStateException("Should not be run from inside regular NetBeans module system");
        }
        String storage = context.getProperty(Constants.FRAMEWORK_STORAGE);
        if (storage != null) {
            System.setProperty("netbeans.user", storage);
        }
        System.setProperty("TopSecurityManager.disable", "true");
        NbBundle.setBranding(System.getProperty("branding.token"));
        OSGiMainLookup.initialize(context);
        queue = new DependencyQueue<String,Bundle>();
        this.context = context;
        framework = ((Framework) context.getBundle(0));
        if (framework.getState() == Bundle.STARTING) {
            LOG.fine("framework still starting");
            final AtomicReference<FrameworkListener> frameworkListener = new AtomicReference<FrameworkListener>();
            frameworkListener.set(new FrameworkListener() {
                public @Override void frameworkEvent(FrameworkEvent event) {
                    if (event.getType() == FrameworkEvent.STARTED) {
//                        System.err.println("framework started");
                        context.removeFrameworkListener(frameworkListener.get());
                        context.addBundleListener(Activator.this);
                        processLoadedBundles();
                    }
                }
            });
            context.addFrameworkListener(frameworkListener.get());
        } else {
            LOG.fine("framework already started");
            context.addBundleListener(this);
            processLoadedBundles();
        }
    }
 

@Override
public void start(BundleContext context) throws Exception {
    registerWeavingHook(context, TransformerRegistrySingleton.get());

    PersistenceBundleTracker customizer = new PersistenceBundleTracker(context.getBundle().adapt(BundleWiring.class));
    persistenceBundleManager = new BundleTracker<Bundle>(context, Bundle.STARTING | Bundle.ACTIVE, customizer);
    persistenceBundleManager.open();
}
 

@Override
public void start(BundleContext ctx) {
    LOG.debug("Starting EclipseLink adapter");
    context = ctx;
    ctx.addBundleListener(this);
    
    for (Bundle b : ctx.getBundles()) {
        if ((b.getState() & (Bundle.ACTIVE | Bundle.STARTING | Bundle.RESOLVED | Bundle.STOPPING)) != 0) 
            handlePotentialEclipseLink(b);
    }
}
 

public void testGetBundleStateAsName() throws Exception {
	OsgiStringUtilsTest.state = Bundle.ACTIVE;
	assertEquals("ACTIVE", OsgiStringUtils.bundleStateAsString(bundle));
	OsgiStringUtilsTest.state = Bundle.STARTING;
	assertEquals("STARTING", OsgiStringUtils.bundleStateAsString(bundle));
	OsgiStringUtilsTest.state = Bundle.STOPPING;
	assertEquals("STOPPING", OsgiStringUtils.bundleStateAsString(bundle));
	OsgiStringUtilsTest.state = -123;
	assertEquals("UNKNOWN STATE", OsgiStringUtils.bundleStateAsString(bundle));
}
 

public void testIsInActiveBundleState() throws Exception {
	OsgiBundleUtilsTest.state = Bundle.ACTIVE;
	assertTrue(OsgiBundleUtils.isBundleActive(bundle));

	OsgiBundleUtilsTest.state = Bundle.STARTING;
	assertFalse(OsgiBundleUtils.isBundleActive(bundle));

	OsgiBundleUtilsTest.state = Bundle.INSTALLED;
	assertFalse(OsgiBundleUtils.isBundleActive(bundle));
}
 

private void assertAllBundlesResolved() {
    int mask = Bundle.RESOLVED | Bundle.STARTING | Bundle.STOPPING | Bundle.ACTIVE;
    for (Bundle bundle : this.bundleContext.getBundles()) {
        assertTrue("Unresolved bundle " + bundle.getSymbolicName(), (bundle.getState() & mask) > 0);
    }
}
 

/**
 * Checks if the specified bundle is resolved or active.
 *
 * @param bundle the bundle
 * @return true, if the bundle is resolved or active
 */
private boolean isBundleStartingResolvedOrActive(Bundle bundle) {
	return (bundle.getState()==Bundle.STARTING || bundle.getState()==Bundle.RESOLVED || bundle.getState()==Bundle.ACTIVE); 
}