Java BundleEvent.STOPPING属性代码示例

private String getBundleEventTypeText(int type) {
    switch (type) {
        case BundleEvent.INSTALLED:
            return "Installed";
        case BundleEvent.RESOLVED:
            return "Resolved";
        case BundleEvent.LAZY_ACTIVATION:
            return "Lazy Activation";
        case BundleEvent.STARTING:
            return "Starting";
        case BundleEvent.STARTED:
            return "Started";
        case BundleEvent.STOPPING:
            return "Stopping";
        case BundleEvent.STOPPED:
            return "Stopped";
        case BundleEvent.UPDATED:
            return "Updated";
        case BundleEvent.UNRESOLVED:
            return "Unresolved";
        case BundleEvent.UNINSTALLED:
            return "Uninstalled";
        default:
            return type + " ???";
        }
}
 

@Override
public void bundleChanged(final BundleEvent event) {
    switch (event.getType()) {
        // FIXME: STARTING instead of STARTED?
        case BundleEvent.STARTED:
            scanBundleForPlugins(event.getBundle());
            break;

        case BundleEvent.STOPPING:
            stopBundlePlugins(event.getBundle());
            break;

        default:
            break;
    }
}
 

private static String bundleEventToString(int type) {
    String s;
    switch (type) {
    case BundleEvent.INSTALLED:
        s = "INSTALLED";
        break;
    case BundleEvent.RESOLVED:
        s = "RESOLVED";
        break;
    case BundleEvent.STARTING:
        s = "STARTING";
        break;
    case BundleEvent.STARTED:
        s = "STARTED";
        break;
    case BundleEvent.STOPPING:
        s = "STOPPING";
        break;
    case BundleEvent.STOPPED:
        s = "STOPPED";
        break;
    case BundleEvent.UNRESOLVED:
        s = "UNRESOLVED";
        break;
    case BundleEvent.UPDATED:
        s = "UPDATED";
        break;
    case BundleEvent.UNINSTALLED:
        s = "UNINSTALLED";
        break;
    case BundleEvent.LAZY_ACTIVATION:
        s = "LAZY_ACTIVATION";
        break;
    default:
        s = "UNKNOWN";
    }
    return s;
}
 

@Override
public void bundleChanged(final BundleEvent event) {
    if (this.configRegistry == null) {
        return;
    }

    // If the system bundle (id 0) is stopping close the ConfigRegistry so it
    // destroys all modules. On
    // shutdown the system bundle is stopped first.
    if (event.getBundle().getBundleId() == SYSTEM_BUNDLE_ID && event.getType() == BundleEvent.STOPPING) {
        this.configRegistry.close();
    }
}
 

/**
 * Implemented from SynchronousBundleListener.
 */
@Override
public void bundleChanged(final BundleEvent event) {
    // If the system bundle (id 0) is stopping, do an orderly shutdown of all blueprint containers. On
    // shutdown the system bundle is stopped first.
    if (event.getBundle().getBundleId() == SYSTEM_BUNDLE_ID && event.getType() == BundleEvent.STOPPING) {
        shutdownAllContainers();
    }
}
 

@Override
public void bundleChanged(BundleEvent event) {
	if(event.getBundle().getHeaders().get("NeuralNetwork")==null)
		return;
		
	if(event.getType()==BundleEvent.STARTING){
		nnBundleStarting(event.getBundle());
	} else if(event.getType()==BundleEvent.STOPPING){
		nnBundleStopping(event.getBundle());
	}
}
 

@Override
public void bundleChanged(BundleEvent event) {

	if (event.getType() == BundleEvent.STARTED || event.getType() == BundleEvent.UPDATED) {
		doBundle(event.getBundle(), SENSIVITY.UPDATE);
	} else
	if (event.getType() == BundleEvent.STOPPING ) {
		doDelete(event.getBundle());
	}
	
}
 

private static final String bundleEventType2String(int bundleEventType) {
	switch (bundleEventType) {
		case BundleEvent.INSTALLED:
			// The bundle has been installed.
			return "INSTALLED";
		case BundleEvent.LAZY_ACTIVATION:
			// The bundle will be lazily activated
			return "LAZY_ACTIVATION";
		case BundleEvent.RESOLVED:
			// The bundle has been resolved
			return "RESOLVED";
		case BundleEvent.STARTED:
			// The bundle has been started
			return "STARTED";
		case BundleEvent.STARTING:
			// The bundle is about to be activated
			return "STARTING";
		case BundleEvent.STOPPED:
			// The bundle has been stopped
			return "STOPPED";
		case BundleEvent.STOPPING:
			// The bundle is about to deactivated
			return "STOPPING";
		case BundleEvent.UNINSTALLED:
			// The bundle has been uninstalled
			return "UNINSTALLED";
		case BundleEvent.UNRESOLVED:
			// The bundle has been unresolved
			return "UNRESOLVED";
		case BundleEvent.UPDATED:
			// The bundle has been updated
			return "UPDATED";
		default:
			return "UNKNOWN_BUNDLE_EVENT_TYPE";
	}
}
 

