Java BundleEvent.UNINSTALLED属性代码示例

public synchronized void stopBundle() throws BundleException {
    if (this.state == BundleEvent.INSTALLED) {
        throw new IllegalStateException("Cannot stop uninstalled bundle "
                + toString());
    } else if (this.state == BundleEvent.RESOLVED) {
        this.state = BundleEvent.UNINSTALLED;
        try {
            if (Framework.DEBUG_BUNDLES && log.isInfoEnabled()) {
                log.info("Framework: Bundle " + toString() + " stopped.");
            }
            Framework.clearBundleTrace(this);
            this.state = BundleEvent.STOPPED;
            Framework.notifyBundleListeners(BundleEvent.STOPPED, this);
            isValid = false;
        } catch (Throwable th) {

            Framework.clearBundleTrace(this);
            this.state = BundleEvent.STOPPED;
            Framework.notifyBundleListeners(BundleEvent.STOPPED, this);
            isValid = false;
        }
    }
}
 

static void shutdown(boolean restart) {
    System.out.println("---------------------------------------------------------");
    System.out.println("  ACDD OSGi shutting down ...");
    System.out.println("  Bye !");
    System.out.println("---------------------------------------------------------");
    systemBundle.state = BundleEvent.UNINSTALLED;
    systemBundle.setLevel(getBundles().toArray(new Bundle[bundles.size()]), 0, true);
    bundles.clear();
    systemBundle.state = BundleEvent.INSTALLED;
    if (restart) {
        try {
            startup();
        } catch (Throwable th) {
            th.printStackTrace();
        }
    }
}
 

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 + " ???";
        }
}
 

/**
 * Returns the specified bundle event as string.
 * @param event the bundle event
 * @return the bundle event as string
 */
private String getBundleEventAsString(BundleEvent event) {
	
	if (event == null) return "null";
	
	int type = event.getType();
	switch (type) {
	case BundleEvent.INSTALLED:
		return "INSTALLED";
	case BundleEvent.LAZY_ACTIVATION:
		return "LAZY_ACTIVATION";
	case BundleEvent.RESOLVED:
		return "RESOLVED";
	case BundleEvent.STARTED:
		return "STARTED";
	case BundleEvent.STARTING:
		return "STARTING";
	case BundleEvent.STOPPED:
		return "STOPPED";
	case BundleEvent.UNINSTALLED:
		return "UNINSTALLED";
	case BundleEvent.UNRESOLVED:
		return "UNRESOLVED";
	case BundleEvent.UPDATED:
		return "UPDATED";
	default:
		return "unknown event type: " + type;
	}
}
 

@Override
public void bundleChanged(BundleEvent event) {
    if ((event.getType() & (BundleEvent.RESOLVED)) != 0) {
        handlePotentialEclipseLink(event.getBundle());
    } else if (event.getType() == BundleEvent.UNRESOLVED || event.getType() == BundleEvent.UNINSTALLED) {
        ServiceRegistration<?> reg = registeredProviders.remove(event.getBundle());
        if (reg != null) {
            reg.unregister();
        }
    }
}
 

@Override
public void bundleChanged(BundleEvent event) {
    switch (event.getType()) {
        case BundleEvent.INSTALLED:
        case BundleEvent.UPDATED:
            Message msg = Message.obtain();
            msg.obj = event.getBundle();
            mHandler.sendMessageDelayed(msg,3000);
            break;
        case BundleEvent.STARTED:
        case BundleEvent.STOPPED:
        case BundleEvent.UNINSTALLED:
            break;
    }
}
 

@SuppressLint("NewApi") @Override
public void bundleChanged(final BundleEvent event){
    switch (event.getType()) {
        case 0:/* LOADED */
            loaded(event.getBundle());
            break;
        case BundleEvent.INSTALLED:
            //todo 注意主dex bundle
            installed(event.getBundle());
            break;
        case BundleEvent.UPDATED:
            updated(event.getBundle());
            break;
        case BundleEvent.UNINSTALLED:
            uninstalled(event.getBundle());
            break;
        case BundleEvent.STARTED:
        	if(isLewaOS()){
        		if(Looper.myLooper() == null){
        			Looper.prepare();
        		}
                started(event.getBundle());
        	}else{
                started(event.getBundle());
        	}  
        	break;
        case BundleEvent.STOPPED:
            stopped(event.getBundle());
            break;
    }
}
 

@Override
public void bundleChanged(BundleEvent event) {
    int mask = BundleEvent.INSTALLED | BundleEvent.RESOLVED | BundleEvent.UNRESOLVED | BundleEvent.UPDATED | BundleEvent.UNINSTALLED;
    if ((mask & event.getType()) > 0) {
        invalidateAllUnits(String.format("Bundle %s entered state %s", event.getBundle().getSymbolicName(), bundleEventToString(event.getType())));
    }
}
 

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;
}
 

public void bundleChanged(BundleEvent event) {
	if (BundleEvent.STOPPED == event.getType() || BundleEvent.UNINSTALLED == event.getType()
			|| BundleEvent.UNRESOLVED == event.getType()) {
		BlueprintEvent removed = events.remove(event.getBundle());
		if (log.isTraceEnabled())
			log.trace("Removed  bundle " + event.getBundle() + " for sending replayes events; last one was "
					+ removed);
	}
}
 

/**
 * 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);
}
 

@Override
public void bundleChanged( BundleEvent event ) {
    long bundleId = event.getBundle().getBundleId();
    switch ( event.getType() ) {
        case BundleEvent.INSTALLED:
            subscribeBundle( bundleId );
            break;
        case BundleEvent.UNINSTALLED:
            pendingForRegistration.remove( bundleId );
            break;
    }
}
 

public void bundleChanged(BundleEvent event) {
    if (event.getType() == BundleEvent.RESOLVED) {
        register(event.getBundle());
    } else if (event.getType() == BundleEvent.UNRESOLVED || event.getType() == BundleEvent.UNINSTALLED) {
        unregister(event.getBundle().getBundleId());
    }
}
 

/**
 * Receives notification that the entities bundle has had a lifecycle change and checks it
 * current status.
 *
 * @param event The {@code BundleEvent}.
 */
@Override
public void bundleChanged(BundleEvent event) {
    if (isEntities(event.getBundle())) {
        LOGGER.info("Entities Bundle Status: {}", nullSafeToString(event));

        synchronized (lock) {
            int type = event.getType();

            bundleStarted = type == BundleEvent.STARTED;
            bundleInstalled = type == BundleEvent.INSTALLED;
            bundleUninstalled = type == BundleEvent.UNINSTALLED;
        }
    }
}
 

private void handleBundleEvent(final Bundle bundle, final int eventType) {
    if (eventType == BundleEvent.INSTALLED || eventType == BundleEvent.UPDATED) {
        if (processingSuspended) {
            awaitingBundles.add(new AwaitingBundle(bundle, eventType));
        } else {
            processSingleBundle(bundle);
        }
    } else if (eventType == BundleEvent.UNRESOLVED && !skipBundle(bundle)) {
        LOGGER.info("Unregistering JDO classes for Bundle: {}", bundle.getSymbolicName());
        MdsBundleHelper.unregisterBundleJDOClasses(bundle);
    } else if (eventType == BundleEvent.UNINSTALLED && !skipBundle(bundle)) {
        SchemaHolder schemaHolder = lockAndGetSchema();
        refreshBundle(bundle, schemaHolder);
    }
}