public abstract class AbstractBundle extends Object implements Bundle, Comparable<Bundle>, KeyedElement, BundleStartLevel, BundleReference, BundleRevisions
Modifier and Type | Field and Description |
---|---|
protected BundleData |
bundledata
Bundle's BundleData object
|
protected BundleProtectionDomain |
domain
ProtectionDomain for the bundle
|
protected Framework |
framework
The Framework this bundle is part of
|
protected ManifestLocalization |
manifestLocalization |
protected int |
state
The state of the bundle.
|
protected Object |
statechangeLock
Internal object used for state change synchronization
|
protected Thread |
stateChanging
A flag to denote whether a bundle state change is in progress
|
ACTIVE, INSTALLED, RESOLVED, SIGNERS_ALL, SIGNERS_TRUSTED, START_ACTIVATION_POLICY, START_TRANSIENT, STARTING, STOP_TRANSIENT, STOPPING, UNINSTALLED
Modifier | Constructor and Description |
---|---|
protected |
AbstractBundle(BundleData bundledata,
Framework framework)
Bundle object constructor.
|
Modifier and Type | Method and Description |
---|---|
<A> A |
adapt(Class<A> adapterType)
Adapt this bundle to the specified type.
|
protected <A> A |
adapt0(Class<A> adapterType) |
protected void |
beginStateChange()
This method marks the bundle's state as changing so that other calls to
start/stop/suspend/update/uninstall can wait until the state change is
complete.
|
protected void |
checkValid()
This method checks that the bundle is not uninstalled.
|
protected void |
close()
Close the the Bundle's file.
|
boolean |
compare(KeyedElement other)
Compares this element with a specified element
|
int |
compareTo(Bundle obj)
Answers an integer indicating the relative positions of the receiver and
the argument in the natural order of elements of the receiver's class.
|
protected void |
completeStateChange()
This method completes the bundle state change by setting stateChanging
to null and notifying one waiter that the state change has completed.
|
protected static AbstractBundle |
createBundle(BundleData bundledata,
Framework framework,
boolean setBundle)
Bundle object constructor.
|
Enumeration<URL> |
findEntries(String path,
String filePattern,
boolean recurse)
Returns entries in this bundle and its attached fragments.
|
Bundle |
getBundle()
Returns the
Bundle object associated with this
BundleReference . |
BundleContext |
getBundleContext()
Returns this bundle's
BundleContext . |
BundleData |
getBundleData() |
BundleDescription |
getBundleDescription() |
long |
getBundleId()
Retrieve the bundle's unique identifier, which the framework assigned to
this bundle when it was installed.
|
protected abstract BundleLoader |
getBundleLoader() |
protected abstract BundleContextImpl |
getContext()
Return the current context for this bundle.
|
File |
getDataFile(String filename)
Creates a
File object for a file in the persistent storage area
provided for this bundle by the Framework. |
URL |
getEntry(String fileName)
Returns a URL to the entry at the specified path in this bundle.
|
Enumeration<String> |
getEntryPaths(String path)
Returns an Enumeration of all the paths (
String objects) to
entries within this bundle whose longest sub-path matches the specified
path. |
protected BundleFragment[] |
getFragments() |
Framework |
getFramework() |
Dictionary<String,String> |
getHeaders()
Return the bundle's manifest headers and values from the manifest's
preliminary section.
|
Dictionary<String,String> |
getHeaders(String localeString)
Returns this bundle's Manifest headers and values.
|
Object |
getKey()
Returns the key for this element
|
int |
getKeyHashCode()
Returns the hash code of the key
|
long |
getLastModified()
Returns the time when this bundle was last modified.
|
String |
getLocation()
Retrieve the location identifier of the bundle.
|
BundleProtectionDomain |
getProtectionDomain()
Get the bundle's ProtectionDomain.
|
BundleException |
getResolutionFailureException() |
ResourceBundle |
getResourceBundle(String localeString) |
List<BundleRevision> |
getRevisions()
Return the bundle revisions for the
referenced bundle. |
Map<X509Certificate,List<X509Certificate>> |
getSignerCertificates(int signersType)
Return the certificates for the signers of this bundle and the
certificate chains for those signers.
|
int |
getStartLevel()
Return the assigned start level value for the bundle.
|
int |
getState()
Returns the current state of the bundle.
|
Thread |
getStateChanging() |
String |
getSymbolicName()
Returns the symbolic name of this bundle as specified by its
Bundle-SymbolicName manifest header. |
Version |
getVersion()
Returns the version of this bundle as specified by its
Bundle-Version manifest header. |
boolean |
hasPermission(Object permission)
Determine whether the bundle has the requested permission.
|
boolean |
isActivationPolicyUsed()
Returns whether the bundle's autostart setting indicates that the
activation policy declared in the bundle manifest must be used.
|
protected boolean |
isActive()
Return true if the bundle is starting or active.
|
protected boolean |
isFragment() |
boolean |
isPersistentlyStarted()
Returns whether the bundle's autostart setting indicates it must be
started.
|
boolean |
isResolved()
Return true if the bundle is resolved.
|
protected abstract void |
load()
Load the bundle.
|
protected BundleActivator |
loadBundleActivator()
Load and instantiate bundle's BundleActivator class
|
Class<?> |
loadClass(String classname)
Loads the specified class using this bundle's class loader.
|
protected abstract Class<?> |
loadClass(String name,
boolean checkPermission)
This method loads a class from the bundle.
|
protected boolean |
readyToResume()
This method does the following
Return false if the bundle is a fragment
Return false if the bundle is not at the correct start-level
Return false if the bundle is not persistently marked for start
Return true if the bundle's activation policy is persistently ignored
Return true if the bundle does not define an activation policy
Transition to STARTING state and Fire LAZY_ACTIVATION event
Return false
|
protected abstract void |
refresh()
Refresh the bundle.
|
protected abstract boolean |
reload(AbstractBundle newBundle)
Reload from a new bundle.
|
protected void |
resolve()
Mark this bundle as resolved.
|
protected void |
resume()
Start this bundle w/o marking is persistently started.
|
void |
setStartLevel(int startlevel)
Assign a start level value to the bundle.
|
protected void |
setStatus(int mask,
boolean state)
Set the persistent status bit for the bundle.
|
void |
start()
Start this bundle.
|
void |
start(int options)
Starts this bundle.
|
protected abstract void |
startWorker(int options)
Internal worker to start a bundle.
|
void |
stop()
Stop this bundle.
|
void |
stop(int options)
Stops this bundle.
|
protected abstract void |
stopWorker(int options)
Internal worker to stop a bundle.
|
protected void |
suspend(boolean lock)
Stop this bundle w/o marking is persistently stopped.
|
boolean |
testStateChanging(Object thread) |
String |
toString()
Return a string representation of this bundle.
|
void |
uninstall()
Uninstall this bundle.
|
protected void |
uninstallWorker(PrivilegedExceptionAction<Object> action)
Uninstall worker.
|
protected void |
uninstallWorkerPrivileged()
Uninstall worker.
|
protected abstract boolean |
unload()
Unload the bundle.
|
void |
update()
Updates this bundle.
|
void |
update(InputStream in)
Updates this bundle from an
InputStream . |
protected void |
updateWorker(PrivilegedExceptionAction<Object> action)
Update worker.
|
protected void |
updateWorkerPrivileged(URLConnection source,
AccessControlContext callerContext)
Update worker.
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
getRegisteredServices, getResource, getResources, getServicesInUse
protected final Framework framework
protected volatile int state
protected volatile Thread stateChanging
protected BundleData bundledata
protected final Object statechangeLock
protected BundleProtectionDomain domain
protected volatile ManifestLocalization manifestLocalization
protected AbstractBundle(BundleData bundledata, Framework framework)
bundledata
- BundleData for this bundleframework
- Framework this bundle is running inprotected static AbstractBundle createBundle(BundleData bundledata, Framework framework, boolean setBundle) throws BundleException
bundledata
- BundleData for this bundleframework
- Framework this bundle is running inBundleException
protected abstract void load()
protected abstract boolean reload(AbstractBundle newBundle)
newBundle
- Dummy Bundle which contains new data.protected abstract void refresh()
protected abstract boolean unload()
protected void close()
protected BundleActivator loadBundleActivator() throws BundleException
BundleException
protected abstract Class<?> loadClass(String name, boolean checkPermission) throws ClassNotFoundException
name
- the name of the desired Class.checkPermission
- indicates whether a permission check should be done.ClassNotFoundException
- if the class definition was not found.public int getState()
public Framework getFramework()
protected boolean isActive()
public boolean isResolved()
public void start() throws BundleException
Otherwise, the following steps are required to start a bundle:
Bundle.UNINSTALLED
then an IllegalStateException
is thrown.
Bundle.ACTIVE
or Bundle.STARTING
then this
method returns immediately.
Bundle.STOPPING
then this method may wait for
the bundle to return to the Bundle.RESOLVED
state before continuing.
If this does not occur in a reasonable time, a BundleException
is thrown to indicate the bundle was unable to be started.
Bundle.RESOLVED
, an attempt is made to
resolve the bundle. If the bundle cannot be resolved, a
BundleException
is thrown.
Bundle.STARTING
.
start
method of the bundle's
BundleActivator
, if one is specified, is called. If the
BundleActivator
is invalid or throws an exception, the state of
the bundle is set back to Bundle.RESOLVED
, the bundle's listeners, if
any, are removed, service's registered by the bundle, if any, are
unregistered, and service's used by the bundle, if any, are released. A
BundleException
is then thrown.
Bundle.ACTIVE
.
BundleEvent
of type BundleEvent.STARTED
is
broadcast.
Bundle.INSTALLED
,Bundle.RESOLVED
}.
Bundle.ACTIVE
}.
BundleActivator.start
has been called
and did not throw an exception.
Bundle.STARTING
,Bundle.ACTIVE
}.
start
in interface Bundle
BundleException
- If the bundle couldn't be started. This could be because
a code dependency could not be resolved or the specified
BundleActivator could not be loaded or threw an
exception.IllegalStateException
- If the bundle has been uninstalled or the bundle tries to
change its own state.SecurityException
- If the caller does not have AdminPermission
permission and the Java runtime environment supports
permissions.Bundle.start(int)
public void start(int options) throws BundleException
Bundle
If this bundle's state is UNINSTALLED
then an
IllegalStateException
is thrown.
If the current start level is less than this bundle's start level:
Bundle.START_TRANSIENT
option is set, then a
BundleException
is thrown indicating this bundle cannot be
started due to the Framework's current start level.
Bundle.START_ACTIVATION_POLICY
option is set or
Started with eager activation if not set.
When the Framework's current start level becomes equal to or more than this bundle's start level, this bundle will be started.
Otherwise, the following steps are required to start this bundle:
BundleException
is thrown to indicate this bundle was unable to
be started.
ACTIVE
then this method returns
immediately.
Bundle.START_TRANSIENT
option is not set then set this
bundle's autostart setting to Started with declared activation
if the Bundle.START_ACTIVATION_POLICY
option is set or
Started with eager activation if not set. When the Framework is
restarted and this bundle's autostart setting is not Stopped,
this bundle must be automatically started.
RESOLVED
, an attempt is made to
resolve this bundle. If the Framework cannot resolve this bundle, a
BundleException
is thrown.
Bundle.START_ACTIVATION_POLICY
option is set and this
bundle's declared activation policy is lazy
then:
STARTING
then this method returns
immediately.
STARTING
.
BundleEvent.LAZY_ACTIVATION
is fired.
STARTING
.
BundleEvent.STARTING
is fired.
BundleActivator.start(BundleContext)
method of this
bundle's BundleActivator
, if one is specified, is called. If the
BundleActivator
is invalid or throws an exception then:
STOPPING
.
BundleEvent.STOPPING
is fired.
RESOLVED
.
BundleEvent.STOPPED
is fired.
BundleException
is then thrown.
UNINSTALLED
, because this bundle
was uninstalled while the BundleActivator.start
method was
running, a BundleException
is thrown.
ACTIVE
.
BundleEvent.STARTED
is fired.
getState()
in { INSTALLED
, RESOLVED
} or { INSTALLED
, RESOLVED
,
STARTING
} if this bundle has a lazy activation policy.
Bundle.START_TRANSIENT
option was set.
getState()
in { ACTIVE
} unless the
lazy activation policy was used.
BundleActivator.start()
has been called and did not throw an
exception unless the lazy activation policy was used.
Bundle.START_TRANSIENT
option was set.
getState()
not in { STARTING
, ACTIVE
}.
start
in interface Bundle
options
- The options for starting this bundle. See
Bundle.START_TRANSIENT
and Bundle.START_ACTIVATION_POLICY
. The
Framework must ignore unrecognized options.BundleException
- If this bundle could not be started.
BundleException types thrown by this method include:
BundleException.START_TRANSIENT_ERROR
,
BundleException.NATIVECODE_ERROR
,
BundleException.RESOLVE_ERROR
,
BundleException.STATECHANGE_ERROR
, and
BundleException.ACTIVATOR_ERROR
.protected abstract void startWorker(int options) throws BundleException
options
- BundleException
protected boolean readyToResume()
protected void resume() throws BundleException
The following steps are followed to start a bundle:
Bundle.UNINSTALLED
then an IllegalStateException
is thrown.
Bundle.ACTIVE
or Bundle.STARTING
then this
method returns immediately.
Bundle.STOPPING
then this method may wait for
the bundle to return to the Bundle.RESOLVED
state before continuing.
If this does not occur in a reasonable time, a BundleException
is thrown to indicate the bundle was unable to be started.
Bundle.RESOLVED
, an attempt is made to
resolve the bundle. If the bundle cannot be resolved, a
BundleException
is thrown.
Bundle.STARTING
.
start
method of the bundle's
BundleActivator
, if one is specified, is called. If the
BundleActivator
is invalid or throws an exception, the state of
the bundle is set back to Bundle.RESOLVED
, the bundle's listeners, if
any, are removed, service's registered by the bundle, if any, are
unregistered, and service's used by the bundle, if any, are released. A
BundleException
is then thrown.
Bundle.ACTIVE
.
BundleEvent
of type BundleEvent.STARTED
is
broadcast.
Bundle.INSTALLED
,Bundle.RESOLVED
}.
Bundle.ACTIVE
}.
BundleActivator.start
has been called
and did not throw an exception.
Bundle.STARTING
,Bundle.ACTIVE
}.
BundleException
- If the bundle couldn't be started. This could be because
a code dependency could not be resolved or the specified
BundleActivator could not be loaded or threw an
exception.IllegalStateException
- If the bundle tries to change its own state.public void stop() throws BundleException
The following steps are followed to stop a bundle:
Bundle.UNINSTALLED
then an IllegalStateException
is thrown.
Bundle.STOPPING
,Bundle.RESOLVED
, or
Bundle.INSTALLED
then this method returns immediately.
Bundle.STARTING
then this method may wait for
the bundle to reach the Bundle.ACTIVE
state before continuing. If this
does not occur in a reasonable time, a BundleException
is thrown
to indicate the bundle was unable to be stopped.
Bundle.STOPPING
.
stop
method of the bundle's
BundleActivator
, if one is specified, is called. If the
BundleActivator
throws an exception, this method will continue
to stop the bundle. A BundleException
will be thrown after
completion of the remaining steps.
Bundle.RESOLVED
.
BundleEvent
of type BundleEvent.STOPPED
is
broadcast.
Bundle.ACTIVE
}.
Bundle.ACTIVE
,Bundle.STOPPING
}.
BundleActivator.stop
has been called
and did not throw an exception.
stop
in interface Bundle
BundleException
- If the bundle's BundleActivator could not be loaded or
threw an exception.IllegalStateException
- If the bundle has been uninstalled or the bundle tries to
change its own state.SecurityException
- If the caller does not have AdminPermission
permission and the Java runtime environment supports
permissions.Bundle.start(int)
public void stop(int options) throws BundleException
Bundle
The following steps are required to stop a bundle:
UNINSTALLED
then an
IllegalStateException
is thrown.
BundleException
is thrown to indicate this bundle was unable to
be stopped.
Bundle.STOP_TRANSIENT
option is not set then then set this
bundle's persistent autostart setting to to Stopped. When the
Framework is restarted and this bundle's autostart setting is
Stopped, this bundle must not be automatically started.
STARTING
or ACTIVE
then
this method returns immediately.
STOPPING
.
BundleEvent.STOPPING
is fired.
ACTIVE
prior to setting the state
to STOPPING
, the BundleActivator.stop(BundleContext)
method of this bundle's BundleActivator
, if one is specified, is
called. If that method throws an exception, this method must continue to
stop this bundle and a BundleException
must be thrown after
completion of the remaining steps.
UNINSTALLED
, because this bundle
was uninstalled while the BundleActivator.stop
method was
running, a BundleException
must be thrown.
RESOLVED
.
BundleEvent.STOPPED
is fired.
getState()
in { ACTIVE
}.
Bundle.STOP_TRANSIENT
option was set.
getState()
not in { ACTIVE
, STOPPING
}.
BundleActivator.stop
has been called and did not throw an
exception.
Bundle.STOP_TRANSIENT
option was set.
stop
in interface Bundle
options
- The options for stopping this bundle. See
Bundle.STOP_TRANSIENT
. The Framework must ignore unrecognized
options.BundleException
- BundleException types thrown by this method
include: BundleException.STATECHANGE_ERROR
and
BundleException.ACTIVATOR_ERROR
.protected abstract void stopWorker(int options) throws BundleException
options
- BundleException
protected void setStatus(int mask, boolean state)
mask
- Mask for bit to set/clearstate
- true to set bit, false to clear bitprotected void suspend(boolean lock) throws BundleException
The following steps are followed to stop a bundle:
Bundle.UNINSTALLED
then an IllegalStateException
is thrown.
Bundle.STOPPING
,Bundle.RESOLVED
, or
Bundle.INSTALLED
then this method returns immediately.
Bundle.STARTING
then this method may wait for
the bundle to reach the Bundle.ACTIVE
state before continuing. If this
does not occur in a reasonable time, a BundleException
is thrown
to indicate the bundle was unable to be stopped.
Bundle.STOPPING
.
stop
method of the bundle's
BundleActivator
, if one is specified, is called. If the
BundleActivator
throws an exception, this method will continue
to stop the bundle. A BundleException
will be thrown after
completion of the remaining steps.
Bundle.RESOLVED
.
BundleEvent
of type BundleEvent.STOPPED
is
broadcast.
Bundle.ACTIVE
}.
Bundle.ACTIVE
,Bundle.STOPPING
}.
BundleActivator.stop
has been called
and did not throw an exception.
lock
- true if state change lock should be held when returning from
this method.BundleException
- If the bundle's BundleActivator could not be loaded or
threw an exception.IllegalStateException
- If the bundle tries to change its own state.public void update() throws BundleException
Bundle
This method performs the same function as calling
Bundle.update(InputStream)
with a null
InputStream.
update
in interface Bundle
BundleException
- If this bundle could not be updated.
BundleException types thrown by this method include:
BundleException.READ_ERROR
,
BundleException.DUPLICATE_BUNDLE_ERROR
,
BundleException.MANIFEST_ERROR
,
BundleException.NATIVECODE_ERROR
,
BundleException.RESOLVE_ERROR
,
BundleException.STATECHANGE_ERROR
, and
BundleException.ACTIVATOR_ERROR
.Bundle.update(InputStream)
public void update(InputStream in) throws BundleException
Bundle
InputStream
.
If the specified InputStream
is null
, the Framework must
create the InputStream
from which to read the updated bundle by
interpreting, in an implementation dependent manner, this bundle's
Bundle-UpdateLocation
Manifest
header, if present, or this bundle's original location.
If this bundle's state is ACTIVE
, it must be stopped before the
update and started after the update successfully completes.
If this bundle has exported any packages that are imported by another
bundle, these packages must remain exported until the
FrameworkWiring.refreshBundles
method has been has been called or the
Framework is relaunched.
The following steps are required to update a bundle:
UNINSTALLED
then an
IllegalStateException
is thrown.
ACTIVE
, STARTING
or
STOPPING
, this bundle is stopped as described in the
Bundle.stop
method. If Bundle.stop
throws an exception,
the exception is rethrown terminating the update.
BundleException
must be thrown after completion of the remaining
steps.
INSTALLED
.
BundleEvent.UPDATED
is fired.
ACTIVE
, the updated
bundle is started as described in the Bundle.start
method. If
Bundle.start
throws an exception, a Framework event of type
FrameworkEvent.ERROR
is fired containing the exception.
getState()
not in { UNINSTALLED
}.
getState()
in { INSTALLED
, RESOLVED
,
ACTIVE
}.
getState()
in { INSTALLED
, RESOLVED
,
ACTIVE
}.
update
in interface Bundle
in
- The InputStream
from which to read the new bundle or
null
to indicate the Framework must create the input
stream from this bundle's Bundle-UpdateLocation
Manifest header, if present, or this
bundle's original location. The input stream must always be closed
when this method completes, even if an exception is thrown.BundleException
- If this bundle could not be updated.
BundleException types thrown by this method include:
BundleException.READ_ERROR
,
BundleException.DUPLICATE_BUNDLE_ERROR
,
BundleException.MANIFEST_ERROR
,
BundleException.NATIVECODE_ERROR
,
BundleException.RESOLVE_ERROR
,
BundleException.STATECHANGE_ERROR
, and
BundleException.ACTIVATOR_ERROR
.Bundle.stop()
,
Bundle.start()
protected void updateWorker(PrivilegedExceptionAction<Object> action) throws BundleException
BundleException
protected void updateWorkerPrivileged(URLConnection source, AccessControlContext callerContext) throws BundleException
BundleException
public void uninstall() throws BundleException
This method removes all traces of the bundle, including any data in the persistent storage area provided for the bundle by the framework.
The following steps are followed to uninstall a bundle:
Bundle.UNINSTALLED
then an IllegalStateException
is thrown.
Bundle.ACTIVE
or Bundle.STARTING
, the bundle
is stopped as described in the stop()
method. If stop()
throws an exception, a FrameworkEvent
of type
FrameworkEvent.ERROR
is broadcast containing the exception.
BundleEvent
of type BundleEvent.UNINSTALLED
is
broadcast.
Bundle.UNINSTALLED
.
Bundle.UNINSTALLED
}.
Bundle.UNINSTALLED
}.
Bundle.UNINSTALLED
}.
uninstall
in interface Bundle
BundleException
- If the uninstall failed.IllegalStateException
- If the bundle has been uninstalled or the bundle tries to
change its own state.SecurityException
- If the caller does not have AdminPermission
permission and the Java runtime environment supports
permissions.stop()
protected void uninstallWorker(PrivilegedExceptionAction<Object> action) throws BundleException
BundleException
protected void uninstallWorkerPrivileged() throws BundleException
BundleException
public Dictionary<String,String> getHeaders()
Manifest header names are case-insensitive. The methods of the returned
Dictionary
object will operate on header names in a
case-insensitive manner.
For example, the following manifest headers and values are included if they are present in the manifest:
Bundle-Name Bundle-Vendor Bundle-Version Bundle-Description Bundle-DocURL Bundle-ContactAddress
This method will continue to return this information when the bundle is
in the Bundle.UNINSTALLED
state.
getHeaders
in interface Bundle
Dictionary
object containing the bundle's
manifest headers and values.SecurityException
- If the caller does not have AdminPermission
permission and the Java runtime environment supports
permissions.Constants.BUNDLE_LOCALIZATION
public Dictionary<String,String> getHeaders(String localeString)
Manifest header names are case-insensitive. The methods of the returned Dictionary object will operate on header names in a case-insensitive manner. If a Manifest header begins with a '%', it will be evaluated with the specified properties file for the specied Locale.
For example, the following Manifest headers and values are included if they are present in the Manifest file:
Bundle-Name Bundle-Vendor Bundle-Version Bundle-Description Bundle-DocURL Bundle-ContactAddress
This method will continue to return Manifest header information while this bundle is in the UNINSTALLED state.
getHeaders
in interface Bundle
localeString
- The locale name into which the header values are to be
localized. If the specified locale is null
then the locale
returned by java.util.Locale.getDefault
is used. If the
specified locale is the empty string, this method will return the
raw (unlocalized) manifest headers including any leading
"%".SecurityException
- If the caller does not have the AdminPermission,
and the Java Runtime Environment supports permissions.Bundle.getHeaders()
,
Constants.BUNDLE_LOCALIZATION
public long getBundleId()
The unique identifier has the following attributes:
This method will continue to return the bundle's unique identifier when
the bundle is in the Bundle.UNINSTALLED
state.
getBundleId
in interface Bundle
public String getLocation()
BundleContext.installBundle
when the
bundle was installed. The location identifier of the bundle may change
during bundle update. Calling this method while framework is updating
the bundle results in undefined behavior.
This method will continue to return the bundle's location identifier
when the bundle is in the Bundle.UNINSTALLED
state.
getLocation
in interface Bundle
SecurityException
- If the caller does not have AdminPermission
permission and the Java runtime environment supports
permissions.public boolean hasPermission(Object permission)
If the Java runtime environment does not supports permissions this
method always returns true
. The permission parameter is
of type Object
to avoid referencing the java.security.Permission
class directly. This is to allow the framework to be implemented in Java
environments which do not support permissions.
hasPermission
in interface Bundle
permission
- The requested permission.true
if the bundle has the requested permission
or false
if the bundle does not have the
permission or the permission parameter is not an instanceof java.security.Permission
.IllegalStateException
- If the bundle has been uninstalled.protected void beginStateChange() throws BundleException
BundleException
- if the bundles state is still changing after waiting for
the timeout.protected void completeStateChange()
public String toString()
public int compareTo(Bundle obj)
compareTo
in interface Comparable<Bundle>
obj
- another Bundle an object to compare the receiver toClassCastException
- if the argument can not be converted into something
comparable with the receiver.protected void checkValid()
IllegalStateException
- If the bundle is uninstalled.public BundleProtectionDomain getProtectionDomain()
protected BundleFragment[] getFragments()
protected boolean isFragment()
public Class<?> loadClass(String classname) throws ClassNotFoundException
Bundle
If this bundle is a fragment bundle then this method must throw a
ClassNotFoundException
.
If this bundle's state is INSTALLED
, this method must attempt to
resolve this bundle before attempting to load the class.
If this bundle cannot be resolved, a Framework event of type
FrameworkEvent.ERROR
is fired containing a
BundleException
with details of the reason this bundle could not
be resolved. This method must then throw a ClassNotFoundException
.
If this bundle's state is UNINSTALLED
, then an
IllegalStateException
is thrown.
loadClass
in interface Bundle
classname
- The name of the class to load.ClassNotFoundException
- If no such class can be found or if this
bundle is a fragment bundle or if the caller does not have the
appropriate AdminPermission[this,CLASS]
, and the Java
Runtime Environment supports permissions.public Enumeration<String> getEntryPaths(String path)
Bundle
String
objects) to
entries within this bundle whose longest sub-path matches the specified
path. This bundle's class loader is not used to search for entries. Only
the contents of this bundle are searched.
The specified path is always relative to the root of this bundle and may begin with a "/". A path value of "/" indicates the root of this bundle.
Returned paths indicating subdirectory paths end with a "/". The returned paths are all relative to the root of this bundle and must not begin with "/".
Note: Jar and zip files are not required to include directory entries. Paths to directory entries will not be returned if the bundle contents do not contain directory entries.
getEntryPaths
in interface Bundle
path
- The path name for which to return entry paths.String
objects) or
null
if no entry could be found or if the caller does not
have the appropriate AdminPermission[this,RESOURCE]
and
the Java Runtime Environment supports permissions.public URL getEntry(String fileName)
Bundle
The specified path is always relative to the root of this bundle and may begin with "/". A path value of "/" indicates the root of this bundle.
Note: Jar and zip files are not required to include directory entries. URLs to directory entries will not be returned if the bundle contents do not contain directory entries.
public String getSymbolicName()
Bundle
Bundle-SymbolicName
manifest header. The bundle symbolic name
should be based on the reverse domain name naming convention like that
used for java packages.
This method must continue to return this bundle's symbolic name while
this bundle is in the UNINSTALLED
state.
getSymbolicName
in interface Bundle
null
if this bundle
does not have a symbolic name.public long getLastModified()
Bundle
The time value is the number of milliseconds since January 1, 1970, 00:00:00 UTC.
getLastModified
in interface Bundle
public BundleData getBundleData()
public Version getVersion()
Bundle
Bundle-Version
manifest header. If this bundle does not have a
specified version then Version.emptyVersion
is returned.
This method must continue to return this bundle's version while this
bundle is in the UNINSTALLED
state.
getVersion
in interface Bundle
public BundleDescription getBundleDescription()
protected abstract BundleLoader getBundleLoader()
protected void resolve()
public BundleContext getBundleContext()
Bundle
BundleContext
. The returned
BundleContext
can be used by the caller to act on behalf of this
bundle.
If this bundle is not in the Bundle.STARTING
, Bundle.ACTIVE
, or
Bundle.STOPPING
states or this bundle is a fragment bundle, then this
bundle has no valid BundleContext
. This method will return
null
if this bundle has no valid BundleContext
.
getBundleContext
in interface Bundle
BundleContext
for this bundle or null
if this
bundle has no valid BundleContext
.protected abstract BundleContextImpl getContext()
public BundleException getResolutionFailureException()
public int getKeyHashCode()
KeyedElement
getKeyHashCode
in interface KeyedElement
public boolean compare(KeyedElement other)
KeyedElement
compare
in interface KeyedElement
other
- the element to compare withpublic Object getKey()
KeyedElement
getKey
in interface KeyedElement
public ResourceBundle getResourceBundle(String localeString)
public boolean testStateChanging(Object thread)
public Thread getStateChanging()
public Enumeration<URL> findEntries(String path, String filePattern, boolean recurse)
Bundle
INSTALLED
, this method must attempt to
resolve this bundle before attempting to find entries.
This method is intended to be used to obtain configuration, setup, localization and other information from this bundle. This method takes into account that the "contents" of this bundle can be extended with fragments. This "bundle space" is not a namespace with unique members; the same entry name can be present multiple times. This method therefore returns an enumeration of URL objects. These URLs can come from different JARs but have the same path name. This method can either return only entries in the specified path or recurse into subdirectories returning entries in the directory tree beginning at the specified path. Fragments can be attached after this bundle is resolved, possibly changing the set of URLs returned by this method. If this bundle is not resolved, only the entries in the JAR file of this bundle are returned.
Examples:
// List all XML files in the OSGI-INF directory and below Enumeration e = b.findEntries("OSGI-INF", "*.xml", true); // Find a specific localization file Enumeration e = b.findEntries("OSGI-INF/l10n", "bundle_nl_DU.properties", false); if (e.hasMoreElements()) return (URL) e.nextElement();
URLs for directory entries must have their path end with "/".
Note: Jar and zip files are not required to include directory entries. URLs to directory entries will not be returned if the bundle contents do not contain directory entries.
findEntries
in interface Bundle
path
- The path name in which to look. The path is always relative
to the root of this bundle and may begin with "/". A
path value of "/" indicates the root of this bundle.filePattern
- The file name pattern for selecting entries in the
specified path. The pattern is only matched against the last
element of the entry path. If the entry is a directory then the
trailing "/" is not used for pattern matching. Substring
matching is supported, as specified in the Filter specification,
using the wildcard character ("*"). If null is
specified, this is equivalent to "*" and matches all
files.recurse
- If true
, recurse into subdirectories. Otherwise
only return entries from the specified path.null
if no matching entry could be found or if the caller
does not have the appropriate
AdminPermission[this,RESOURCE]
, and the Java Runtime
Environment supports permissions. The URLs are sorted such that
entries from this bundle are returned first followed by the
entries from attached fragments in attachment order. If this
bundle is a fragment, then only matching entries in this fragment
are returned.public Map<X509Certificate,List<X509Certificate>> getSignerCertificates(int signersType)
Bundle
getSignerCertificates
in interface Bundle
signersType
- If Bundle.SIGNERS_ALL
is specified, then information
on all signers of this bundle is returned. If
Bundle.SIGNERS_TRUSTED
is specified, then only information on
the signers of this bundle trusted by the framework is returned.X509Certificate
s for the signers of this bundle and
the X509Certificate
chains for those signers. The keys of
the Map
are the X509Certificate
s of the signers
of this bundle. The value for a key is a List
containing
the X509Certificate
chain for the signer. The first item
in the List
is the signer's X509Certificate
which
is then followed by the rest of the X509Certificate
chain. The returned Map
will be empty if there are no
signers. The returned Map
is the property of the caller
who is free to modify it.public final <A> A adapt(Class<A> adapterType)
Bundle
Adapting this bundle to the specified type may require certain checks,
including security checks, to succeed. If a check does not succeed, then
this bundle cannot be adapted and null
is returned.
adapt
in interface Bundle
A
- The type to which this bundle is to be adapted.adapterType
- Class object for the type to which this bundle is to be
adapted.null
if this bundle cannot be adapted to the
specified type.public List<BundleRevision> getRevisions()
BundleRevisions
referenced
bundle.
The result is a list containing the current bundle revision, if there is one, and all in use bundle revisions. The list may also contain intermediate bundle revisions which are not in use.
The list is ordered in reverse chronological order such that the first item is the most recent bundle revision and last item is the oldest bundle revision.
Generally the list will have at least one bundle revision for the bundle: the current bundle revision. However, for an uninstalled bundle with no in use bundle revisions, the list may be empty.
getRevisions
in interface BundleRevisions
BundleRevision
s for
the referenced bundle.protected <A> A adapt0(Class<A> adapterType)
public File getDataFile(String filename)
Bundle
File
object for a file in the persistent storage area
provided for this bundle by the Framework. This method will return
null
if the platform does not have file system support or this
bundle is a fragment bundle.
A File
object for the base directory of the persistent storage
area provided for this bundle by the Framework can be obtained by calling
this method with an empty string as filename
.
If the Java Runtime Environment supports permissions, the Framework will
ensure that this bundle has the java.io.FilePermission
with
actions read
,write
,delete
for all files
(recursively) in the persistent storage area provided for this bundle.
getDataFile
in interface Bundle
filename
- A relative name to the file to be accessed.File
object that represents the requested file or
null
if the platform does not have file system support or
this bundle is a fragment bundle.public Bundle getBundle()
BundleReference
Bundle
object associated with this
BundleReference
.getBundle
in interface BundleReference
Bundle
object associated with this
BundleReference
.public int getStartLevel()
BundleStartLevel
getStartLevel
in interface BundleStartLevel
BundleStartLevel.setStartLevel(int)
public void setStartLevel(int startlevel)
BundleStartLevel
The bundle will be assigned the specified start level. The start level value assigned to the bundle will be persistently recorded by the Framework.
If the new start level for the bundle is lower than or equal to the
active start level of the Framework and the bundle's autostart setting
indicates this bundle must be started, the Framework will start the
bundle as described in the Bundle.start(int)
method using the
Bundle.START_TRANSIENT
option. The
Bundle.START_ACTIVATION_POLICY
option must also be used if
BundleStartLevel.isActivationPolicyUsed()
returns true
. The actual
starting of the bundle must occur asynchronously.
If the new start level for the bundle is higher than the active start
level of the Framework, the Framework will stop the bundle as described
in the Bundle.stop(int)
method using the
Bundle.STOP_TRANSIENT
option. The actual stopping of the bundle
must occur asynchronously.
setStartLevel
in interface BundleStartLevel
startlevel
- The new start level for the bundle.public boolean isPersistentlyStarted()
BundleStartLevel
The autostart setting of a bundle indicates whether the bundle is to be started when its start level is reached.
isPersistentlyStarted
in interface BundleStartLevel
true
if the autostart setting of the bundle indicates it
is to be started. false
otherwise.Bundle.START_TRANSIENT
public boolean isActivationPolicyUsed()
BundleStartLevel
The autostart setting of a bundle indicates whether the bundle's declared activation policy is to be used when the bundle is started.
isActivationPolicyUsed
in interface BundleStartLevel
true
if the bundle's autostart setting indicates the
activation policy declared in the manifest must be used.
false
if the bundle must be eagerly activated.Bundle.START_ACTIVATION_POLICY
Copyright © 2007–2018 The Apache Software Foundation. All rights reserved.