protected void handleEvent(BundleEvent event) {

			Bundle bundle = event.getBundle();

			// ignore current bundle for context creation
			if (bundle.getBundleId() == bundleId) {
				return;
			}

			switch (event.getType()) {
				case BundleEvent.STARTED: {
					maybeCreateApplicationContextFor(bundle);
					break;
				}
				case BundleEvent.STOPPING: {
					if (OsgiBundleUtils.isSystemBundle(bundle)) {
						if (log.isDebugEnabled()) {
							log.debug("System bundle stopping");
						}
						// System bundle is shutting down; Special handling for
						// framework shutdown
						shutdown();
					}
					else {
						maybeCloseApplicationContextFor(bundle);
					}
					break;
				}
				default:
					break;
			}
		}
 

public void bundleChanged(BundleEvent event) {
	Bundle bundle = event.getBundle();
	boolean trace = log.isTraceEnabled();

	switch (event.getType()) {
	case BundleEvent.STARTED: {
		if (trace)
			log.trace("Processing " + OsgiStringUtils.nullSafeToString(event) + " event for bundle "
					+ OsgiStringUtils.nullSafeNameAndSymName(bundle));

		maybeDeployWar(bundle);

		break;
	}
	case BundleEvent.STOPPING: {
		if (trace)
			log.trace("Processing " + OsgiStringUtils.nullSafeToString(event) + " event for bundle "
					+ OsgiStringUtils.nullSafeNameAndSymName(bundle));

		maybeUndeployWar(bundle);

		break;
	}
	default:
		break;
	}
}
 

@Override
public void bundleChanged(BundleEvent event) {
    switch (event.getType()) {
        case BundleEvent.STOPPING:
            long bundleId = event.getBundle().getBundleId();
            Set<Type> types = cache.remove(bundleId);
            if (types != null && !types.isEmpty()) {
                registryHook.invalidateAll(types);
            }
            break;
        default:
            //nothing to do
    }
}
 

@Override
public void bundleChanged(BundleEvent event) {
	String type;
	Level level;
	switch (event.getType()) {
		case BundleEvent.INSTALLED:
			level = Level.INFO;
			type = "INSTALLED";
			break;
		case BundleEvent.RESOLVED:
			level = Level.FINE;
			type = "RESOLVED";
			break;
		case BundleEvent.LAZY_ACTIVATION:
			level = Level.FINE;
			type = "LAZY_ACTIVATION";
			break;
		case BundleEvent.STARTING:
			level = Level.FINE;
			type = "STARTING";
			break;
		case BundleEvent.STARTED:
			level = Level.INFO;
			type = "STARTED";
			break;
		case BundleEvent.STOPPING:
			level = Level.FINE;
			type = "STOPPING";
			break;
		case BundleEvent.STOPPED:
			level = Level.INFO;
			type = "STOPPED";
			break;
		case BundleEvent.UPDATED:
			level = Level.INFO;
			type = "UPDATED";
			break;
		case BundleEvent.UNRESOLVED:
			level = Level.FINE;
			type = "UNRESOLVED";
			break;
		case BundleEvent.UNINSTALLED:
			level = Level.INFO;
			type = "UNINSTALLED";
			break;
		default:
			level = Level.OFF;
			type = "<Unknown type: " + event.getType() + ">";
			break;
	}
	StringBuilder sb = new StringBuilder();
	sb.append(type);
	if (event.getBundle() != null) {
		sb.append(" bundle=[")
				.append(event.getBundle())
				.append("]");
	}
	if (event.getOrigin() != null) {
		sb.append(" origin=[")
				.append(event.getOrigin())
				.append("]");
	}
	LOGGER_BUNDLE.log(level, sb.toString());
}
 

public void bundleChanged(BundleEvent event) {
	if (event.getType() == BundleEvent.STOPPING
			&& event.getBundle().getBundleId() == getPlugin().getBundle().getBundleId()) {
		dispose();
	}
}