Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) OSGi Alliance (2004, 2013). All Rights Reserved.
   * 
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.osgi.service.application;
 
ApplicationHandle is an OSGi service interface which represents an instance of an application. It provides the functionality to query and manipulate the lifecycle state of the represented application instance. It defines constants for the lifecycle states.

Author(s):
$Id: 4a9c1d6258e03ce4eb1a26748bccf83661ad8244 $
 
 public abstract class ApplicationHandle {
 	/*
 	 * NOTE: An implementor may also choose to replace this class in their
 	 * distribution with a class that directly interfaces with the
 	 * org.osgi.service.application implementation. This replacement class MUST
 	 * NOT alter the public/protected signature of this class.
 	 */

The property key for the unique identifier (PID) of the application instance.
 
 	public static final String			APPLICATION_PID.;

The property key for the pid of the corresponding application descriptor.
 
 	public final static String			APPLICATION_DESCRIPTOR"application.descriptor";

The property key for the state of this application instance.
 
 	public final static String			APPLICATION_STATE"application.state";

The property key for the supports exit value property of this application instance.

Since:
1.1
 
 	public final static String			APPLICATION_SUPPORTS_EXITVALUE"application.supports.exitvalue";

The application instance is running. This is the initial state of a newly created application instance.
 
 	public final static String			RUNNING"RUNNING";

The application instance is being stopped. This is the state of the application instance during the execution of the destroy() method.
 
 	public final static String			STOPPING"STOPPING";
 
 	private final String				instanceId;
 
 	private final ApplicationDescriptor	descriptor;

Application instance identifier is specified by the container when the instance is created. The instance identifier must remain static for the lifetime of the instance, it must remain the same even across framework restarts for the same application instance. This value must be the same as the service.pid service property of this application handle.

The instance identifier should follow the following scheme: <application descriptor PID>.<index> where <application descriptor PID> is the PID of the corresponding ApplicationDescriptor and <index> is a unique integer index assigned by the application container. Even after destroying the application index the same index value should not be reused in a reasonably long timeframe.

Parameters:
instanceId the instance identifier of the represented application instance. It must not be null.
descriptor the ApplicationDescriptor of the represented application instance. It must not be null.
Throws:
java.lang.NullPointerException if any of the arguments is null.
	protected ApplicationHandle(String instanceIdApplicationDescriptor descriptor) {
		if ((null == instanceId) || (null == descriptor)) {
			throw new NullPointerException("Parameters must not be null!");
		}
		this. = instanceId;
		this. = descriptor;
		try {
			 = new Delegate();
			.setApplicationHandle(thisdescriptor.delegate);
catch (Exception e) {
			// Too bad ...
			..println("No implementation available for ApplicationDescriptor, property is: " + .);
		}
	}

Retrieves the ApplicationDescriptor to which this ApplicationHandle belongs.

Returns:
The corresponding ApplicationDescriptor
		return ;
	}

Get the state of the application instance.

Returns:
the state of the application.
Throws:
java.lang.IllegalStateException if the application handle is unregistered
	public abstract String getState();

Returns the exit value for the application instance. The timeout specifies how the method behaves when the application has not yet terminated. A negative, zero or positive value may be used.
  • negative - The method does not wait for termination. If the application has not terminated then an ApplicationException is thrown.
  • zero - The method waits until the application terminates.
  • positive - The method waits until the application terminates or the timeout expires. If the timeout expires and the application has not terminated then an ApplicationException is thrown.

The default implementation throws an UnsupportedOperationException. The application model should override this method if exit values are supported.

Parameters:
timeout The maximum time in milliseconds to wait for the application to timeout.
Returns:
The exit value for the application instance. The value is application specific.
Throws:
java.lang.UnsupportedOperationException If the application model does not support exit values.
java.lang.InterruptedException If the thread is interrupted while waiting for the timeout.
ApplicationException If the application has not terminated. The error code will be ApplicationException.APPLICATION_EXITVALUE_NOT_AVAILABLE.
Since:
1.1
	public Object getExitValue(long timeoutthrows ApplicationExceptionInterruptedException {
	}

Returns the unique identifier of this instance. This value is also available as a service property of this application handle's service.pid.

Returns:
the unique identifier of the instance
	public final String getInstanceId() {
		return ;
	}

The application instance's lifecycle state can be influenced by this method. It lets the application instance perform operations to stop the application safely, e.g. saving its state to a permanent storage.

The method must check if the lifecycle transition is valid; a STOPPING application cannot be stopped. If it is invalid then the method must exit. Otherwise the lifecycle state of the application instance must be set to STOPPING. Then the destroySpecific() method must be called to perform any application model specific steps for safe stopping of the represented application instance.

At the end the ApplicationHandle must be unregistered. This method should free all the resources related to this ApplicationHandle.

When this method is completed the application instance has already made its operations for safe stopping, the ApplicationHandle has been unregistered and its related resources has been freed. Further calls on this application should not be made because they may have unexpected results.

Throws:
java.lang.SecurityException if the caller doesn't have "lifecycle" ApplicationAdminPermission for the corresponding application.
java.lang.IllegalStateException if the application handle is unregistered
	public final void destroy() {
		try {
catch (SecurityException se) {
												 * check whether the bundle was
												 * uninstalled
												 */
			/* if yes, throws IllegalStateException */
			throw se/* otherwise throw the caught SecurityException */
		}
	}

Called by the destroy() method to perform application model specific steps to stop and destroy an application instance safely.

Throws:
java.lang.IllegalStateException if the application handle is unregistered
	protected abstract void destroySpecific();
This class will load the class named by the org.osgi.vendor.application.ApplicationHandle and delegate method calls to an instance of the class.
	static class Delegate {
		static String	cName;
		static Method	destroy;
		static {
			AccessController.doPrivileged(new PrivilegedAction() {
				public Object run() {
					 = System.getProperty("org.osgi.vendor.application.ApplicationHandle");
					if ( == null) {
						throw new NoClassDefFoundError("org.osgi.vendor.application.ApplicationHandle property must be set");
					}
					try {
catch (ClassNotFoundException e) {
					}
					try {
						 = .getMethod("setApplicationHandle"new Class[] {ApplicationHandle.classObject.class});
						 = .getMethod("destroy"new Class[] {});
catch (NoSuchMethodException e) {
						throw new NoSuchMethodError(e.toString());
					}
					return null;
				}
			});
		}
		Delegate() throws Exception {
			 = AccessController.doPrivileged(new PrivilegedExceptionAction() {
				public Object run() throws Exception {
				}
			});
		}
			try {
				try {
					.invoke(new Object[] {ddescriptor.target});
catch (InvocationTargetException e) {
				}
catch (Error e) {
				throw e;
catch (RuntimeException e) {
				throw e;
catch (Throwable e) {
				throw new RuntimeException(e);
			}
		}
		void destroy() {
			try {
				try {
					.invoke(new Object[] {});
catch (InvocationTargetException e) {
				}
catch (Error e) {
				throw e;
catch (RuntimeException e) {
				throw e;
catch (Throwable e) {
				throw new RuntimeException(e);
			}
		}
	}
New to GrepCode? Check out our FAQ X