Java Web Start Guide
This document was uploaded by user and they confirmed that they have the permission to share it. If you are author or own the copyright of this book, please report to us by using this DMCA report form. Report DMCA
Overview
Download & View Java Web Start Guide as PDF for free.
More details
- Words: 32,722
- Pages: 116
Java Web Start Guide Note: There are two ways to navigate this guide:
Related Documents
Search the guide Select from the contents below:
Overview Java Web Start Technology Where to Find Java Web Start Technology Using Java Web Start Software Requirements
Setting up the Web Site Introduction Basic Steps
Creating the Web Page That Launches the Application Introduction Detecting if Java Web Start is installed on Netscape Detecting if Java Web Start is installed on IE, and if so, the version number Launching the application if Java Web Start is Installed—or providing a link for auto-install or general download page Creating an auto-install page
Application Development Considerations Introduction Retrieving Resources from JAR files Security and Code Signing Signing JAR Files with a Test Certificate How to Encode JNLP Files Dynamic Download of HTTPS Certificates
JnlpDownloadServlet Guide Introduction Examples Servlet Configuration Specifying Resources Mapping Requests to Resources Processing of JNLP Files
JNLP File Syntax http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/contents.html
Introduction The jnlp Element The information Element The security Element The resources Element The application-desc Element The applet-desc Element
JNLP API Examples Introduction Using a BasicService Service Using a ClipboardService Service Using a DownloadService Service Using a FileOpenService Service Using a FileSaveService Service Using a PrintService Service Using a PersistenceService Service Using FileContents Using a JNLPRandomAccessFile Using a SingleInstanceService Service Using an ExtendedService Service
The javaws Command Line Interface Appendices: FAQ JNLP API (JavaDoc)
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/contents.html
Overview Select a Chapter/Topic
Java Web Start Technology Java Web Start is a helper application that gets associated with a Web browser. When a user clicks on a link that points to a special launch file (JNLP file), it causes the browser to launch Java Web Start, which then automatically downloads, caches, and runs the given Java Technology-based application. The entire process is typically completed without requiring any user interaction, except for the initial single click. From a technology standpoint, Java Web Start has a number of key benefits that make it an attractive platform to use for deploying applications:
Java Web Start is built exclusively to launch applications written to the Java(TM) Platform Standard Edition. Thus, a single application can be made available on a Web server and then deployed on a wide variety of platforms, including Windows 98/NT/2000/ME/XP, Linux, and the SolarisTM Operating Environment. The Java platform has proven to be a very robust, productive, and expressive development platform, leading to a significant cost savings due to minimized development and testing costs. Java Web Start supports multiple revisions of the Java(TM) Platform Standard Edition. Thus, an application can request a particular version of the platform it requires, such as Java SETM 1.5.0. Several applications can run at the same time on different platform revisions without causing conflicts, and Java Web Start can automatically download and install a revision of the platform if an application requests a version that is not installed on the client system. Java Web Start allows applications to be launched independently of a Web browser. This can be used for off-line operation of an application, where launching through the browser is often inconvenient or impossible. The application can also be launched through desktop shortcuts, making launching the Web-deployed application similar to launching a native application. Java Web Start takes advantage of the inherent security of the Java Platform. Applications are by default run in a protective environment (sandbox) with restricted access to local disk and network resources. It allows the user to safely run applications from sources that are not trusted. Applications launched with Java Web Start are cached locally. Thus, an already-downloaded application is launched on par with a traditionally installed application.
The technology underlying Java Web Start is the Java TM Network Launching Protocol & API (JNLP). This technology was developed via the Java Community Process (JCP). Java Web Start is the reference implementation (RI) for the JNLP specification. The JNLP technology defines, among other things, a standard file format that describes how to launch an application called a JNLP file.
Security Java Web Start is built on top of the Java(TM) SE platform, which provides a comprehensive security architecture. Applications launched with Java Web Start will, by default, run in a restricted environment ("sandbox") with limited access to files and network. Thus, launching applications using Java Web Start maintains system security and integrity. An application can request unrestricted access to your system. In this case, Java Web Start will display a Security Warning dialog when the application is launched for the first time. The security warning will show information about the vendor who developed the application. If you choose to trust the vendor, then the application will be launched. The information about the origin of the application is based on digital code signing. http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/overview.html
Where to find Java Web Start Java Web Start is included in the Java Runtime Environment available at http://java.sun.com. The JNLP specification can be found at JSR 56: Java Network Launching Protocol and API.
Using Java Web Start Software Java Web Start allows you to launch Java-technology-based applications directly from the Web. An application can be launched in three different ways:
From a Web browser by clicking on a link. From desktop icons or the Start Menu. From the Java Cache Viewer
Regardless of which way is used, Java Web Start will connect back to the Web server each time an application is launched to check whether an updated version of the application is available.
Launching from a Web browser Point your web browser to a page with a link to a jnlp application, and click on that link. Some applications require extra privileges, such as access to your local hard disk. For these applications, a security dialog will pop up with information about the origin of the application based on who digitally signed the code. The application will run only if you decide to trust the vendor. That is really all there is to using Java Web Start, but how does it work? The HTML links that launch the applications are, in fact, standard HTML links. However, instead of pointing to another Web page, they link to a special configuration file called a JNLP file. The Web browser examines the file extension and/or the MIME type of the file, and sees that it belongs to Java Web Start. It then launches Java Web Start with the downloaded JNLP file as an argument. Java Web Start proceeds with downloading, caching, and running the application as directed by the JNLP file.
Launching from desktop icons and the Start Menu (Microsoft Windows and Unix running GNOME 2.0+) Java Web Start technology can automatically create shortcuts for your application on the desktop and in the Start Menu for Web-deployed applications developed with Java technology. You can use the Java Control Panel to control the shortcut settings. Shortcuts can also be added by using the Java Web Start Cache Viewer, using the install shortcut menu item.
Using Java Web Start Software Behind a Proxy Server/Firewall Java Web Start software must be configured with the correct proxy settings in order to launch applications from outside your firewall. Java Web Start software will automatically try to detect the proxy settings from the default browser on your system (Internet Explorer or NetscapeTM browsers on Microsoft Windows, and Netscape browsers on the Solaris Operating Environment and Linux). Java Web Start technology supports most web proxy auto-configuration scripts. It can detect proxy settings in almost all environments. You can also use the Java Web Start Control Panel to view or edit the proxy configuration. Refer to the Java Control Panel for more details.
Requirements Desktop/Client requirements: The client machine requires support for the Java Runtime Environment (JRE), version 1.3 or later. Java Web Start is available for Windows 98/NT/2000/ME/XP, the Solaris Operating Environment, and Linux. http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/overview.html
Server requirements: Applications can be deployed from any standard Web server. In order to use Java Web Start, the Web server must be configured with support for a new MIME type. See Setting Up the Web Site.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/overview.html
Setting Up the Web Site Select a Chapter/Topic
Introduction Java Web Start leverages existing Internet technology, such as the HTTP protocol and Web servers, so existing infrastructure for deploying HTML-based contents can be reused to deploy Java Technology-based applications using Java Web Start. In order to deploy your application to client machines, you must make sure that all files containing your application are accessible through a Web server. This typically amounts to copying one or more JAR files, along with a JNLP file, into the Web server's directories. The set-up required for enabling the Web site to support Java Web Start is very similar to deploying HTML-based contents. The only caveat is that a new MIME type needs to be configured for the Web server.
Basic Steps 1. Configure the Web server to use the Java Web Start MIME type Configure the Web server so that all files with the .jnlp file extension are set to the application/x-java-jnlp-file MIME type. Most Web browsers use the MIME type returned with the contents from the Web server to determine how to handle the particular content. The server must return application/x-java-jnlp-file MIME type for JNLP files in order for Java Web Start to be invoked. Each Web server has a specific way in which to add MIME types. For example, for the Apache Web server you must add the following line to the .mime.types configuration file: application/x-java-jnlp-file JNLP
Check the documentation for the specifics of your Web server. 2. Create a JNLP file for the application The easiest way to create this file is to modify an existing JNLP file to your requirements. The syntax and format for the JNLP file is described in a later section. 3. Make the application accessible on the Web server Ensure your application's JAR files and the JNLP file are accessible at the URLs listed in the JNLP file. 4. Create the web page that launches the application See the next chapter, Creating the Web Page that launches the Application, for details on step 4.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/setup.html
Creating the Web Page That Launches the Application Select a Chapter/TopicTable of ContentsSearch PageOverviewSetting Up the Web SiteCreating the Web Page That Launches the ApplicationApplication Development ConsiderationsPackaging JNLP Applications in a Web ArchiveJNLP File SyntaxJNLP API Examplesjavaws Command LineFAQJNLP API (JavaDoc) This chapter includes the following topics:
Introduction Detecting if Java Web Start is installed on Netscape Detecting if Java Web Start is installed on IE, and if so, the version number Launching the application if Java Web Start is Installed—or providing a link for auto-install or general download page Creating an auto-install page
Introduction In order for an application to be launched from a web page via JNLP, the page must include a link to the JNLP file. E.g., to be able to launch application app.jnlp on a web site http://www.MySite.com, the page needs to include the following link: Launch the application
It may be the case, however, that Java Web Start is not installed on the user's computer. Thus the page needs to include logic (scripts) to take account of this. In fact, the page should include logic for the following: Detect if Java Web Start is installed
If so, launch the application. If not, detect if user is running IE on Window. If so, provide link to a page that can auto-install the JRE for Windows If not, provide a link to the general download page for the JDK/JRE.
The scripts, and the HTML for the auto-install page, are discussed below.
Detecting if Java Web Start is installed on Netscape Here is the first script that should be run on a web page for launching an application via JNLP: <SCRIPT LANGUAGE="JavaScript"> var javawsInstalled = 0; var javaws142Installed=0; var javaws150Installed=0; var javaws160Installed = 0; isIE = "false"; if (navigator.mimeTypes && navigator.mimeTypes.length) { x = navigator.mimeTypes['application/x-java-jnlp-file']; if (x) { javawsInstalled = 1; javaws142Installed=1; javaws150Installed=1; javaws160Installed = 1; } } else { isIE = "true"; }
This script looks at the navigator.mimeTypes object and the navigator.mimeTypes.length var to decide if the browser is Netscape or
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/launch.html
IE. If length is 0, it is assumed the browser is IE, as with IE the navigator.mimeTypes array is defined but always empty. If length is non-zero, then the browser is assumed to be Netscape and the JNLP MIME type is checked to see if it exists on Netscape. If so, javawsInstalled, javaws142Installed , javaws150Installed and javaws160Installed are all set to 1. With Netscape it is not possible to determine which particular version of Java Web Start is installed, so all four variables are set to 1.
Detecting if JavaWeb Start is installed on IE, and if so, the version The above JavaScript should be followed by a VBScript that sets variables related to Internet Explorer browers: <SCRIPT LANGUAGE="VBScript"> on error resume next If isIE = "true" Then If Not(IsObject(CreateObject("JavaWebStart.isInstalled"))) Then javawsInstalled = 0 Else javawsInstalled = 1 End If If Not(IsObject(CreateObject("JavaWebStart.isInstalled.1.4.2.0"))) Then javaws142Installed = 0 Else javaws142Installed = 1 End If If Not(IsObject(CreateObject("JavaWebStart.isInstalled.1.5.0.0"))) Then javaws150Installed = 0 Else javaws150Installed = 1 End If If Not(IsObject(CreateObject("JavaWebStart.isInstalled.1.6.0.0"))) Then javaws160Installed = 0 Else javaws160Installed = 1 End If End If
This VBScript is executed if the variable isIE from the preceeding JavaScript is "true"; i.e., if the end-user's browser is Internet Explorer. This script instantiates the isInstalled COM object in JavaWebStart.dll, and this object determines four things:
whether the client machine has any version of Java Web Start installed; whether the client machine has version 1.2 of Java Web Start installed; whether the client machine has versions 1.4.2 of Java Web Start installed; whether the client machine has versions 1.5.0 of Java Web Start installed. whether the client machine has versions 1.6.0 of Java Web Start installed.
After the above two scripts have been executed, the variables javawsInstalled, javaws142Installed, javawsInstalled150 and will be set to either 1 or 0, as follows:
javawsInstalled160
Browser javawsInstalled javaws142Installed javaws150Installed javaws160Installed 1 if any version of Internet 1 if Java Web Start 1.4.2 is Java Web Start is Explorer installed; 0 otherwise. installed; 0 otherwise.
1 if Java Web Start 1.5.0 is installed; 0 otherwise.
1 if Java Web Start 1.6.0 is installed; 0 otherwise.
1 if any version of Netscape 1 if any version of Java Web 1 if any version of Java Web 1 if any version of Java Web Java Web Start is Navigator Start is installed; 0 otherwise. Start is installed; 0 otherwise. Start is installed; 0 otherwise. installed; 0 otherwise.
Launching the application if Java Web Start is Installed—or providing a link for auto-install or general download page An additional JavaScript can be used to decide whether to:
provide a link to the application's jnlp file (i.e., Java Web Start is installed); initiate auto-download of JRE 6.0, which includes Java Web Start (i.e., Java Web Start is not installed and the user is running IE on Windows);
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/launch.html
or provide a link to the general download page for the 6.0 JDK/JRE (i.e., Java Web Start is not installed and the user is not running IE on Windows).
The following JavaScript handles these scenarios: <script language="JavaScript"> /* Note that the logic below always launches the JNLP application *if the browser is Gecko based. This is because it is not possible *to detect MIME type application/x-java-jnlp-file on Gecko-based browsers. */ if (javawsInstalled || (navigator.userAgent.indexOf("Gecko") !=-1)) { document.write("Launch the application"); } else { document.write("Click "); document.write("here "); document.write("to download and install JRE 5.0 and the application."); }
Notes: 1. The script only uses javawsInstalled—not javaws142Installed or javaws150Installed or javaws160Installed . 2. The line breaks following '?' and '&' are for readability purposes only; in an actual script there should be no breaks in the href string.
If javawsInstalled is 1, indicating that Java Web Start is already available on the client, then the script provides a link to the application's jnlp file. If Java Web Start is not installed on the client, the script instead provides a link to the PluginBrowserCheck program on the java.sun.com web site. PluginBrowserCheck checks whether the client uses Internet Explorer on a Microsoft Windows platform. If so, PluginBrowserCheck sends the user to the auto-install page http://www.MySite.com/download.html . (See the next section, Creating an auto-install page, for how to create an auto-install page for IE running on Windows.) If PluginBrowserCheck determines the user is not using Internet Explorer on Microsoft Windows, the user is redirected to the 6.0 JRE general download page on java.sun.com.
Creating an auto-install page
Note: The.cab file in the codebase attribute below will not be available until the GA release of the 6.0 JDK/JRE. For a complete list of JRE releases that can be autodownloaded via a .cab file, as mentioned below, see Autodownload Files (Windows Only). The download.html file should be staged on the server side. It contains special OBJECT and PARAM tags that will download to the client an auto-installer for JRE 6.0 . Along with Java Web Start, an ActiveX control will be downloaded to the client. The ActiveX control will launch the application using the newly installed Java Web Start. Here is a sample download.html file:
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/launch.html
The OBJECT tag fetches a .cab file that contains an auto-installer for JRE 6.0. The URL: http://java.sun.com/update/1.6.0/jinstall-6-windows-i586.cab will return the latest update release available for the Java SE 6 release. The string: Version=6,0,0,0 will be used to compare with the wsdetect.dll version, which is registered with the CLSID above. If the local machine has the dll installed and the version is greater than or equal to the Version specified, we will just load the dll in the local machine. Otherwise it will download and install Java from the codebase specified. The PARAM tags specify the location of the application's jnlp file so that it may be automatically launched after the JRE is installed on the client. app:
Once the Java Web Start Active-X control is installed/loaded, it will invoke Java Web Start to launch the application specified by this URL.
back:
This controls the behavior of the browser after launching the application. It can remain on the current page (download.html in this case) or navigate back to the previous page. For issues relating to application development see the next chapter, Application Development Considerations.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/launch.html
Application Development Considerations Select a Chapter/Topic
This chapter includes the following topics:
Introduction Retrieving Resources from JAR files Security and Code Signing Signing JAR Files With a Test Certificate How to Encode JNLP Files Dynamic Download of HTTPS Certificates
Introduction
Developing applications for deployment with Java Web Start is generally the same as developing stand-alone applications for the Java(TM) Platform Standard Edition. For instance, the entry point for the application is the standard public static void main(String[] argv). However, in order to support Web deployment—automatic download and launching of an application—and to ensure that an application can run in a secure sandbox, there are some additional considerations:
An application must be delivered as a set of JAR files. All application resources, such as files and images must be stored in JAR files; and they must be referenced using the getResource mechanism in the Java(TM) Platform Standard Edition (see below). If an application is written to run in a secure sandbox, it must follow these restrictions: No access to local disk. All JAR files must be downloaded from the same host. Network connections are enabled only to the host from which the JAR files are downloaded. No security manager can be installed. No native libraries may be used. Limited access to system properties. The application has read/write access to all system properties defined in the JNLP File, as well as read-only access to the same set of properties that an Applet has access to. An application is allowed to use the System.exit call. An application that needs unrestricted access to the system will need to be delivered in a set of signed JAR files. All entries in each JAR file must be signed.
Retrieving Resources from JAR files Java Web Start only transfers JAR files from the Web server to the client machine. It determines where to store the JAR files on the local machine. Thus, an application cannot use disk-relative references to resources such as images and configuration files.
All application resources must be retrieved from the JAR files specified in the resources section of the JNLP file, or retrieved explicitly using an HTTP request to the Web server. Storing resources in JAR files is recommended, since they will be cached on the local machine by Java Web Start. The following code example shows how to retrieve images from a JAR file: // Get current classloader
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/development.html
ClassLoader cl = this.getClass().getClassLoader(); // Create icons Icon saveIcon = new ImageIcon(cl.getResource("images/save.gif")); Icon cutIcon = new ImageIcon(cl.getResource("images/cut.gif")); ...
The example assumes that the following entries exist in one of the JAR files for the application: images/save.gif images/cut.gif
Security and Code Signing Java Web Start addresses the security issues:
Protecting users against malicious code (intentional & unintentional) that may affect local files; Protecting enterprises against code that may attempt to access or destroy data on networks.
Applications launched with Java Web Start are, by default, run in a restricted environment where they have limited access to local computing resources, such as storage devices and the local network. In this sandbox environment, Java Web Start can guarantee that a downloaded and potentially untrusted application cannot compromise the security of the local files or the network. An additional security feature supported by Java Web Start is digital code signing. If an application being invoked is delivered in one or more signed JAR files, Java Web Start will verify that the contents of the JAR file have not been modified since they were signed. If verification of a digital signature fails, Java Web Start will not run the application, since it may have been compromised by a third-party. The support for code signing is important for both users and for application service providers. This service makes it possible for users to verify that an application comes from a trusted source. Because the application service provider signs the code, both can be ensured that no other party can impersonate the application on the Web. A signed application that is trusted by the user can also request additional system privileges, such as access to a local disk. Java Web Start presents a dialog displaying the application's origin, based on the signer's certificate, before the application is launched. This allows the user to make an informed decision about whether or not to grant additional privileges to the downloaded code. By including the following settings in the JNLP file, an application can request full access to a client system if all its JAR files are signed :
<security>
The implementation of code signing in Java Web Start is based on the security API in the core Java(TM) Platform Standard Edition. The Java 2 SE JRE 1.4.2 supports code signing with the SHA1withDSA and MD5withRSA algorithms. Developers sign code for use with Java Web Start in the same way as for Java Applets—by using the standard jarsigner tool from the Java(TM) Platform Standard Edition. The jarsigner tool documentation provides examples of how to sign code and create test certificates, and it discusses other issues related to signing. Java Web Start also supports use of the Netscape signtool used with SDK/JRE 1.4.2. See the Netscape Web site for details: http://developer.netscape.com/software/signedobj/
Signing JAR Files With a Test Certificate http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/development.html
Here are the steps needed to sign a JAR file with a test certificate: 1. Make sure that you have an SDK 1.4.2 keytool and jarsigner in your path. These tools are located in the SDK bin directory. 2. Create a new key in a new keystore as follows: keytool -genkey -keystore myKeystore -alias myself
You will get prompted for a information about the new key, such as password, name, etc. This will create the myKeystore file on disk. 3. Then create a self-signed test certificate as follows: keytool -selfcert -alias myself -keystore myKeystore
This will prompt for the password. Generating the certificate may take a few minutes. 4. Check to make sure that everything is okay. To list the contents of the keystore, use this command: keytool -list -keystore myKeystore
It should list something like: Keystore type: jks Keystore provider: SUN Your keystore contains 1 entry: myself, Tue Jan 23 19:29:32 PST 2001, keyEntry, Certificate fingerprint (MD5): C2:E9:BF:F9:D3:DF:4C:8F:3C:5F:22:9E:AF:0B:42:9D
5. Finally, sign the JAR file with the test certificate as follows: jarsigner -keystore myKeystore test.jar myself
Repeat this step with all of your JAR files.
Note that a self-signed test certificate should only be used for internal testing, since it does not guarantee the identity of the user and therefore cannot be trusted. A trust-worthy certificate can be obtained from a certificate authority, such as VeriSign or Thawte, and should be used when the application is put into production.
How to Encode JNLP Files Beginning with Java Web Start version 1.2, JNLP files may be encoded in any character encoding supported by the Java(TM) Platform Standard Edition. (See the Java(TM) Platform Standard Edition documentation for a list of supported encodings.) To encode a JNLP file, specify an encoding in the XML prolog of that file. For example, the following line indicates that the JNLP file will be encoded in UTF-16.
The XML prolog itself must be UTF-8-encoded.
Dynamic Download of HTTPS Certificates http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/development.html
Beginning with 1.4.2, Java Web Start dynamically imports certificates in much the same way as browsers do. In order to make this work, Java Web Start now sets its own https handler, using the java.protocol.handler.pkgs system properties, to initialize defaults for SSLSocketFactory and HostnameVerifier. It sets the defaults with HttpsURLConnection.setDefaultSSLSocketFactory and HttpsURLConnection.setDefaultHostnameVerifier. If your application uses those two method, make sure they are called after the Java Web Start https handler is initialized, otherwise your custom handler will be replaced by the Java Web Start default handler. You can ensure that your own customized SSLSocketFactory and HostnameVerifiter are used by doing either of the following:
1. Installing your own https handler, which will completely replace the Java Web Start https handler (for more information, see A New Era for Java Protocol Handlers); 2. Calling HttpsURLConnection.setDefaultSSLSocketFactory or HttpsURLConnection.setDefaultHostnameVerifier only after the first https url object is created, which will execute the Java Web Start https handler initialization code first. For information on creating a download servlet see the next chapter, JnlpDownloadServlet Guide.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/development.html
JnlpDownloadServlet Guide Select a Chapter/Topic
Table of Contents Introduction Examples Servlet Configuration Specifying Resources Mapping Requests to Resources Processing of JNLP Files Pack200 Support
Introduction Java Web Start includes a servlet in the sample/jnlp directory of the JDK. It can be used on either a JNOP file and its associated resources packaged in a Web Archive (.war) file, or on an unarchived directory. The purpose of the servlet is to provide a simple and convenient packaging format for JNLP applications, so they can be easily deployed in a Web Container, such as Tomcat or a Java EE-compliant Application Server. The download servlet supports the following features:
Automatic installation of the codebase URL into JNLP files, thus eliminating manual management of hard-coded URLs into JNLP files. Explicit specification of the timestamp for a JNLP file, independent of the file-system timestamp. Supports all download protocols defined in the JNLP specification v1.0.1. These include basic download protocol, version-based download protocol, and extension download protocol. Version-based information is specified per file or per directory in the Web archive. Thus, no centralized file needs to be managed for the entire archive. Automatic generation of JARDiff files Pack200 support
The packaging support consists of one servlet: JnlpDownloadServlet. The servlet is packaged into the jnlp-servlet.jar file, which can be found in the SDK under samples/jnlp/servlet/. Below are two examples of how to use the servlet followed by a detailed description of the functionality of the servlet.
Examples The first example shows how an application can be packaged into a WAR file without using the version-based download. The JnlpDownloadServlet is used to insert the exact URL into the JNLP file at request time. The second example shows how to add support for version-based download as well.
WAR file without use of version-download protocol The example1.war contains: http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
/index.html /app/launch.jnlp /app/application.jar /app/images/icon.gif /WEB-INF/web.xml /WEB-INF/lib/jnlp-servlet.jar /WEB-INF/lib/<jar files for XML parser> (not needed if the servlet container is running J2SE 1.4+)
The JNLP file for the application would look like this: TS: 2002-04-23 19:21:05 <jnlp codebase="$$codebase"> Example 1 Myself <description>just an example <j2se version="1.2+"/> <jar href="application.jar"/>
The first line with the TS tag contains the timestamp that the servlet will return for the JNLP file. The format of the timestamp is in ISO 8601 format. If the line is omitted, the timestamp of the file in the WAR file is used. The $$codebase string is modified by the JnlpDownloadServlet to be the actual URL for the request. The web.xml file instructs the Web container to invoke the JNLPDownloadServlet for all requests to a JNLP file. <web-app> <servlet> <servlet-name>JnlpDownloadServlet <servlet-class>jnlp.sample.servlet.JnlpDownloadServlet <servlet-mapping> <servlet-name>JnlpDownloadServlet*.jnlp
The JnlpDownloadServlet requires an XML parser in order to work. If your servlet container is running J2SE 1.4+, there is already a XML parser integrated in it. Otherwise please add jar files that implement a Java XML parser to the WEB-INF/lib directory. The reference implementation of the parser can be downloaded from http://java.sun.com/xml.
WAR file with use of version-download protocol The example2.war contains: /index.html /app/version.xml /app/launch.jnlp /app/application.jar /app/lib__V2.1.jar /app/images/icon.gif /WEB-INF/web.xml /WEB-INF/lib/jnlp-servlet.jar /WEB-INF/lib/<jar files for XML parser> (not needed if the servlet container is running J2SE 1.4+)
The /app directory contains two JAR resources: application.jar and lib.jar. The lib.jar uses a naming convention to associate the version-id 2.1, i.e., the version information is associated on a per-file basis. The version of the application.jar http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
file is described in the version.xml file, i.e., on a per-directory basis. The version.xml file looks like this: <jnlp-versions> <pattern> application.jar 1.1 application.jar
The JNLP file for the application looks like this: TS: 2002-04-23 19:21:05 <jnlp codebase="$$codebase" href="$$name"> Example 2 Myself <description>just an example <j2se version="1.2+"/> <jar href="application.jar" version="1.1"/> <jar href="lib.jar" version="2.1"/>
Finally, the web.xml file configures the JnlpDownloadServlet to be invoked for all requests into the /app directory. <web-app> <servlet> <servlet-name>JnlpDownloadServlet <servlet-class>jnlp.sample.servlet.JnlpDownloadServlet <servlet-mapping> <servlet-name>JnlpDownloadServlet/app/*
Servlet Configuration This section shows how to configure a WAR file to include the JnlpDownloadServlet and also how the servlet can be configured.
Adding the Servlet to a WAR archive
First the necessary servlet code must be made available to the servlet container. This is done by populating the WEB-INF/lib directory. The servlet is added to a WAR archive by including the jnlp-servlet.jar file in the WEB-INF/lib/ directory. The servlet needs access to an XML parser. If your servlet container is running J2SE 1.4+, there is already a XML parser integrated in it. Otherwise JAR files implementing a Java XML parser must also be added. They can be downloaded from http://java.sun.com/xml. Once the servlet code is available, the Web container must be told to invoke the servlet on the right set of JNLP and JAR files, http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
or on a given subdirectory. This is all configured in the WEB-INF/web.xml file inside the <web-app> tag: <web-app> ...
The first thing to do is to tell the Web container how to invoke the servlet. This is done by using the <servlet> tag: <servlet> <servlet-name>JnlpDownloadServlet <servlet-class>jnlp.sample.servlet.JnlpDownloadServlet
Secondly, the Web container must be told when to invoke the servlet. This can be done in several ways. It can be invoked for certain directories or for files with certain extensions. For example, to invoke it for JNLP files, add the following to the web.xml file: <servlet-mapping> <servlet-name>JnlpDownloadServlet*.jnlp
Or for a given subdirectory: <servlet-mapping> <servlet-name>JnlpDownloadServlet/app/*
See also example1 and example2 for examples on how to configure the servlet.
Logging The servlet has built-in logging capabilities to monitor its behavior. Logging messages are generated in 4 different categories: FATAL A malfunction or internal error happened inside the servlet. WARNING An error processing some of the information in the WAR file, e.g., parsing the version.xml file. INFORMATIONAL Logging all requests and replies, re-scanning of directories, etc. DEBUG Detailed internal information about how a request is processed.
The logging output is controlled by two servlet initialization parameters, logLevel and logPath. The log level can be set to either NONE, FATAL, WARNING, INFORMATIONAL, or DEBUG. The log path specifies a file where the output will be written to. If no path is specified, logging is done to the standard log for servlets (using the ServletContext.log method). For example: <servlet> <servlet-name> JnlpDownloadServlet <servlet-class> jnlp.sample.servlet.JnlpDownloadServlet <param-name>
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
logLevel <param-value> DEBUG <param-name> logPath <param-value> /logs/jnlpdownloadservlet.log
Configuring file extensions and MIME types
The servlet treats JNLP and JAR files specially. JNLP files will be macro-expanded as described in a section below. A versionbased request for a JAR file might result in the generation for an incremental update. The servlet uses extensions to determine if a file is a JNLP or JAR file. The default extension of JNLP files is .jnlp and for JAR files is .jar. These default extensions can be overwritten by the initialization parameters: jnlp-extension and jar-extension. For example: <param-name> jnlp-extension <param-value> .xjnlp
The MIME type that is returned for a file is also based on its extension. The MIME type is looked up in the configuration files for the Web container and the WAR file. If no mapping is specified, the default MIME types are shown below: Extension Default MIME type ------------------------------------------.jnlp application/x-java-jnlp-file .jar application/x-java-archive .jardiff application/x-java-archive-diff
A mapping can be overwritten by using the <mime-type> element in the web.xml file. For example: <web-app> ... <mime-mapping> <extension>jnlp <mime-type>text/ascii ...
Specifying Resources
Application resources such as images, JAR files, and JNLP files are stored in the WAR file. The WAR file itself is a hierarchical directory structure, and the location of a resource inside the WAR file determines what URL will be used to look it up. http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
Assume that the WAR file (or servlet) has been configured so it handles all URL requests that starts with http://www.mytool.com/tool/ . If the following requests is made: http://www.mytool.com/tool/app/launch.jnlp. Then the JnlpDownloadServlet will look for the launch.jnlp resource in the app/ directory in the WAR file.
No version information A resource that has no associated version information, such as a JNLP file for an application, is simply just added to the WAR file. For example, given the above example, then the WAR file should included the following file: /app/launch.jnlp
In general, the timestamp that will be returned for the file is the last-modified timestamp that the file has in the WAR file. The only exception is for JNLP files where it can be explicitly specified in the JNLP file (see below).
Version information and more The version-based and extension-based download protocols in the JNLP specification allows a resource to be looked up based on version-id, operating system, system architecture, and locale. The JnlpDownloadServlet provides two mechanisms for associating this information with a resource. It can be done on a per-file basis, using a naming convention, or by a perdirectory basis, using a configuration file. Both methods can be used for the same directory. The following information can be associated with a resource:
A path to the resource, e.g., /app A name for the resource, e.g., launch.jnlp A version-id, e.g., 1.1.0 A list of supported operations systems, e.g., SunOS Linux A list of supported architectures, e.g., x86 A list of supported locales, e.g., da da_DK A flag indicating if the version-id is a product version or a platform version (only used for JRE downloading)
The path is specified by the location of the resource in the WAR archive. The rest of the information is either specified by the use of a naming convention or in the version.xml file.
Resource Naming The file naming convention is used if a double underscore (__) marker is found in the filename. The filename is parsed according to the BNF notation shown below: file ::= name __ options . ext options ::= option ( __ options ) * option ::= V version-id | O os | A arch | L locale
Only one version-id can be specified per file. However, multiple os, arch, and locale fields can be specified. For example: application__V1.2__Len_US__Len.jar
will mean that the resource application.jar has a version-id of 1.2, and the following associated locales: en_US and en.
The version.xml file In each directory, a version.xml file can be placed to describe the additional properties, such as a version-id, for files in that particular directory. This is an alternative to the file naming convention. http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
For example, placing the file application-1_2-us.jar in a directory, along with a version.xml with the following content: <jnlp-versions> <pattern> application.jar 1.2 en_US en application-1_2-us.jar
will be the same as having placed the file application__V1.2__Len_US__Len.jar in the directory.
A resource can also be specified with a platform version-id in the version.xml file. Such a resource is used to match a particular platform request for a JRE. A resource with a platform version-id is specified using the element. For example: <pattern> JRE 1.3 en_US en j2re-1_3.0-us.jnlp <product-version-id>1.3.0
Platform version requests are generated internally by Java Web Start, when an application has requested a version of the Java platform that is currently not installed on the local system. The complete document type definition (DTD) for the version.xml is shown in the following:
jnlp-versions resource (pattern, file)> platform (pattern, file, product-version-id)> pattern (name, version-id, os*, arch*, locale*)> name (#PCDATA)> version-id (#PCDATA)> os (#PCDATA)> arch (#PCDATA)> locale (#PCDATA)> file (#PCDATA)> product-version-id (#PCDATA)>
Mapping Requests to Resources The JNLP specification defines four different kinds of download requests that Java Web Start (or more generally, a JNLP Client) can make to a server when requesting a resource:
Basic Download Request: This is an ordinary URL request to a specific file. The Last-Modified field of the response is used to determine if an update is available on the server. The basic download request can be used for all resource types. Version-based Download Request: This request type can be used for JAR files and images, i.e., the following elements will generate a version-based download request: <jar>,, and , when the version attribute is included. Extension Download Request: This request type is an extension of the version-based request type and is generated by either the <j2se> or <extension> elements. In addition to the version information, it also contains information about
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
operating system, system architecture, and locale. Platform-version Download Request: This is simliar to the extension download request, but used to request a particular version of the J2SE Runtime Environment (JRE). This request is generated by Java Web Start, when a JNLP file has requested a particular version of the JRE that is not currently installed on the client system.
A request is initially processed by the JNLPDownloadServlet, and it extracts the following information from the request:
Path in WAR file, Name of requested file Version string (version-id parameter or platform-version-id parameter) Current version-id (current-version-id parameter) List of operation systems (os parameter) List of architectures (arch parameter) List of locales (locale parameter)
Consider example2, and assume that it is being hosted at http://www.mytool.com/tool2/. If the following requests is made: http://www.mytool.com/tool2/app/lib.jar&version-id=2.1. Then the path of the resource would be, app/, the name would be lib.jar, the version string would be 2.1, and the lists for os, architecture, and locales would be empty. A request to a directory, e.g., http://www.mytool.com/tool2/app/, will get appended the default filename: launch.jnlp. Thus, it would be the same as http://www.mytool.com/tool2/app/launch.jnlp.
Handling a basic download request A request for which no version-id is specified (neither version-id parameter or platform-version-id parameter is specified in the request) is handled as a basic download request. The request is first checked to see if it contains a double underscore (__) or is a request to the version.xml file. If so, the request is rejected and a HTTP 404 error code is returned. The JnlpDownloadServlet will then try to locate the resource with the given path and name in the WAR file, and if found return it. If the resource is not found, a HTTP 404 error code is returned for the request. If a match is found and it is a JNLP file, then it is preprocessed as described below before returned.
Handling a version-based download request The resource lookup for resources with a version-id is uniform across the version-based download protocol, the extension download protocol, and the platform-version download request.
First, the JnlpDownloadServlet will build a database of all the resources that are located in the WAR file directory that the URL request is accessing (based on the path in the request). The database is built by scanning the version.xml file (if present), and the list of files in the directory that is using the naming convention described above. The servlet caches the information internally. It only does a re-scan if the timestamp of the version.xml file is more recent than at the last scan. Thus, if you add a file using the naming convention, make sure to touch the version.xml file to force the servlet to do a rescan.
Secondly, the servlet will scan through the entries in the database to find a match for the given request (the match rules are described below). For a non-platform request, first the resource entries in the version.xml file are scanned in the order they are specified, and then secondly the entries that are specified using the naming convention. For a platform-version request, the platform entries in the version.xml file is scanned in the order they are specified. If several entries matches the request, then the entry with the highest version-id is returned. If multiple matches is found with the same highest version-id, then the first one specified is returned. The matching rules are as follows: http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
1. The name of the resource must match the request 2. The version-id of the resource must match the version string in the request 3. For the os, arch, and locale lists the following rules are used: 1. If an empty list is specified for the resource, then it is a match 2. If a non-empty list is specified for the resource, then it is a match, if at least one of the values specified for the resource is a prefix of at least one of the values specified in the request. The x-java-jnlp-version-id returned in the response is the version-id for the matching resource, except for a platform request where it is taken from the <product-version-id> field in the version.xml file. If a match is found and it is a JNLP file, then it is preprocessed as described below before returned.
Automatic JARDiff generation
The servlet will automatically generate and return incremental updates to JAR files, if possible. If the current-version-id parameter is included in the request and the servlet can find both a match on the current-version-id and the requested version (given the above matching rules) and the request is for a JAR file (e.g., the target resource has the .jar extension), then a JARDiff file will be generated by the servlet. The JARDiff file is returned as long as its size is less than that of the requested version.
The JARDiff file is generated and stored in a temporary directory that is specific to the given Web container. The servlet locates the temporary working directory using the javax.servlet.context.tempdir context attribute.
Processing of JNLP files The JnlpDownloadServlet will automatically macro-expand certain template values in a JNLP file and replace them with URLs that are specific to the current request. This will enable JNLP files to be written and deployed without containing hardcoded URLs.
Macro expansions
The servlet will automatically substitute certain fixed keys in the JNLP file (prefixed with $$) with URLs that are based on the current request. The keys are designed so location-independent WAR files can be created and deployed into a Web container.
The table below shows the 4 keys that the servlet will look for and substitute: Pattern Value ---------------------------------------------------------------$$codebase Complete URL for request, except name of JNLP file $$name Name of the JNLP file $$context Base URL for the Web Archive $$site Web site address without the WAR context portion
For example: Consider the example1 WAR file. Lets assume that it has been deployed at the following location: http://www.mytool.com/tool . Thus, a request to http://www.mytool.com/tool/app/launch.jnlp will return the JNLP file. The values of the macro-expanded keys would be: $$codebase $$name $$context $$site
= = = =
http://www.mytool.com/tool/app/ launch.jnlp http://www.mytool.com/tool/ http://www.mytool.com/
The servlet does not validate the format of the JNLP file nor that the XML is well-formed. The value substitution is purely textual.
Explicit Timestamps http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
An explicit timestamp can be included in a JNLP file to ensure that a consistent timestamp will be returned from the Web Server. This is especially useful if a JNLP file is replicated onto multiple Web servers that are serving the same URL in a round-robin or load-balancing fashion. Note that a similar method is not provided for JAR files. The version-based download protocol should be used instead. An explicit timestamp is included in the JNLP if the first-line starts with TS:. If so, it is parsed accordingly to the ISO 8601 formatting of timestamps (see below). The first line is also removed from the contents. See example1 and example2 above for sample JNLP files using the TS: element.
ISO 8601 Formatting The general format of a timestamp is: YYYY-MM-DD hh:mm:ss
The dashes, colons, and seconds are optional: YYYYMMDDhhmm
The hh is in 24h notation. By default, the local time zone is used. A Universal Time (UTC) (also know as GMT time) can be specified by appending the capital letter Z to a time as in: 23:59:59Z or 235959Z
The strings +hh:mm, +hhmm, or +hh
can be added to the time to indicate that the used local time zone is hh hours and mm minutes ahead of UTC. For time zones west of the zero meridian, which are behind UTC, the notation -hh:mm, -hhmm, or -hh
is used instead. For example, Central European Time (CET) is +0100 and U.S./Canadian Eastern Standard Time (EST) is 0500. The following strings all indicate the same point of time: 12:00Z = 13:00+01:00 = 0700-0500
Pack200 Support
You can now host *.jar.pack.gz or *.jar.gz files together with your original *.jar files. If the client supports the pack200-gzip or gzip file formats, the servlet will return the compressed file if it is available on the server. Java Web Start 5.0 supports both compression formats. You must host both the original jar file and the pack file in the server, otherwise the servlet will not pick up the pack file. The pack file can be created with the pack200.exe command included in J2SE 5.0. For more information on the pack200 compression technology, please see Pack200 and Compression for Network Deployment.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
JNLP File Syntax Select a Chapter/Topic
This chapter covers the following topics:
Introduction Example JNLP Elements jnlp Element information Element security Element update Element resources Element application-desc Element applet-desc Element component-desc Element installer-desc Element
Introduction The format used in this release is that specified in the Java Network Launching Protocol & API Specification (JSR-56) version 6.0. This document describes the most commonly used elements of a JNLP file. For a complete description of the format, refer to the specification.
JNLP File Contents Element
Attributes
jnlp
Description
Since
This is the main xml element for a jnlp file. Everything is contained within the jnlp element.
1.0
spec
The spec attribute can be 1.0, 1.5.0, or 6.0 or can use the wildcards such as 1.0+. It denoted the minimum version of the JNLP Specification that this jnlp file can work woth.
1.0
codebase
The codebase attribute specifies the base location for all relative URLs specified in href attributes in the JNLP file.
1.0
href
The href specifies the URL of the JNLP file itself.
1.0
version
The version of the application being launched, as well as the version of the JNLP file itself.
1.0
The information element contains other elements that describe the application and it's source.
1.0
information
Required yes
yes
1.5.0
os
Specifies the operating system for which this information element should be considered.
arch
Specifies the architecture for which this information element should be considered
1.5.0
platform
Specifies the platform for which this information element should be considered.
1.5.0
locale
Specifies the locale for which this information element should be considered.
1.5.0
title
The title element specifies the title of the application.
1.0
yes
vendor
The vendor element specifies the provider of the application.
1.0
yes
The homepage of the application.
1.0
A URL pointing to where more information on this application can be found.
1.0
A short statement describing the application.
1.0
An indicator as to what type of description this is, legal values are one-line, short, and tooltip.
1.0
Describes an icon that can be used to identify the application to the user.
1.0
href
A URL pointing to the icon file, may be in one of the following formats: gif, jpg, png, ico.
1.0
kind
Indicates the suggested use of the icon, can be: default, selected, disabled, rollover, splash, or shortcut.
1.0
width
Can be used to indicate the resolution of the image.
1.0
height
Can be used to indicate the resolution of the image.
1.0
depth
Can be used to indicate the resolution of the image.
1.0
homepage href description kind icon
offline-allowed
Indicates that this application can operate when the client system is disconnected from the network. 1.0
shortcut
The shortcut element can be used to indicate an application's preferences for desktop integration.
1.5.0
Can be used to describe the application's preference for creating a shortcut to run online or offline.
1.5.0
desktop
Can be used to indicate an application's preference for putting a shortcut on the users desktop.
1.5.0
menu
Can be used to indicate an application's preference for putting a menu item in the users start menus. 1.5.0
online
sub-menu association extensions
Can be used to indicate an application's preference for where to place the menu item.
1.5.0
Can be used to hint to the JNLP client that it wishes to be registered with the operating system as the primary handler of certain extensions and a certain mime-type.
1.5.0
Contains a list of file extensions (separated by spaces) that the application requests it be registered to handle.
1.5.0
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
yes
yes
mime-type
Contains the mime-type that the application requests it be registered to handle.
1.5.0
Describes an additional piece of related content that may be integrated with the application.
1.5.0
A URL pointing to the related content.
1.5.0
The update element is used to indicate the preferences for how application updates should be handled by the JNLP Client.
6.0
check
Indicates the preference for when the JNLP Client should check for updates. It can be always, timeout, or background..
6.0
policy
Indicates the preference for how the JNLP Client should handle an application update when it is known an update is available before the application is launched. It can be always, prompt-update, or prompt-run.
6.0
related-content href
update
yes
1.0 security
This element can be used to request enhanced permissions.
1.0
all-permissions
Requests that the application be run with all permissions.
1.0
j2ee-applicationclient-permissions
Requests that the application be run with a permission set that meets the security specifications of the J2EE Application Client environment.
1.0 1.0
resources
Describes all the resources that are needed for an application.
1.0
os
Specifies the operating system for which the resources element should be considered.
1.0
arch
Specifies the architecture for which the resources element should be considered.
1.0
locale
Specifies that the locales for which the resources element should be considered.
java (or j2se)
yes
Specifies what version(s) of Java to run the application with.
6.0 (java)
version
Describes an ordered list of version ranges to use.
1.0
href
The URL denoting the supplier of this version of java, and where it may be downloaded from.
1.0
java-vm-args
Indicates an additional set of standard and non-standard virtual machine arguments that the application would prefer the JNLP Client to use when launching Java.
1.0
initial-heap-size
Indicates the initial size of the Java heap.
1.0
max-heap-size
Indicates the maximum size of the Java heap.
1.0
Specifies a JAR file that is part of the application's classpath.
1.0
yes
href
The URL of the jar file.
1.0
yes
version
The requested version of the jar file. Requires using the version-based download protocol
1.0
main
Indicates if this jar contains the class containing the main method of the application.
1.0
download
Can be used to indicate this jar may be downloaded lazily, or when needed.
1.0
size
Indicates the downloadable size of the jar file in bytes.
1.0
part
Can be used to group resources together so they will be downloaded at the same time.
1.0
Specifies a JAR file that contains native libraries in it's root directory.
1.0
href
The URL of the jar file.
1.0
version
The requested version of the jar file. Requires using the version-based download protocol
1.0
download
Can be used to indicate this jar may be downloaded lazily.
1.0
size
Indicates the downloadable size of the jar file in bytes.
1.0
part
Can be used to group resources together so they will be downloaded at the same time.
1.0
Contains pointer to an additional component-desc or installer-desc to be used with this application.
1.0
href
The URL to the additional extension jnlp file.
1.0
version
The version of the additional extension jnlp file.
1.0
name
The name of the additional extension jnlp file
1.0
jar
nativelib
extension
ext-download
Can be used in an extension element to denote the parts contained in a component-extension.
1.0
ext-part
Describes the name of a part that can be expected to be found in the extension.
1.0
download
Can be used to indicate this extension may be downloaded eagerly or lazily.
1.0
part
Denotes the name of a part in this jnlp file to include the extension in.
1.0
package
yes
yes
yes
yes
Can be used to indicate to the JNLP Client which packages are implemented in which JAR files.
1.0
name
Package name contained in the jar files of the given part.
1.0
yes
part
Part name containing the jar files that include the given package name.
1.0
yes
recursive
Can be used to indicated that all package names beginning with the given name, can be found in the given part.
1.0
Defines a system property that will be available through the System.getProperty and System.getProperties methods.
1.0
name
Name of the system property.
1.0
yes
value
Value it will be set to.
1.0
yes
property
1.0
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
applicaation-desc main-class argument applet-desc
Note: A jnlp file must contain one of application-desc, applet-desc, component-desc, or installerdesc
1.0
Denotes this is the jnlp file for an application.
1.0
The name of the class containing the public static void main(String[]) method of the application.
1.0
Each argument contains (in order) an additional argument to be passed to main.
1.0
yes
yes
Denotes this is the jnlp file for an applet.
1.0
main-class
This is the name of the main Applet class.
1.0
documentbase
The document base for the Applet as a URL.
1.0
name
Name of the Applet.
1.0
yes
width
The width of the applet in pixels.
1.0
yes
height
The height of the applet in pixels
1.0
yes
param
yes
A set of parameters that can be passed into the applet.
1.0
name
The name of this parameter
1.0
yes
value
The value of this parameter
1.0
yes
Denotes this is the jnlp file for a component extension.
1.0
Denotes this is the jnlp file for an installed extension.
1.0
The name of the class containing the public static void main(String[]) method of the installer.
1.0
component-desc installer-desc main-class
yes
The JNLP file is an XML document. The following shows a complete example of a JNLP file.
Example <jnlp spec="6.0+" codebase="http://my_company.com/jaws/apps" href="swingset2.jnlp"> SwingSet2 Demo Application Sun Microsystems, Inc. <mime-type="application-x/swingset2-file"/> <extensions="swingset2"/> <shortcut online="false"> <desktop/> <menu submenu="My Corporation Apps"/> SwingSet2 Demo on Linux <security> <j2se version="1.6+" java-vm-args="-esa -Xnoclassgc"/> <jar href="lib/SwingSet2.jar"/>
The example shows the basic outline of the document. The root element is jnlp, which has four subelements: information, security, resources, and application-desc. In addition, Java Web Start also supports launching applets by using the applet-desc element. The elements are described in more detail below.
JNLP Elements jnlp Element spec attribute: This attribute must be 1.0 or higher to work with this release. The default value is "1.0+". Thus, it can typically be omited. Note that this version supports both spec version 1.0, version 1.5, and version 6.0, whereas previous versions support only 1.0 and 1.5. A jnlp file specifying spec="6.0+" will work with this version, but not previous versions of Java Web Start. codebase attribute: All relative URLs specified in href attributes in the JNLP file are using this URL as a base. href attribute: This is a URL pointing to the location of the JNLP file itself.
information Element title element: The name of the application. vendor element: The name of the vendor of the application. homepage element: Contains a single attribute, href, which is a URL locating the home page for the Application. It is used by the Java Application Cache Viewer to point the user to a Web page
where more information about the application can be found. description element: A short statement about the application. Description elements are optional. The kind attribute defines how the description should be used. It can have one of the following
values:
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
one-line: If a reference to the application is going to appear on one row in a list or a table, this description will be used. short: If a reference to the application is going to be displayed in a situation where there is room for a paragraph, this description is used. tooltip: If a reference to the application is going to appear in a tooltip, this description is used.
Only one description element of each kind can be specified. A description element without a kind is used as a default value. Thus, if Java Web Start needs a description of kind short, and it is not specified in the JNLP file, then the text from the description without an attribute is used. All descriptions contain plain text. No formatting, such as with HTML tags, is supported. icon element: Contains an HTTP URL to an image file in either GIF or JPEG format. The icons are used to represents the application
during launch when Java Web Start presents the application to the user; in the Java Application Cache Viewer; in desktop shortcuts.
A 64x64 icon is shown during download; in the Java Application Cache Viewer and in desktop shortcuts a 32x32 icon is used. Java Web Start automatically resizes an icon to the appropriate size. Optional width and height attributes can be used to indicate the size of the images. The optional kind="splash" attribute may be used in an icon element to indicate that the image is to be used as a "splash" screen during the launch of an application. If the JNLP file does not contain an icon element with kind="splash" attribute, Java Web Start will construct a splash screen using other items from the information Element. If the JNLP file does not contain any icon images, the splash image will consist of the application's title and vendor, as taken from the JNLP file. The first time an application is launched following the addition or modification of the icon element in the JNLP file, the old splash image will still be displayed. The new splash image will appear on the second and subsequent launches of the application. offline-allowed element: The optional offline-allowed element indicates if the application can be launched offline.
If offline-allowed is specified, then the application can be launched offline by the Java Application Cache Viewer, and shortcuts can be created which launch the application offline. If an application is launched offline, it will not check for updates and the API call BasicService.isOffline() will return true. The offline-allowed element also controls how Java Web Start checks for an update to an application. If the element is not specified—i.e., the application is required to be online to run—Java Web Start will always check for an updated version before launching the application. And if an update is found, the new application will be downloaded and launched. Thus, it is guaranteed that the user always runs the latest version of the application. The application, however, must be run online. If offline-allowed is specified, Java Web Start will also check to see if an update is available. However, if the application is already downloaded the check will timeout after a few seconds, in which case the cached application will be launched instead. Given a reasonably fast server connection, the latest version of the application will usually be run, but it is not guaranteed. The application, however, can be run offline. shortcut element: The optional shortcut element can be used to indicate an application's preferences for desktop integration. The shortcut element and it's sub-elements provide hints that the JNLP Client may or may not use. The shortcut element can contain the optional online attribute, and the two optional sub-elements, desktop and menu. association element: The optional association element is a hint to the JNLP client that it wishes to be registered with the operating system as the primary handler of certain extensions and a certain
mime-type. The association element must have the extensions and mime-type attributes.
related-content element: The optional related-content element describes an additional piece of related content, such as a readme file, help pages, or links to registration pages, as a hint to a JNLP
Client. The application is asking that this content be included in its desktop integration. The related-content element has a mandatory href and title attribute. It can contain any of the following two sub-elements:
description element: A short description of the related content. icon element: The icon can be used by the JNLP Client to identify the related content to the user.
security Element Each application is, by default, run in a restricted execution environment, similar to the Applet sandbox. The security element can be used to request unrestricted access. If the all-permissions element is specified, the application will have full access to the client machine and local network. If an application requests full access, then all JAR files must be signed. The user will be prompted to accept the certificate the first time the application is launched. update Element The update element is used to indicate the preferences for how application updates should be handled by Java Web Start. The update element can contain the following two optional attributes: check attribute: The check attribute indicates the preference for when the JNLP Client should check for updates, and can have one of the three values: "always", "timeout", and "background"
A value of "always" means to always check for updates before launching the application. A value of "timeout" (default) means to check for updates until timeout before launching the application. If the update check is not completed before the timeout, the application is launched, and the update check will continue in the background. A value of "background" means to launch the application while checking for updates in the background. policy attribute: The policy attribute indicates the preference for how the JNLP Client should handle an application update when it is known an update is available before the application is
launched, and can have one of the following three values: "always", "prompt-update", and "prompt-run" A value of "always" (default) means to always download updates without any prompt. A value of "prompt-update" means to ask the user if he/she wants to download and run the updated version, or launch the cached version. A value of "prompt-run" means to ask the user if he/she wants to download and run the updated version, or cancel and abort runing the application. For example: resources Element The resources element is used to specify all the resources, such as Java class files, native libraries, and system properties, that are part of the application. A resource definition can be restricted to a specific operating system, architecture, or locale using the os, arch, and locale attributes.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
The resources element has six different possible subelements: jar, nativelib, j2se, property, package, and extension. The package and extension elements are not discussed in this developer's guide. See the Java Network Launching Protocol & API Specification (JSR-56) version 6.0 for details. A jar element specifies a JAR file that is part of the application's classpath. For example: <jar href="myjar.jar"/>
The jar file will be loaded into the JVM using a ClassLoader object. The jar file will typically contain Java classes that contain the code for the particular application, but can also contain other resources, such as icons and configuration files, that are available through the getResource mechanism. A nativelib element specifies a JAR file that contains native libraries. For example:
By default, jar and nativelib resources will be downloaded eagerly, i.e., they are downloaded and available locally to the JVM running the application before the application is launched. The jar and nativelib elements also allow a resource to be specified as lazy. This means the resource does not have to be downloaded onto the client system before the application is launched. The download attribute is used to control whether a resource is downloaded eagerly or lazily. For example: <jar href="sound.jar" download="lazy"/>
The j2se element specifies what Java(TM) Platform Standard Edition Runtime Environment (JRE) versions an application is supported on, as well as standard parameters to the Java Virtual Machine. If several JREs are specified, this indicates a prioritized list of the supported JREs, with the most preferred version first. For example: <j2se version="1.3" initial-heap-size="64m" max-heap-size="128m"/> <j2se version="1.4.2+" href="http://java.sun.com/products/autodl/j2se" java-vm-args="-esa -Xnoclassgc"/> The version attribute refers, by default, to a platform version (specification version) of the Java(TM) Platform Standard Edition. Currently defined platform versions are 1.2, 1.3, 1.4, 1.5 and 1.6. (A platform version will not normally contain a micro version number; e.g., 1.4.2.) Exact product versions (implementation versions) may also be specified. by including the href attribute. For example, 1.3.1_07, 1.4.2, or 1.5.0-beta2 by Sun Microsystems, Inc. For example, <j2se version="1.4.2" href="http://java.sun.com/products/autodl/j2se"/ or <j2se version="1.4.2_04" href="http://java.sun.com/products/autodl/j2se"/> If a platform version is specified (i.e., no href attribute is provided), Java Web Start will not consider an installed non-FCS (i.e., milestone) JRE as a match. E.g., a request of the form <j2se version="1.4+"/>
would not consider an installed 1.4.1-ea or 1.4.2-beta JRE as a match for the request. Starting with 1.3.0, a JRE from Sun Microsystems, Inc., is by convention a non-FCS (milestone) JRE if there is a dash (-) in the version string. The java-vm-args attribute of the j2se element specifies a preferred set of virtual machine arguments to use when launching java. <j2se version="1.4+" java-vm-args="-ea -Xincgc"/>
The following java-vm-args are supported by this version: -d32,
/* use a 32-bit data model if available */ -client, /* to select the client VM */ -server, /* to select the server VM */ -verbose, /* enable verbose output */ -version, /* print product version and exit */ -showversion, /* print product version and continue */ -help, /* print this help message */ -X, /* print help on non-standard options */ -ea, /* enable assertions */ -enableassertions, /* enable assertions */ -da, /* disable assertions */ -disableassertions, /* disable assertions */ -esa, /* enable system assertions */ -enablesystemassertions, /* enable system assertions */ -dsa, /* disable system assertione */ -disablesystemassertions, /* disable system assertione */ -Xmixed, /* mixed mode execution (default) */ -Xint, /* interpreted mode execution only */ -Xnoclassgc, /* disable class garbage collection */ -Xincgc, /* enable incremental garbage collection */ -Xbatch, /* disable background compilation */ -Xprof, /* output cpu profiling data */ -Xdebug, /* enable remote debugging */ -Xfuture, /* enable strictest checks, anticipating future default */ -Xrs, /* reduce use of OS signals by Java/VM (see documentation) */ -XX:+ForceTimeHighResolution, /* use high resolution timer */ -XX:-ForceTimeHighResolution, /* use low resolution (default) */
Plus any argument starting with one of the following: -ea, /* enable assertions for classes */ -enableassertions, /* enable assertions for classes */ -da, /* disable assertions for classes */ -disableassertions, /* disable assertions for classes */ -verbose, /* enable verbose output */ -Xms, /* set initial Java heap size */ -Xmx, /* set maximum Java heap size */
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
-Xss, /* set java thread stack size */ -XX:NewRatio, /* set Ratio of new/old gen sizes */ -XX:NewSize, /* set initial size of new generation */ -XX:MaxNewSize, /* set max size of new generation */ -XX:PermSize, /* set initial size of permanent gen */ -XX:MaxPermSize, /* set max size of permanent gen */ -XX:MaxHeapFreeRatio, /* heap free percentage (default 70) */ -XX:MinHeapFreeRatio, /* heap free percentage (default 40) */ -XX:UseSerialGC, /* use serial garbage collection */ -XX:ThreadStackSize, /* thread stack size (in KB) */ -XX:MaxInlineSize, /* set max num of bytecodes to inline */ -XX:ReservedCodeCacheSize, /* Reserved code cache size (bytes) */ -XX:MaxDirectMemorySize,
The property element defines a system property that will be available through the System.getProperty and System.setProperties methods. It has two required attributes: name and value. For example: <property name="key" value="overwritten"/> Properties set in the jnlp file will normally be set by Java Web Start after the VM is started but before the application is invoked. Some properties are considered "secure" properties and can be passed as -Dkey=value arguments on the java invocation command line. The following properties are considered "secure" and will be passed to the VM in this way: sun.java2d.noddraw, javax.swing.defaultlf, javaws.cfg.jauthenticator, swing.useSystemFontSettings, swing.metalTheme, http.agent, http.keepAlive, sun.awt.noerasebackground, sun.java2d.opengl, sun.java2d.d3d, java.awt.syncLWRequests, java.awt.Window.locationByPlatform, sun.awt.erasebackgroundonresize, swing.noxp, swing.boldMetal, awt.useSystemAAFontSettings, sun.java2d.dpiaware,
For an untrusted application, system properties set in the JNLP file will only be set by Java Web Start if they are considered secure, or if the property name begins with "jnlp." or "javaws.". application-desc Element The application element indicates that the JNLP file is launching an application (as opposed to an applet). The application element has an optional attribute, main-class, which can be used to specify the name of the application's main class, i.e., the class that contains the public static void main(String argv[]) method where execution must begin. The main-class attribute can be omitted if the first JAR file specified in the JNLP file contains a manifest file containing the main class. Arguments can be specified to the application by including one or more nested argument elements. For example: <argument>arg1 <argument>arg2
applet-desc Element Java Web Start has support for launching Java applets. This support provides easy migration of existing code to Java Web Start. An applet is launched using the applet-desc element instead of the application-desc element. For example: <param name="key1" value="value1"/> <param name="key2" value="value2"/>
The JAR files that make up the applet are described using the resources element as for applications. The documentBase must be provided explicitly since a JNLP file is not embedded in an HTML page. The rest of the attributes correspond to the respective HTML applet tag elements. The main-class attribute is used instead of the code attribute. The main-class attribute is assigned the name of the Applet class (without the .class extension). This attribute can be omitted if the Applet class can be found from the Main-Class manifest entry in the main JAR file. Note: Applets must be packaged in JAR files in order to work with Java Web Start. component-desc Element The component-desc element denotes that this jnlp file is not an application or an applet but an extension that can be used as a resource in an application, applet or another extension. A component extension is typically used to factor out a set of resources that are shared between multiple applications or that have separate security needs. installer-desc Element The installer-desc element denotes that this jnlp file is an installer extension that defines an application that will be run only once, the first time this extension jnlp file is used in an application, applet or another extension. An installer extension is typically used to install platform specific native code that requires a more complicated setup than simply loading a native library into the VM.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
JNLP API Examples Select a Chapter/Topic
This chapter includes the following topics:
Introduction Using a BasicService Service Using a ClipboardService Service Using a DownloadService Service Using a FileOpenService Service Using a FileSaveService Service Using a PrintService Service Using a PersistenceService Service Using FileContents Using a JNLPRandomAccessFile Using a SingleInstanceService Service Using a ExtendedService Service
Introduction The JNLP API is designed to provide additional information to the application that would otherwise not be available using the standard Java(TM) Platform Standard Edition API. The following code examples show how the following services can be used: BasicService, ClipboardService, DownloadService, FileOpenService, FileSaveService, PrintService, and PersistenceService.
The public classes and interfaces in the JNLP API are included in the jnlp.jar file. This JAR file must be included in the classpath when compiling source files that use the JNLP API. For example on Windows: javac -classpath .;jnlp.jar *.java
The jnlp.jar file is included in the JNLP Developers Pack.
Using a BasicService Service The javax.jnlp.BasicService service provides a set of methods for querying and interacting with the environment similar to what the AppletContext provides for a Java Applet. The showURL method uses the JNLP API to direct the default browser on the platform to show the given URL. The method returns true if the request succeeds, otherwise false. import javax.jnlp.*; ... // Method to show a URL boolean showURL(URL url) { try { // Lookup the javax.jnlp.BasicService object BasicService bs = (BasicService)ServiceManager.lookup("javax.jnlp.BasicService"); // Invoke the showDocument method return bs.showDocument(url);
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
} catch(UnavailableServiceException ue) { // Service is not supported return false; } }
Using a ClipboardService Service The javax.jnlp.ClipboardService service provides methods for accessing the shared system-wide clipboard, even for applications that are running in the restricted execution environment. Java Web Start will warn the user of the potential security risk of letting an untrusted application access potentially confidential information stored in the clipboard, or overwriting contents stored in the clipboard. import javax.jnlp; ... private ClipboardService cs; try { cs = (ClipboardService)ServiceManager.lookup ("javax.jnlp.ClipboardService"); } catch (UnavailableServiceException e) { cs = null; } if (cs != null) { // set the system clipboard contents to a string selection StringSelection ss = new StringSelection("Java Web Start!"); cs.setContents(ss); // get the contents of the system clipboard and print them Transferable tr = cs.getContents(); if (tr.isDataFlavorSupported(DataFlavor.stringFlavor)) { try { String s = (String)tr.getTransferData(DataFlavor.stringFlavor); System.out.println("Clipboard contents: " + s); } catch (Exception e) { e.printStackTrace(); } } }
Using a DownloadService Service The javax.jnlp.DownloadService service allows an application to control how its own resources are cached. The service allows an application to determine which of its resources are cached, to force resources to be cached, and to remove resources from the cache. import javax.jnlp.*; ... DownloadService ds; try { ds = (DownloadService)ServiceManager.lookup("javax.jnlp.DownloadService"); } catch (UnavailableServiceException e) { ds = null; }
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
if (ds != null) { try { // determine if a particular resource is cached URL url = new URL("http://java.sun.com/javase/technologies/desktop/javawebstart/lib/draw.jar"); boolean cached = ds.isResourceCached(url, "1.0"); // remove the resource from the cache if (cached) { ds.removeResource(url, "1.0"); } // reload the resource into the cache DownloadServiceListener dsl = ds.getDefaultProgressWindow(); ds.loadResource(url, "1.0", dsl); } catch (Exception e) { e.printStackTrace(); } }
Using a FileOpenService Service The javax.jnlp.FileOpenService service provides methods for importing files from the local disk, even for applications that are running in the restricted execution environment. This interface is designed to provide the same kind of of disk access to potentially untrusted Web-deployed applications that a Web developer has when using HTML. HTML forms support the inclusion of files by displaying a file open dialog. import javax.jnlp.*; ... FileOpenService fos; try { fos = (FileOpenService)ServiceManager.lookup("javax.jnlp.FileOpenService"); } catch (UnavailableServiceException e) { fos = null; } if (fos != null) { try { // ask user to select a file through this service FileContents fc = fos.openFileDialog(null, null); // ask user to select multiple files through this service FileContents[] fcs = fos.openMultiFileDialog(null, null); } catch (Exception e) { e.printStackTrace(); } }
Using a FileSaveService Service The javax.jnlp.FileSaveService service provides methods for exporting files to the local disk, even for applications that are running in the restricted execution environment. This interface is designed to provide the same level of disk access to potentially untrusted Web-deployed applications that a Web browser provides for contents that it is displaying. Most browsers provide a Save As... dialog as part of their user interface. import javax.jnlp.*; ... FileSaveService fss;
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
FileOpenService fos; try { fos = (FileOpenService)ServiceManager.lookup("javax.jnlp.FileOpenService"); fss = (FileSaveService)ServiceManager.lookup ("javax.jnlp.FileSaveService"); } catch (UnavailableServiceException e) { fss = null; fos = null; } if (fss != null && fos != null) { try { // get a file with FileOpenService FileContents fc = fos.openFileDialog(null, null); // one way to save a file FileContents newfc = fss.saveFileDialog(null, null, fc.getInputStream(), "newFileName.txt"); // another way to save a file FileContents newfc2 = fss.saveAsFileDialog(null, null, fc); } catch (Exception e) { e.printStackTrace(); } }
Also see Using FileContents.
Using a PrintService Service The javax.jnlp.PrintService service provides methods for access to printing, even for applications that are running in the restricted execution environment. Using this service, an application can submit a print job. Java Web Start will then show this request to the user and, if accepted, queue the request to the printer. In Java Web Start 5.0, you can now directly use the Java Printing APIs, and Java Web Start will pop up a security dialog asking the user to grant PrintPermission if the application is running in a sandbox. There is no need to use the JNLP Printing APIs anymore. You can have full access to the Java Printing APIs in any JNLP application. import javax.jnlp.*; ... PrintService ps; try { ps = (PrintService)ServiceManager.lookup("javax.jnlp.PrintService"); } catch (UnavailableServiceException e) { ps = null; } if (ps != null) { try { // get the default PageFormat PageFormat pf = ps.getDefaultPage(); // ask the user to customize the PageFormat PageFormat newPf = ps.showPageFormatDialog(pf); // print the document with the PageFormat above ps.print(new DocToPrint()); } catch (Exception e) { e.printStackTrace();
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
} }
// Code to construct the Printable Document class DocToPrint implements Printable { public int print(Graphics g, PageFormat pageformat, int PageIndex){ // code to generate what you want to print } }
Using a PersistenceService Service The javax.jnlp.PersistenceService service provides methods for storing data locally on the client system, even for applications that are running in the restricted execution environment.
The service is designed to be somewhat similar to that which the cookie mechanism provides to HTML-based applications. Cookies allow a small amount of data to be stored locally on the client system. That data can be securely managed by the browser and can only be retrieved by HTML pages which originate from the same URL as the page that stored the data. import javax.jnlp.*; ... PersistenceService ps; BasicService bs; try { ps = (PersistenceService)ServiceManager.lookup("javax.jnlp.PersistenceService"); bs = (BasicService)ServiceManager.lookup("javax.jnlp.BasicService"); } catch (UnavailableServiceException e) { ps = null; bs = null; } if (ps != null && bs != null) { try { // find all the muffins for our URL URL codebase = bs.getCodeBase(); String [] muffins = ps.getNames(url); // get the attributes (tags) for each of these muffins. // update the server's copy of the data if any muffins // are dirty int [] tags = new int[muffins.length]; URL [] muffinURLs = new URL[muffins.length]; for (int i = 0; i < muffins.length; i++) { muffinURLs[i] = new URL(codebase.toString() + muffins[i]); tags[i] = ps.getTag(muffinURLs[i]); // update the server if anything is tagged DIRTY if (tags[i] == PersistenceService.DIRTY) { doUpdateServer(muffinURLs[i]); } } // read in the contents of a muffin and then delete it FileContents fc = ps.get(muffinURLs[0]); long maxsize = fc.getMaxLength(); byte [] buf = new byte[fc.getLength()]; InputStream is = fc.getInputStream(); long pos = 0; while((pos = is.read(buf, pos, buf.length - pos)) > 0) { // just loop } is.close(); ps.delete(muffinURLs[0]);
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
// re-create the muffin and repopulate its data ps.create(muffinURLs[0], maxsize); fc = ps.get(muffinURLs[0]); // don't append OutputStream os = fc.getOutputStream(false); os.write(buf); os.close(); } catch (Exception e) { e.printStackTrace(); } } void doUpdateServer(URL url) { // update the server's copy of the persistent data // represented by the given URL ... ps.setTag(url, PersistenceService.CACHED); }
Using FileContents javax.jnlp.FileContents objects encapsulate the name and contents of a file. An object of this class is used by the FileOpenService, FileSaveService and PersistenceService. Here is an example of how an instance of a FileContents can
be used to read from and write to a file:
import javax.jnlp.*; ... FileOpenService fos; //Initialize fos (see Using a FileOpenService Service example) ... if (fos != null) { try { // get a FileContents object to work with from the // FileOpenService FileContents fc = fos.openFileDialog(null, null); // get the InputStream from the file and read a few bytes byte [] buf = new byte[fc.getLength()]; InputStream is = fc.getInputStream(); int pos = 0; while ((pos = is.read(buf, pos, buf.length - pos)) > 0) { // just loop } is.close(); // get the OutputStream and write the file back out if (fc.canWrite()) { // don't append OutputStream os = fc.getOutputStream(false); os.write(buf); } } catch (Exception e) { e.printStackTrace(); } }
Using a JNLPRandomAccessFile http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
Instances of javax.jnlp.JNLPRandomAccessFile support both reading and writing to a random access file. A random access file behaves like a large array of bytes stored in the file system. Here is an example of how an instance of a JNLPRandomAccessFile can be used to write to a random access file: import javax.jnlp.*; ... FileOpenService fos; //Initialize fos (see Using a FileOpenService Service example) ... if (fos != null) { try { // ask the user to choose a file to open FileContents fc = fos.openFileDialog(null, null); // attempt to increase the maximum file length long grantedLength = fc.getLength(); if (grantedLength + 1024 > fc.getMaxLength()) { // attempt to increase the maximum file size defined by // the client grantedLength = fc.setMaxLength(grantedLength + 1024); } // if we were able to increase the maximum allowable file size, // get a JNLPRandomAccessFile representation of the file, and // write to it if (fc.getMaxSize() > fc.getLength() && fc.canWrite()) { JNLPRandomAccessFile raf = fc.getRandomAccessFile("rw"); raf.seek(raf.length() - 1); raf.writeUTF("Java Web Start!"); raf.close(); } } catch (Exception e) { e.printStackTrace(); } }
Using a SingleInstanceService Service The javax.jnlp.SingleInstanceService provides a set of methods for applications to register themselves as singletons, and to register listener(s) for handling arguments passed in from different instances of applications. import javax.jnlp.*; ... SingleInstanceService sis; ... try { sis = (SingleInstanceService)ServiceManager.lookup("javax.jnlp.SingleInstanceService"); } catch (UnavailableServiceException e) { sis=null; } ... // Register the single instance listener at the start of your application SISListener sisL = new SISListener(); sis.addSingleInstanceListener(sisL); ...
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
// Remember to remove the listener before your application exits sis.removeSingleInstanceListener(sisL); System.exit(0);
// Implement the SingleInstanceListener for your application class SISListener implements SingleInstanceListener { public void newActivation(String[] params) { // your code to handle the new arguments here ... } }
Using an ExtendedService Service The javax.jnlp.ExtendedService provides additional support to the current JNLP API. It allows applications to open specific file(s) in the client's file system. import javax.jnlp.*; ... ExtendedService es; ... try { es = (ExtendedService)ServiceManager.lookup("javax.jnlp.ExtendedService"); } catch (UnavailableServiceException e) { es=null; } ... // Open a specific file in the local machine File a = new File("c:\somefile.txt"); ... // Java Web Start will pop up a dialog asking the user to grant permission // to read/write the file c:\somefile.txt FileContents fc_a = es.openFile(a); // You can now use the FileContents object to read/write the file ... // Open a specific set of files in the local machine File[2] fArray = new File[2]; fArray[0] = a; fArray[1] = new File("c:\anotherFile.txt"); // Java Web Start will pop up a dialog asking the user to grant permission // to read/write files in fArray
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
FileContents[] fc_Array = es.OpenFiles(fArray); // You can now read/write the set of files in fc_Array using the // FileContents objects }
For detailed information on using javaws, see the javaws Command Line Interface.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
Package Class Tree Index PREV PACKAGE NEXT PACKAGE
FRAMES NO FRAMES All Classes
Package javax.jnlp Interface Summary BasicService ClipboardService
The BasicService interface provides access to the codebase of the application, if an application is run in offline mode, and simple interaction with the native browser on the given platform. ClipboardService provides methods for accessing the shared system-wide clipboard, even for
applications that are running in the untrusted execution environment.
DownloadService
DownloadService service allows an application to control how its own resources are cached, to determine which of its resources are currently cached, to force resources to be cached, and to remove resources from the cache.
DownloadServiceListener
The DownloadServiceListener provides an interface for a callback object implementation, which may be used by a DownloadService implementation.
ExtendedService
ExtendedService provides additional support to the current JNLP API, which allow
applications to open a specific file in the client's file system.
ExtensionInstallerService
The ExtensionInstallerService is used by an extension installer to communicate with the JNLP Client.
FileContents
FileContents objects encapsulate the name and contents of a file.
FileOpenService
FileOpenService service allows the user to choose a file from the local file system, even for applications that are running in the untrusted execution environment.
FileSaveService
FileSaveService service allows the user to save a file to the local file system, even for applications that are running in the untrusted execution environment.
JNLPRandomAccessFile Instances of this class support both reading and writing to a random access file. PersistenceService PrintService ServiceManagerStub SingleInstanceListener SingleInstanceService
PersistenceService provides methods for storing data locally on the client system, even for
applications that are running in the untrusted execution environment.
PrintService provides methods for access to printing functions, even for applications that are
running in the untrusted execution environment.
A ServiceManagerStub object implements the particular lookup of JNLP services by the JNLP Client. SingleInstanceListener is a interface which should be implemented by a JNLP application if
they wish to support single instance behaviour. SingleInstanceService allow applications launched under Java Web Start to register
themselves as singletons, and to be passed in new parameter sets when user attempts to launch new instances of them.
Class Summary ServiceManager The ServiceManager provides static methods to lookup JNLP services.
Exception Summary http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/package-summary.html
UnavailableServiceException
The UnavailableServiceException is thrown by the ServiceManager when a nonexisting or unavailable service is looked up.
Package Class Tree Index PREV PACKAGE NEXT PACKAGE
FRAMES NO FRAMES All Classes
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/package-summary.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface BasicService public interface BasicService
The BasicService interface provides access to the codebase of the application, if an application is run in offline mode, and simple interaction with the native browser on the given platform. This interface mimics loosely the AppletContext functionality. Since: 1.0
Method Summary java.net.URL
getCodeBase()
Returns the codebase for the application. boolean
isOffline()
Determines if the system is offline. boolean
isWebBrowserSupported()
Checks if a Web browser is supported on the current platform and by the given JNLP Client. boolean
showDocument(java.net.URL url)
Directs a browser on the client to show the given URL.
Method Detail getCodeBase java.net.URL getCodeBase()
Returns the codebase for the application. The codebase is either specified directly in the JNLP file, or it is the location of the JAR file containing the main class of the application. Returns: a URL with the codebase of the application
isOffline boolean isOffline()
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/BasicService.html
Determines if the system is offline. The return value represents the JNLP client's "best guess" at the online / offline state of the client system. The return value is does not have to be guaranteed to be reliable, as it is sometimes difficult to ascertain the true online / offline state of a client system. Returns: true if the system is offline, otherwise false
showDocument boolean showDocument(java.net.URL url)
Directs a browser on the client to show the given URL. This will typically replace the page currently being viewed in a browser with the given URL, or cause a browser to be launched that will show the given URL. Parameters: url - an URL giving the location of the document. A relative URL will be relative to the codebase. Returns: true if the request succeded, otherwise false
isWebBrowserSupported boolean isWebBrowserSupported()
Checks if a Web browser is supported on the current platform and by the given JNLP Client. If this is not the case, then showDocument(java.net.URL) will always return false. Returns: true if a Web browser is supported, otherwise false
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/BasicService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface ClipboardService public interface ClipboardService ClipboardService provides methods for accessing the shared system-wide clipboard, even for applications that are running in the
untrusted execution environment. Implementors should warn the user of the potential security risk of letting an untrusted application have access to potentially confidential information stored in the clipboard, or overwriting the contents of the clipboard. Since: 1.0
Method Summary java.awt.datatransfer.Transferable
getContents()
Returns a Transferable object representing the current contents of the clipboard. void
setContents(java.awt.datatransfer.Transferable contents) Sets the current contents of the clipboard to the specified Transferable object.
Method Detail getContents java.awt.datatransfer.Transferable getContents()
Returns a Transferable object representing the current contents of the clipboard. If the clipboard currently has no contents, it returns null. Returns: The current Transferable object on the clipboard.
setContents void setContents(java.awt.datatransfer.Transferable contents)
Sets the current contents of the clipboard to the specified Transferable object. Parameters: contents
- The Transferable object representing clipboard content.
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ClipboardService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface DownloadService public interface DownloadService DownloadService service allows an application to control how its own resources are cached, to determine which of its
resources are currently cached, to force resources to be cached, and to remove resources from the cache. The JNLP Client is responsible for providing a specific implementation of this service. Since: 1.0
Method Summary DownloadServiceListener
getDefaultProgressWindow() Return a default DownloadServiceListener implementation which, when passed to a load
method, should pop up and update a progress window as the load progresses. boolean
isExtensionPartCached(java.net.URL ref, java.lang.String version, java.lang.String part) Returns true if the given part of the given extension is cached, and the extension and part are
mentioned in the JNLP file for the application.
boolean
isExtensionPartCached(java.net.URL ref, java.lang.String version, java.lang.String[] parts) Returns true if the given parts of the given extension are cached, and the extension and parts
are mentioned in the JNLP file for the application.
boolean
isPartCached(java.lang.String part) Returns true if the part referred to by the given string is cached, and that part is mentioned in
the JNLP file for the application.
boolean
isPartCached(java.lang.String[] parts) Returns true if the parts referred to by the given array are cached, and those parts are
mentioned in the JNLP file for the application.
boolean
isResourceCached(java.net.URL ref, java.lang.String version) Returns true if the resource referred to by the given URL and version is cached, and that
resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or the calling application has been granted all-permissions.
void
loadExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String [] parts, DownloadServiceListener progress)
Downloads the given parts of the given extension, if the parts and the extension are mentioned in the JNLP file for the application. void
loadExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String part, DownloadServiceListener progress)
Downloads the given part of the given extension, if the part and the extension are mentioned in the JNLP file for the application. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
void
loadPart(java.lang.String[] parts, DownloadServiceListener progress)
Downloads the given parts, if the parts are mentioned in the JNLP file for the application. void
loadPart(java.lang.String part, DownloadServiceListener progress)
Downloads the given part, if the part is mentioned in the JNLP file for the application. void
loadResource(java.net.URL ref, java.lang.String version, DownloadServiceListener progress)
Downloads the given resource, if the resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or if the calling application has been granted all-permissions. void
removeExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String part)
Removes the given part of the given extension from the cache, if the part and the extension are mentioned in the JNLP file for the application. void
removeExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String [] parts)
Removes the given parts of the given extension from the cache, if the parts and the extension are mentioned in the JNLP file for the application. void
removePart(java.lang.String part)
Removes the given part from the cache, if the part is mentioned in the JNLP file for the application. void
removePart(java.lang.String[] parts)
Removes the given parts from the cache, if the parts are mentioned in the JNLP file for the application. void
removeResource(java.net.URL ref, java.lang.String version)
Removes the given resource from the cache, if the resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or if the calling application has been granted all-permissions.
Method Detail isResourceCached boolean isResourceCached(java.net.URL ref, java.lang.String version)
Returns true if the resource referred to by the given URL and version is cached, and that resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or the calling application has been granted all-permissions. . Parameters: ref - The URL for the resource. version - The version string, or null for no version. Returns: true if the above conditions are met, and false otherwise.
isPartCached boolean isPartCached(java.lang.String part)
Returns true if the part referred to by the given string is cached, and that part is mentioned in the JNLP file for the http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
application. Parameters: part - The name of the part. Returns: true if the above conditions are met, and false otherwise.
isPartCached boolean isPartCached(java.lang.String[] parts)
Returns true if the parts referred to by the given array are cached, and those parts are mentioned in the JNLP file for the application. Parameters: parts - An array of part names. Returns: true if the above conditions are met, and false otherwise.
isExtensionPartCached boolean isExtensionPartCached(java.net.URL ref, java.lang.String version, java.lang.String part)
Returns true if the given part of the given extension is cached, and the extension and part are mentioned in the JNLP file for the application. Parameters: ref - The URL for the resource. version - The version string, or null for no version. part - The name of the part. Returns: true if the above conditions are met, and false otherwise.
isExtensionPartCached boolean isExtensionPartCached(java.net.URL ref, java.lang.String version, java.lang.String[] parts)
Returns true if the given parts of the given extension are cached, and the extension and parts are mentioned in the JNLP file for the application. Parameters: ref - The URL for the resource. version - The version string, or null for no version. parts - An array of part names. Returns: true if the above conditions are met, and false otherwise. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
loadResource void loadResource(java.net.URL ref, java.lang.String version, DownloadServiceListener progress) throws java.io.IOException
Downloads the given resource, if the resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or if the calling application has been granted all-permissions. This method will block until the download is completed or an exception occurs. Parameters: ref - The URL for the resource. version - The version string, or null for no version. progress - Download progress callback object. Throws: java.io.IOException
loadPart void loadPart(java.lang.String part, DownloadServiceListener progress) throws java.io.IOException
Downloads the given part, if the part is mentioned in the JNLP file for the application. This method will block until the download is completed or an exception occurs. Parameters: part - The name of the part. progress - Download progress callback object. Throws: java.io.IOException
loadPart void loadPart(java.lang.String[] parts, DownloadServiceListener progress) throws java.io.IOException
Downloads the given parts, if the parts are mentioned in the JNLP file for the application. This method will block until the download is completed or an exception occurs. Parameters: parts - An array of part names. progress - Download progress callback object. Throws: java.io.IOException
loadExtensionPart http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
void loadExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String part, DownloadServiceListener progress) throws java.io.IOException
Downloads the given part of the given extension, if the part and the extension are mentioned in the JNLP file for the application. This method will block until the download is completed or an exception occurs. Parameters: ref - The URL for the resource. version - The version string, or null for no version. part - The name of the part. progress - Download progress callback object. Throws: java.io.IOException
loadExtensionPart void loadExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String[] parts, DownloadServiceListener progress) throws java.io.IOException
Downloads the given parts of the given extension, if the parts and the extension are mentioned in the JNLP file for the application. This method will block until the download is completed or an exception occurs. Parameters: ref - The URL for the resource. version - The version string, or null for no version. parts - An array of part names to load. progress - Download progress callback object. Throws: java.io.IOException
removeResource void removeResource(java.net.URL ref, java.lang.String version) throws java.io.IOException
Removes the given resource from the cache, if the resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or if the calling application has been granted all-permissions. Parameters: ref - The URL for the resource. version - The version string, or null for no version. Throws: java.io.IOException
removePart http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
void removePart(java.lang.String part) throws java.io.IOException
Removes the given part from the cache, if the part is mentioned in the JNLP file for the application. Parameters: part - The name of the part. Throws: java.io.IOException
removePart void removePart(java.lang.String[] parts) throws java.io.IOException
Removes the given parts from the cache, if the parts are mentioned in the JNLP file for the application. Parameters: parts - An array of part names. Throws: java.io.IOException
removeExtensionPart void removeExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String part) throws java.io.IOException
Removes the given part of the given extension from the cache, if the part and the extension are mentioned in the JNLP file for the application. Parameters: ref - The URL for the resource. version - The version string, or null for no version. part - The name of the part. Throws: java.io.IOException
removeExtensionPart void removeExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String[] parts) throws java.io.IOException
Removes the given parts of the given extension from the cache, if the parts and the extension are mentioned in the JNLP file for the application. Parameters: ref - The URL for the resource. version - The version string, or null for no version. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
parts
- An array of part names.
Throws:
java.io.IOException
getDefaultProgressWindow DownloadServiceListener getDefaultProgressWindow()
Return a default DownloadServiceListener implementation which, when passed to a load method, should pop up and update a progress window as the load progresses. Returns: A DownloadServiceListener object representing a download progress listener. Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface DownloadServiceListener public interface DownloadServiceListener
The DownloadServiceListener provides an interface for a callback object implementation, which may be used by a DownloadService implementation. The DownloadServiceListener implementation's methods should be invoked by the DownloadService implementation at various stages of the download, allowing an application that uses the JNLP API to display a progress bar during a DownloadService download. Since: 1.0 See Also: DownloadService
Method Summary void
downloadFailed(java.net.URL url, java.lang.String version) A JNLP client's DownloadService implementation should call this method if a download fails or aborts
unexpectedly. void
progress(java.net.URL url, java.lang.String version, long readSoFar, long total, int overallPercent) A JNLP client's DownloadService implementation should call this method several times during a download.
void
upgradingArchive(java.net.URL url, java.lang.String version, int patchPercent, int overallPercent) A JNLP client's DownloadService implementation should call this method at least several times when applying
an incremental update to an in-cache resource. void
validating(java.net.URL url, java.lang.String version, long entry, long total, int overallPercent) A JNLP client's DownloadService implementation should call this method at least several times during
validation of a download.
Method Detail progress void progress(java.net.URL url, java.lang.String version, long readSoFar, long total, int overallPercent)
A JNLP client's DownloadService implementation should call this method several times during a download. A http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadServiceListener.html
DownloadServiceListener implementation may display a progress bar and / or update information based on the
parameters.
Parameters: url - The URL representing the resource being downloaded. version - The version of the resource being downloaded. readSoFar - The number of bytes downloaded so far. total - The total number of bytes to be downloaded, or -1 if the number is unknown. overallPercent - The percentage of the overall update operation that is complete, or -1 if the percentage is unknown.
validating void validating(java.net.URL url, java.lang.String version, long entry, long total, int overallPercent)
A JNLP client's DownloadService implementation should call this method at least several times during validation of a download. Validation often includes ensuring that downloaded resources are authentic (appropriately signed). A DownloadServiceListener implementation may display a progress bar and / or update information based on the parameters. Parameters: url - The URL representing the resource being validated. version - The version of the resource being validated. entry - The number of JAR entries validated so far. total - The total number of entries to be validated. overallPercent - The percentage of the overall update operation that is complete, or -1 if the percentage is unknown.
upgradingArchive void upgradingArchive(java.net.URL url, java.lang.String version, int patchPercent, int overallPercent)
A JNLP client's DownloadService implementation should call this method at least several times when applying an incremental update to an in-cache resource. A DownloadServiceListener implementation may display a progress bar and / or update information based on the parameters. Parameters: url - The URL representing the resource being patched. version - The version of the resource being patched. patchPercent - The percentage of the patch operation that is complete, or -1 if the percentage is unknown. overallPercent - The percentage of the overall update operation that is complete, or -1 if the percentage is unknown.
downloadFailed http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadServiceListener.html
void downloadFailed(java.net.URL url, java.lang.String version)
A JNLP client's DownloadService implementation should call this method if a download fails or aborts unexpectedly. In response, a DownloadServiceListener implementation may display update information to the user to reflect this.
Parameters: url - The URL representing the resource for which the download failed. version - The version of the resource for which the download failed.
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadServiceListener.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface ExtendedService public interface ExtendedService ExtendedService provides additional support to the current JNLP API, which allow applications to open a specific file in the
client's file system. Since: 1.5
Method Summary FileContents
openFile(java.io.File file)
Asks the user the permission to open the specified file if the file has not been opened before. FileContents []
openFiles(java.io.File[] files)
Asks the user the permission to open the specified list of files if any of the files has not been opened before.
Method Detail openFile FileContents openFile(java.io.File file) throws java.io.IOException
Asks the user the permission to open the specified file if the file has not been opened before. The contents of the file is returned as a FileContents object. The returned FileContents object contains the contents the file. Parameters: file - the file object Returns: A FileContent object with information about the opened file Throws: java.io.IOException - - if there is any I/O error
openFiles FileContents[] openFiles(java.io.File[] files) throws java.io.IOException
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtendedService.html
Asks the user the permission to open the specified list of files if any of the files has not been opened before. The contents of each file is returned as a FileContents object in the FileContents array. The returned FileContents object contains the contents the file. Parameters: files - the array of files Returns: A FileContent[] object with information about each opened file Throws: java.io.IOException - - if there is any I/O error Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtendedService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface ExtensionInstallerService public interface ExtensionInstallerService
The ExtensionInstallerService is used by an extension installer to communicate with the JNLP Client. It provides the following type of functionality:
Access to prefered installation location, and other information about the JNLP Client Manipulation of the JNLP Client's download screen Methods for updating the JNLP Client with the installed code
The normal sequence of events for an installer is: 1. 2. 3. 4.
Get service using ServiceManager.lookup("javax.jnlp.ExtensionInstallerService"). Update status, heading, and progress as install progresses (setStatus, setHeading and updateProgress). Invoke either setJREInfo or setNativeLibraryInfo depending on if a JRE or a library is installed If successful invoke installSucceeded, otherwise invoke installFailed.
Since: 1.0
Method Summary java.net.URL
getExtensionLocation()
Returns the location of the extension being installed java.lang.String
getExtensionVersion()
Returns the version of the extension being installed java.lang.String
getInstalledJRE(java.net.URL url, java.lang.String version)
Returns the path to the executable for the given JRE. java.lang.String
getInstallPath()
Returns the directory where the installer is recommended to install the extension in. void
hideProgressBar()
Hides the progress bar. void
hideStatusWindow()
Hides the status window. void
installFailed()
This should be invoked if the install fails. void
installSucceeded(boolean needsReboot)
Installers should invoke this upon a succesful installation of the extension. void
setHeading(java.lang.String heading)
Updates the status of the installer process. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtensionInstallerService.html
void
setJREInfo(java.lang.String platformVersion, java.lang.String jrePath)
Informs the JNLP Client of the path to the executable for the JRE, if this is an installer for a JRE, and about platform-version this JRE implements. void
setNativeLibraryInfo(java.lang.String path)
Informs the JNLP Client of a directory where it should search for native libraries. void
setStatus(java.lang.String status)
Updates the status of the installer process. void
updateProgress(int value)
Updates the progress bar.
Method Detail getInstallPath java.lang.String getInstallPath()
Returns the directory where the installer is recommended to install the extension in. It is not required that the installer install in this directory, this is merely a suggested path.
getExtensionVersion java.lang.String getExtensionVersion()
Returns the version of the extension being installed
getExtensionLocation java.net.URL getExtensionLocation()
Returns the location of the extension being installed
hideProgressBar void hideProgressBar()
Hides the progress bar. Any subsequent calls to updateProgress will force it to be visible.
hideStatusWindow void hideStatusWindow()
Hides the status window. You should only invoke this if you are going to provide your own feedback to the user as to the progress of the install.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtensionInstallerService.html
setHeading void setHeading(java.lang.String heading)
Updates the status of the installer process.
setStatus void setStatus(java.lang.String status)
Updates the status of the installer process.
updateProgress void updateProgress(int value)
Updates the progress bar. Parameters: value - progress bar value - should be between 0 and 100.
installSucceeded void installSucceeded(boolean needsReboot)
Installers should invoke this upon a succesful installation of the extension. This will cause the JNLP Client to regain control and continue its normal operation. Parameters: needsReboot
- If true, a reboot is needed
installFailed void installFailed()
This should be invoked if the install fails. The JNLP Client will continue its operation, and inform the user that the install has failed.
setJREInfo void setJREInfo(java.lang.String platformVersion, java.lang.String jrePath)
Informs the JNLP Client of the path to the executable for the JRE, if this is an installer for a JRE, and about platformversion this JRE implements.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtensionInstallerService.html
setNativeLibraryInfo void setNativeLibraryInfo(java.lang.String path)
Informs the JNLP Client of a directory where it should search for native libraries.
getInstalledJRE java.lang.String getInstalledJRE(java.net.URL url, java.lang.String version)
Returns the path to the executable for the given JRE. This method can be used by extensions that needs to find information in a given JRE, or enhance a given JRE. Parameters: url - product location of the JRE version - product version of the JRE Returns: The path to the executable for the given JRE, or null if the JRE is not installed. Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtensionInstallerService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface FileContents public interface FileContents FileContents objects encapsulate the name and contents of a file. An implementation of this class is used by the FileOpenService, FileSaveService, and PersistenceService .
The FileContents implementation returned by PersistenceService.get(java.net.URL), FileOpenService, and FileSaveService should never truncate a file if the maximum file length is set to be less that the current file length. Since: 1.0 See Also: FileOpenService, FileSaveService
Method Summary boolean
canRead()
Returns whether the file can be read. boolean
canWrite()
Returns whether the file can be written to. java.io.InputStream
long
getInputStream() Gets an InputStream from the file. getLength()
Gets the length of the file. long
getMaxLength()
Gets the maximum file length for the file, as set by the creator of this object. java.lang.String
getName()
Gets the file name as a String. java.io.OutputStream
getOutputStream(boolean overwrite) Gets an OutputStream to the file.
JNLPRandomAccessFile
getRandomAccessFile(java.lang.String mode) Returns a JNLPRandomAccessFile representing a random access interface to the file's contents.
long
setMaxLength(long maxlength)
Sets the maximum file length for the file.
Method Detail getName http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileContents.html
java.lang.String getName() throws java.io.IOException
Gets the file name as a String. Returns: a string containing the file name. Throws: java.io.IOException - if an I/O exception occurs.
getInputStream java.io.InputStream getInputStream() throws java.io.IOException
Gets an InputStream from the file. Returns: an InputStream to the file. Throws: java.io.IOException - if an I/O exception occurs.
getOutputStream java.io.OutputStream getOutputStream(boolean overwrite) throws java.io.IOException
Gets an OutputStream to the file. A JNLP client may implement this interface to return an OutputStream subclass which restricts the amount of data that can be written to the stream. Returns: an OutputStream from the file. Throws: java.io.IOException - if an I/O exception occurs.
getLength long getLength() throws java.io.IOException
Gets the length of the file. Returns: the length of the file as a long. Throws: java.io.IOException - if an I/O exception occurs.
canRead http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileContents.html
boolean canRead() throws java.io.IOException
Returns whether the file can be read. Returns: true if the file can be read, false otherwise. Throws: java.io.IOException - if an I/O exception occurs.
canWrite boolean canWrite() throws java.io.IOException
Returns whether the file can be written to. Returns: true if the file can be read, false otherwise. Throws: java.io.IOException - if an I/O exception occurs.
getRandomAccessFile JNLPRandomAccessFile getRandomAccessFile(java.lang.String mode) throws java.io.IOException
Returns a JNLPRandomAccessFile representing a random access interface to the file's contents. The mode argument must either be equal to "r" or "rw", indicating the file is to be opened for input only or for both input and output, respectively. An IllegalArgumentException will be thrown if the mode is not equal to "r" or "rw". Parameters: mode - the access mode. Returns: a JNLPRandomAccessFile. Throws: java.io.IOException - if an I/O exception occurs.
getMaxLength long getMaxLength() throws java.io.IOException
Gets the maximum file length for the file, as set by the creator of this object. Returns: the maximum length of the file. Throws: java.io.IOException - if an I/O exception occurs.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileContents.html
setMaxLength long setMaxLength(long maxlength) throws java.io.IOException
Sets the maximum file length for the file. A JNLP client may enforce restrictions on setting the maximum file length. A JNLP client should not truncate a file if the maximum file length is set that is less than the current file size, but it also should not allow further writes to that file. Parameters:
maxlength - the requested new maximum file length. Returns: the maximum file length that was granted. Throws: java.io.IOException - if an I/O exception occurs.
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileContents.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface FileOpenService public interface FileOpenService FileOpenService service allows the user to choose a file from the local file system, even for applications that are running in
the untrusted execution environment. The JNLP Client is the mediator and is therefore responsible for providing the specific implementation of this, if any. This service provides a similar function as the file input field for HTML-based forms. Since: 1.0 See Also: FileSaveService, FileContents
Method Summary FileContents
openFileDialog(java.lang.String pathHint, java.lang.String[] extensions)
Asks the user to choose a single file. FileContents []
openMultiFileDialog(java.lang.String pathHint, java.lang.String[] extensions)
Asks the user to choose one or more files.
Method Detail openFileDialog FileContents openFileDialog(java.lang.String pathHint, java.lang.String[] extensions) throws java.io.IOException
Asks the user to choose a single file. The contents of a potential selected file is returned as a FileContents object. The returned FileContents object contains the contents along with the name of the file. The full path is not returned. Parameters: - A hint from the application to the initial directory for the file chooser. This might be ignored by the JNLP Client. extensions - A list of default extensions to show in the file chooser. For example, String[] { "txt", "java" }. This might be ignored by the JNLP Client. Returns: A FileContent object with information about the chosen file, or null if the user did not choose a file. Throws: IOException - if the request failed in any way other than the user did not choose to select a file. pathHint
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileOpenService.html
java.io.IOException
openMultiFileDialog FileContents[] openMultiFileDialog(java.lang.String pathHint, java.lang.String[] extensions) throws java.io.IOException
Asks the user to choose one or more files. Otherwise similar to openFileDialog(java.lang.String, java.lang.String[])
Throws: java.io.IOException
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileOpenService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface FileSaveService public interface FileSaveService FileSaveService service allows the user to save a file to the local file system, even for applications that are running in the
untrusted execution environment. The JNLP Client is the mediator and is therefore responsible for providing the specific implementation of this, if any. This service provides similar functionatlity as the Save as... functionality provided by most browsers. Since: 1.0 See Also: FileOpenService, FileContents
Method Summary FileContents
saveAsFileDialog(java.lang.String pathHint, java.lang.String[] extensions, FileContents contents)
Asks the users to save a file. FileContents
saveFileDialog(java.lang.String pathHint, java.lang.String[] extensions, java.io.InputStream stream, java.lang.String name)
Asks the users to save a file.
Method Detail saveFileDialog FileContents saveFileDialog(java.lang.String pathHint, java.lang.String[] extensions, java.io.InputStream stream, java.lang.String name) throws java.io.IOException
Asks the users to save a file. Parameters: pathHint
- A hint from the application to the default directory to be used. This might be ignored by the JNLP
Client.
extensions - A list of default extensions to show in the file chooser. For example, String[] { "txt", "java" }. These might be ignored by the JNLP Client. stream - The content of the file to save along represented as an InputStream name - The suggested filename, which might be ignored by the JNLP client
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileSaveService.html
Returns: A FileContents object for the saved file if the save was successfully, or null if the user canceled the request. Throws: IOException - if the requested failed in any way other than the user chose not to save the file java.io.IOException
saveAsFileDialog FileContents saveAsFileDialog(java.lang.String pathHint, java.lang.String[] extensions, FileContents contents) throws java.io.IOException
Asks the users to save a file. Parameters: pathHint
- A hint from the application to the default directory to be used. This might be ignored by the JNLP
Client.
extensions - A list of default extensions to show in the file chooser. For example, String[] { "txt", "java" }. These might be ignored by the JNLP Client. contents - The content of the file to save along with the suggested filename. The suggested filename might be
ignored by the JNLP Client. Returns: A FileContents object for the saved file if the save was successfully, or null if the user canceled the request. Throws: IOException - if the requested failed in any way other than the user chose not to save the file java.io.IOException
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileSaveService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface JNLPRandomAccessFile All Superinterfaces: java.io.DataInput, java.io.DataOutput
public interface JNLPRandomAccessFile extends java.io.DataInput, java.io.DataOutput
Instances of this class support both reading and writing to a random access file. A random access file behaves like a large array of bytes stored in the file system. There is a kind of cursor, or index into the implied array, called the file pointer; input operations read bytes starting at the file pointer and advance the file pointer past the bytes read. If the random access file is created in read/write mode, then output operations are also available; output operations write bytes starting at the file pointer and advance the file pointer past the bytes written. Output operations that write past the current end of the implied array cause the array to be extended. The file pointer can be read by the getFilePointer method and set by the seek method.
It is generally true of all the reading routines in this class that if end-of-file is reached before the desired number of bytes has been read, an EOFException (which is a kind of IOException) is thrown. If any byte cannot be read for any reason other than end-of-file, an IOException other than EOFException is thrown. In particular, an IOException may be thrown if the stream has been closed.
Implementations are encouraged to enforce a maximum amount of data that may be written to a file. Since: 1.0
Method Summary void
close()
Closes this random access file stream and releases any system resources associated with the stream. long
getFilePointer()
Returns the current offset in this file. long
length()
Returns the length of this file. int
read()
Reads a byte of data from this file. int
read(byte[] b)
Reads up to b.length bytes of data from this file into an array of bytes. int
boolean
byte
read(byte[] b, int off, int len) Reads up to len bytes of data from this file into an array of bytes. readBoolean() Reads a boolean from this file. readByte()
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Reads a signed eight-bit value from this file. char
readChar()
Reads a Unicode character from this file. double
float
readDouble() Reads a double from this file. readFloat()
Reads a float from this file. void
readFully(byte[] b) Reads b.length bytes from this file into the byte array, starting at the current file pointer.
void
readFully(byte[] b, int off, int len) Reads exactly len bytes from this file into the byte array, starting at the current file pointer.
int
readInt()
Reads a signed 32-bit integer from this file. java.lang.String
readLine()
Reads the next line of text from this file. long
readLong()
Reads a signed 64-bit integer from this file. short
readShort()
Reads a signed 16-bit number from this file. int
readUnsignedByte()
Reads an unsigned eight-bit number from this file. int
readUnsignedShort()
Reads an unsigned 16-bit number from this file. java.lang.String
readUTF()
Reads in a string from this file. void
seek(long pos)
Sets the file-pointer offset, measured from the beginning of this file, at which the next read or write occurs. void
setLength(long newLength)
Sets the length of this file. int
skipBytes(int n)
Attempts to skip over n bytes of input discarding the skipped bytes. void
write(byte[] b) Writes b.length bytes from the specified byte array to this file, starting at the current file pointer.
void
write(byte[] b, int off, int len) Writes len bytes from the specified byte array starting at offset off to this file.
void
write(int b)
Writes the specified byte to this file. void
writeBoolean(boolean v) Writes a boolean to the file as a one-byte value.
void
writeByte(int v) Writes a byte to the file as a one-byte value.
void
writeBytes(java.lang.String s)
Writes the string to the file as a sequence of bytes. void
writeChar(int v) Writes a char to the file as a two-byte value, high byte first.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
void
writeChars(java.lang.String s)
Writes a string to the file as a sequence of characters. void
writeDouble(double v)
Converts the double argument to a long using the doubleToLongBits method in class Double, and then writes that long value to the file as an eight-byte quantity, high byte first. void
writeFloat(float v)
Converts the float argument to an int using the floatToIntBits method in class Float, and then writes that int value to the file as a four-byte quantity, high byte first. void
writeInt(int v) Writes an int to the file as four bytes, high byte first.
void
writeLong(long v) Writes a long to the file as eight bytes, high byte first.
void
writeShort(int v) Writes a short to the file as two bytes, high byte first.
void
writeUTF(java.lang.String str)
Writes a string to the file using UTF-8 encoding in a machine-independent manner.
Method Detail close void close() throws java.io.IOException
Closes this random access file stream and releases any system resources associated with the stream. A closed random access file cannot perform input or output operations and cannot be reopened. Throws: java.io.IOException
- if an I/O error occurs.
length long length() throws java.io.IOException
Returns the length of this file. Returns: the length of this file, measured in bytes. Throws: java.io.IOException - if an I/O error occurs.
getFilePointer long getFilePointer() throws java.io.IOException
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Returns the current offset in this file. Returns: the offset from the beginning of the file, in bytes, at which the next read or write occurs. Throws: java.io.IOException - if an I/O error occurs.
read int read() throws java.io.IOException
Reads a byte of data from this file. The byte is returned as an integer in the range 0 to 255 (0x00-0x0ff). This method blocks if no input is yet available. Although JNLPRandomAccessFile is not a subclass of InputStream, this method behaves in exactly the same way as the read method of InputStream. Returns: the next byte of data, or -1 if the end of the file has been reached. Throws: java.io.IOException - if an I/O error occurs. Not thrown if end-of-file has been reached.
read int read(byte[] b, int off, int len) throws java.io.IOException
Reads up to len bytes of data from this file into an array of bytes. This method blocks until at least one byte of input is available. Although JNLPRandomAccessFile is not a subclass of InputStream, this method behaves in the exactly the same way as the read(byte[], int, int) method of InputStream. Parameters: b - the buffer into which the data is read. off - the start offset of the data. len - the maximum number of bytes read. Returns: the total number of bytes read into the buffer, or -1 if there is no more data because the end of the file has been reached. Throws: java.io.IOException - if an I/O error occurs.
read int read(byte[] b) throws java.io.IOException
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Reads up to b.length bytes of data from this file into an array of bytes. This method blocks until at least one byte of input is available. Although JNLPRandomAccessFile is not a subclass of InputStream, this method behaves in the exactly the same way as the read(byte[]) method of InputStream. Parameters: b - the buffer into which the data is read. Returns: the total number of bytes read into the buffer, or -1 if there is no more data because the end of this file has been reached. Throws: java.io.IOException - if an I/O error occurs.
readFully void readFully(byte[] b) throws java.io.IOException
Reads b.length bytes from this file into the byte array, starting at the current file pointer. This method reads repeatedly from the file until the requested number of bytes are read. This method blocks until the requested number of bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readFully in interface java.io.DataInput
Parameters: b - the buffer into which the data is read. Throws: EOFException - if this file reaches the end before reading all the bytes. java.io.IOException - if an I/O error occurs.
readFully void readFully(byte[] b, int off, int len) throws java.io.IOException
Reads exactly len bytes from this file into the byte array, starting at the current file pointer. This method reads repeatedly from the file until the requested number of bytes are read. This method blocks until the requested number of bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readFully in interface java.io.DataInput Parameters: b - the buffer into which the data is read. off - the start offset of the data. len - the number of bytes to read. Throws: EOFException - if this file reaches the end before reading all the bytes. java.io.IOException - if an I/O error occurs.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
skipBytes int skipBytes(int n) throws java.io.IOException
Attempts to skip over n bytes of input discarding the skipped bytes. This method may skip over some smaller number of bytes, possibly zero. This may result from any of a number of conditions; reaching end of file before n bytes have been skipped is only one possibility. This method never throws an EOFException. The actual number of bytes skipped is returned. If n is negative, no bytes are skipped. Specified by: skipBytes in interface java.io.DataInput Parameters: n - the number of bytes to be skipped. Returns: the actual number of bytes skipped. Throws: java.io.IOException - if an I/O error occurs.
readBoolean boolean readBoolean() throws java.io.IOException
Reads a boolean from this file. This method reads a single byte from the file, starting at the current file pointer. A value of 0 represents false. Any other value represents true. This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown. Specified by: readBoolean in interface java.io.DataInput Returns: the boolean value read. Throws: EOFException - if this file has reached the end. java.io.IOException - if an I/O error occurs.
readByte byte readByte() throws java.io.IOException
Reads a signed eight-bit value from this file. This method reads a byte from the file, starting from the current file pointer. If the byte read is b, where 0 <= b <= 255, then the result is: (byte)(b)
This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown. Specified by: readByte in interface java.io.DataInput
Returns:
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
the next byte of this file as a signed eight-bit byte. Throws: EOFException - if this file has reached the end. java.io.IOException - if an I/O error occurs.
readUnsignedByte int readUnsignedByte() throws java.io.IOException
Reads an unsigned eight-bit number from this file. This method reads a byte from this file, starting at the current file pointer, and returns that byte. This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown. Specified by: readUnsignedByte in interface java.io.DataInput Returns: the next byte of this file, interpreted as an unsigned eight-bit number. Throws: EOFException - if this file has reached the end. java.io.IOException - if an I/O error occurs.
readShort short readShort() throws java.io.IOException
Reads a signed 16-bit number from this file. The method reads two bytes from this file, starting at the current file pointer. If the two bytes read, in order, are b1 and b2, where each of the two values is between 0 and 255, inclusive, then the result is equal to: (short)((b1 << 8) | b2)
This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readShort in interface java.io.DataInput Returns: the next two bytes of this file, interpreted as a signed 16-bit number. Throws: EOFException - if this file reaches the end before reading two bytes. java.io.IOException - if an I/O error occurs.
readUnsignedShort int readUnsignedShort() throws java.io.IOException
Reads an unsigned 16-bit number from this file. This method reads two bytes from the file, starting at the current file http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
pointer. If the bytes read, in order, are b1 and b2, where 0 <= b1, b2 <= 255, then the result is equal to: (b1 << 8) | b2
This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readUnsignedShort in interface java.io.DataInput Returns: the next two bytes of this file, interpreted as an unsigned 16-bit integer. Throws: EOFException - if this file reaches the end before reading two bytes. java.io.IOException - if an I/O error occurs.
readChar char readChar() throws java.io.IOException
Reads a Unicode character from this file. This method reads two bytes from the file, starting at the current file pointer. If the bytes read, in order, are b1 and b2, where 0 <= b1, b2 <= 255, then the result is equal to: (char)((b1 << 8) | b2)
This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readChar in interface java.io.DataInput
Returns: the next two bytes of this file as a Unicode character. Throws: EOFException - if this file reaches the end before reading two bytes. java.io.IOException - if an I/O error occurs.
readInt int readInt() throws java.io.IOException
Reads a signed 32-bit integer from this file. This method reads 4 bytes from the file, starting at the current file pointer. If the bytes read, in order, are b1, b2, b3, and b4, where 0 <= b1, b2, b3, b4 <= 255, then the result is equal to: (b1 << 24) | (b2 << 16) + (b3 << 8) + b4
This method blocks until the four bytes are read, the end of the stream is detected, or an exception is thrown. Specified by:
readInt in interface java.io.DataInput Returns: the next four bytes of this file, interpreted as an int.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Throws: EOFException - if this file reaches the end before reading four bytes. java.io.IOException - if an I/O error occurs.
readLong long readLong() throws java.io.IOException
Reads a signed 64-bit integer from this file. This method reads eight bytes from the file, starting at the current file pointer. If the bytes read, in order, are b1, b2, b3, b4, b5, b6, b7, and b8, where: 0 <= b1, b2, b3, b4, b5, b6, b7, b8 <=255,
then the result is equal to: ((long)b1 << 56) + ((long)b2 << 48) + ((long)b3 << 40) + ((long)b4 << 32) + ((long)b5 << 24) + ((long)b6 << 16) + ((long)b7 << 8) + b8
This method blocks until the eight bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readLong in interface java.io.DataInput
Returns: the next eight bytes of this file, interpreted as a long. Throws: EOFException - if this file reaches the end before reading eight bytes. java.io.IOException - if an I/O error occurs.
readFloat float readFloat() throws java.io.IOException
Reads a float from this file. This method reads an int value, starting at the current file pointer, as if by the readInt method and then converts that int to a float using the intBitsToFloat method in class Float. This method blocks until the four bytes are read, the end of the stream is detected, or an exception is thrown. Specified by:
readFloat in interface java.io.DataInput Returns: the next four bytes of this file, interpreted as a float. Throws: EOFException - if this file reaches the end before reading four bytes. java.io.IOException - if an I/O error occurs. See Also: readInt()
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
readDouble double readDouble() throws java.io.IOException
Reads a double from this file. This method reads a long value, starting at the current file pointer, as if by the readLong method and then converts that long to a double using the longBitsToDouble method in class Double. This method blocks until the eight bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readDouble in interface java.io.DataInput
Returns: the next eight bytes of this file, interpreted as a double. Throws: EOFException - if this file reaches the end before reading eight bytes. java.io.IOException - if an I/O error occurs. See Also: readLong()
readLine java.lang.String readLine() throws java.io.IOException
Reads the next line of text from this file. This method successively reads bytes from the file, starting at the current file pointer, until it reaches a line terminator or the end of the file. Each byte is converted into a character by taking the byte's value for the lower eight bits of the character and setting the high eight bits of the character to zero. This method does not, therefore, support the full Unicode character set. A line of text is terminated by a carriage-return character ('\r'), a newline character ('\n'), a carriage-return character immediately followed by a newline character, or the end of the file. Line-terminating characters are discarded and are not included as part of the string returned. This method blocks until a newline character is read, a carriage return and the byte following it are read (to see if it is a newline), the end of the file is reached, or an exception is thrown. Specified by: readLine in interface java.io.DataInput Returns: the next line of text from this file, or null if end of file is encountered before even one byte is read. Throws: java.io.IOException - if an I/O error occurs.
readUTF java.lang.String readUTF() throws java.io.IOException
Reads in a string from this file. The string has been encoded using a modified UTF-8 format. The first two bytes are read, starting from the current file pointer, as if by readUnsignedShort. This value gives the number of following bytes that are in the encoded string, not the length of the resulting string. The following bytes are http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
then interpreted as bytes encoding characters in the UTF-8 format and are converted into characters. This method blocks until all the bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readUTF in interface java.io.DataInput
Returns: a Unicode string. Throws: EOFException - if this file reaches the end before reading all the bytes. java.io.IOException - if an I/O error occurs. UTFDataFormatException - if the bytes do not represent valid UTF-8 encoding of a Unicode string. See Also: readUnsignedShort()
seek
void seek(long pos) throws java.io.IOException
Sets the file-pointer offset, measured from the beginning of this file, at which the next read or write occurs. The offset may be set beyond the end of the file. Setting the offset beyond the end of the file does not change the file length. The file length will change only by writing after the offset has been set beyond the end of the file. Parameters: pos - the offset position, measured in bytes from the beginning of the file, at which to set the file pointer. Throws: java.io.IOException - if pos is less than 0 or if an I/O error occurs.
setLength void setLength(long newLength) throws java.io.IOException
Sets the length of this file. If the present length of the file as returned by the length method is greater than the newLength argument then the file will be truncated. In this case, if the file offset as returned by the getFilePointer method is greater then newLength then after this method returns the offset will be equal to newLength. If the present length of the file as returned by the length method is smaller than the newLength argument then the file will be extended. In this case, the contents of the extended portion of the file are not defined. Parameters: newLength
- The desired length of the file
Throws:
java.io.IOException
- If an I/O error occurs
write void write(int b)
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
throws java.io.IOException
Writes the specified byte to this file. The write starts at the current file pointer. Specified by: write in interface java.io.DataOutput Parameters: b - the byte to be written. Throws: java.io.IOException - if an I/O error occurs.
write void write(byte[] b) throws java.io.IOException
Writes b.length bytes from the specified byte array to this file, starting at the current file pointer. Specified by: write in interface java.io.DataOutput Parameters: b - the data. Throws: java.io.IOException - if an I/O error occurs.
write void write(byte[] b, int off, int len) throws java.io.IOException
Writes len bytes from the specified byte array starting at offset off to this file. Specified by: write in interface java.io.DataOutput Parameters: b - the data. off - the start offset in the data. len - the number of bytes to write. Throws: java.io.IOException - if an I/O error occurs.
writeBoolean void writeBoolean(boolean v) throws java.io.IOException
Writes a boolean to the file as a one-byte value. The value true is written out as the value (byte)1; the value false is written out as the value (byte)0. The write starts at the current position of the file pointer. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Specified by: writeBoolean in interface java.io.DataOutput Parameters: v - a boolean value to be written. Throws: java.io.IOException - if an I/O error occurs.
writeByte void writeByte(int v) throws java.io.IOException
Writes a byte to the file as a one-byte value. The write starts at the current position of the file pointer. Specified by: writeByte in interface java.io.DataOutput
Parameters: v - a byte value to be written. Throws: java.io.IOException - if an I/O error occurs.
writeShort void writeShort(int v) throws java.io.IOException
Writes a short to the file as two bytes, high byte first. The write starts at the current position of the file pointer. Specified by: writeShort in interface java.io.DataOutput
Parameters: v - a short to be written. Throws: java.io.IOException - if an I/O error occurs.
writeChar void writeChar(int v) throws java.io.IOException
Writes a char to the file as a two-byte value, high byte first. The write starts at the current position of the file pointer. Specified by: writeChar in interface java.io.DataOutput
Parameters: v - a char value to be written. Throws: java.io.IOException - if an I/O error occurs.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
writeInt void writeInt(int v) throws java.io.IOException
Writes an int to the file as four bytes, high byte first. The write starts at the current position of the file pointer. Specified by: writeInt in interface java.io.DataOutput Parameters: v - an int to be written. Throws: java.io.IOException - if an I/O error occurs.
writeLong void writeLong(long v) throws java.io.IOException
Writes a long to the file as eight bytes, high byte first. The write starts at the current position of the file pointer. Specified by: writeLong in interface java.io.DataOutput Parameters: v - a long to be written. Throws: java.io.IOException - if an I/O error occurs.
writeFloat void writeFloat(float v) throws java.io.IOException
Converts the float argument to an int using the floatToIntBits method in class Float, and then writes that int value to the file as a four-byte quantity, high byte first. The write starts at the current position of the file pointer. Specified by: writeFloat in interface java.io.DataOutput
Parameters: v - a float value to be written. Throws: java.io.IOException - if an I/O error occurs.
writeDouble void writeDouble(double v) throws java.io.IOException
Converts the double argument to a long using the doubleToLongBits method in class Double, and then writes that long value to the file as an eight-byte quantity, high byte first. The write starts at the current position of the file pointer. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Specified by: writeDouble in interface java.io.DataOutput Parameters: v - a double value to be written. Throws: java.io.IOException - if an I/O error occurs.
writeBytes void writeBytes(java.lang.String s) throws java.io.IOException
Writes the string to the file as a sequence of bytes. Each character in the string is written out, in sequence, by discarding its high eight bits. The write starts at the current position of the file pointer. Specified by: writeBytes in interface java.io.DataOutput Parameters: s - a string of bytes to be written. Throws: java.io.IOException - if an I/O error occurs.
writeChars void writeChars(java.lang.String s) throws java.io.IOException
Writes a string to the file as a sequence of characters. Each character is written to the data output stream as if by the writeChar method. The write starts at the current position of the file pointer. Specified by:
writeChars in interface java.io.DataOutput Parameters: s - a String value to be written. Throws: java.io.IOException - if an I/O error occurs. See Also: writeChar(int)
writeUTF void writeUTF(java.lang.String str) throws java.io.IOException
Writes a string to the file using UTF-8 encoding in a machine-independent manner. First, two bytes are written to the file, starting at the current file pointer, as if by the writeShort method giving the number of bytes to follow. This value is the number of bytes actually written out, not the length of the string. Following the length, each character of the string is output, in sequence, using the UTF-8 encoding for each character. Specified by: http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
writeUTF in interface java.io.DataOutput
Parameters: str - a string to be written. Throws: java.io.IOException - if an I/O error occurs. Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface PersistenceService public interface PersistenceService PersistenceService provides methods for storing data locally on the client system, even for applications that are running in
the untrusted execution environment. The service is somewhat similar to that which the cookie mechanism provides to HTMLbased applications. Each entry in the persistence data store is named with a URL. This provides a similar hierarchical structure as a traditional file system. An application is only allowed to access data stored with a URL that is based on its codebase. For example, given the codebase http://www.mysite.com/apps/App1/, the application would be allowed to access the data at the associated URLs:
http://www.mysite.com/apps/App1/ http://www.mysite.com/apps/ http://www.mysite.com/
This scheme allows sharing of data between different applications from the same host. For example, if another application is located at http://www.mysite.com/apps/App2/, then they can share data between them in the http://www.mysite.com/ and http://www.mysite.com/apps/ directories. A JNLP client should track the amount of storage that a given application uses. A PersistenceService implementation provides methods to get the current storage usage and limits and to request more storage. Storage is allocated on a per file basis, but a JNLP Client will typically grant or deny the request based on the total storage is use by an application.
Data stored using this mechanism is intended to be a local copy of data stored on a remote server. The individual entries can be tagged as either cached, meaning the server has an up-to-date copy, dirty, meaning the server does not have an up-to-date copy, or temporary, meaning that the file can always be recreated. Since: 1.0
Field Summary static int
CACHED
static int
DIRTY
static int
TEMPORARY
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PersistenceService.html
Method Summary long
create(java.net.URL url, long maxsize)
Creates a new persistent storage entry on the client side named with the given URL. void
delete(java.net.URL url)
Removes the stream associated with the given URL from the client-side date persistence store. FileContents
java.lang.String [] int
get(java.net.URL url) Returns a FileContents object representing the contents of this file. getNames(java.net.URL url)
Returns an array of Strings containing the names of all the entries for a given URL. getTag(java.net.URL url) Returns an int corresponding to the current value of the tag for the persistent data store entry
associated with the given URL. void
setTag(java.net.URL url, int tag)
Tags the persistent data store entry associated with the given URL with the given tag value.
Field Detail CACHED static final int CACHED
See Also: Constant Field Values
TEMPORARY static final int TEMPORARY
See Also: Constant Field Values
DIRTY static final int DIRTY
See Also: Constant Field Values
Method Detail create long create(java.net.URL url, long maxsize) throws java.net.MalformedURLException, java.io.IOException
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PersistenceService.html
Creates a new persistent storage entry on the client side named with the given URL. Parameters: url - the URL representing the name of the entry in the persistent data store. maxsize - maximum size of storage that can be written to this entry. Returns: the maximum size of storage that got granted, in bytes. Throws: java.net.MalformedURLException - if the application is denied access to the persistent data store represented by the given URL. java.io.IOException - if an I/O exception occurs, or the entry already exists.
get FileContents get(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException, java.io.FileNotFoundException
Returns a FileContents object representing the contents of this file. Parameters: url - the URL representing the persistent data store entry. Returns: the file contents as a FileContents. Throws: java.io.IOException - if an I/O error occurs. java.net.MalformedURLException - if the application is denied access to the persistent data store represented by the given URL. java.io.FileNotFoundException - if a persistence store for the given URL is not found.
delete void delete(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException
Removes the stream associated with the given URL from the client-side date persistence store. Parameters: url - the URL representing the entry to delete from the persistent data store. Throws: java.net.MalformedURLException - if the application is denied access to the persistent data store represented by the given URL. java.io.IOException - if an I/O exception occurs.
getNames java.lang.String[] getNames(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PersistenceService.html
Returns an array of Strings containing the names of all the entries for a given URL. Parameters: url - the URL representing the root directory to search for entry names. Returns: a String array containing the entries names. Throws: java.net.MalformedURLException - if the application is denied access to the persistent data store represented by the given URL. java.io.IOException - if an I/O exception occurs.
getTag int getTag(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException
Returns an int corresponding to the current value of the tag for the persistent data store entry associated with the given URL. Parameters: url - the URL representing the persistent data store entry for which the tag value is requested. Returns: an int containing one of the following tag values:
Throws:
CACHED TEMPORARY DIRTY
java.net.MalformedURLException
by the given URL. java.io.IOException
- if the application is denied access to the persistent data store represented
- if an I/O exception occurs.
setTag void setTag(java.net.URL url, int tag) throws java.net.MalformedURLException, java.io.IOException
Tags the persistent data store entry associated with the given URL with the given tag value. Parameters: url - the URL representing the persistent data store entry for which to set the tag value. tag - the tag value to set. Throws: java.net.MalformedURLException - if the application is denied access to the persistent data store represented by the given URL. java.io.IOException - if an I/O exception occurs. Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PersistenceService.html
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PersistenceService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface PrintService public interface PrintService PrintService provides methods for access to printing functions, even for applications that are running in the untrusted
execution environment. Using this service, an application can submit a print job to the JNLP client. The client can then display this request to the user, and if accepted, queue the request to the printer. Since: 1.0
Method Summary java.awt.print.PageFormat
getDefaultPage()
Creates a new PageFormat instance and sets it to the default size and orientation. boolean
print(java.awt.print.Pageable document) Prints a document using the given Pageable object
boolean
print(java.awt.print.Printable painter) Prints a document using the given Printable object
java.awt.print.PageFormat
showPageFormatDialog(java.awt.print.PageFormat page) Displays a dialog that allows modification of a PageFormat instance.
Method Detail getDefaultPage java.awt.print.PageFormat getDefaultPage()
Creates a new PageFormat instance and sets it to the default size and orientation. Returns: a PageFormat set to the default size and orientation.
showPageFormatDialog java.awt.print.PageFormat showPageFormatDialog(java.awt.print.PageFormat page)
Displays a dialog that allows modification of a PageFormat instance. The page argument is used to initialize controls in the page setup dialog. If the user cancels the dialog then this method returns the original page object unmodified. If the http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PrintService.html
user okays the dialog then this method returns a new PageFormat object with the indicated changes. In either case, the original page object is not modified.
Parameters: page - the default PageFormat presented to the user for modification. Returns: the original page object if the dialog is cancelled; a new PageFormat object containing the format indicated by the user if the dialog is acknowledged.
print boolean print(java.awt.print.Pageable document)
Prints a document using the given Pageable object Parameters: document
- the pages to be printed. It can not be null.
Returns:
true if printing was successfull, false otherwise.
print boolean print(java.awt.print.Printable painter)
Prints a document using the given Printable object Parameters: painter
Returns:
- the Printable called to render each page of the document.
true if printing was successfull, false otherwise.
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PrintService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface ServiceManagerStub public interface ServiceManagerStub
A ServiceManagerStub object implements the particular lookup of JNLP services by the JNLP Client. The object is registered with the ServiceManager using the ServiceManager.setServiceManagerStub(javax.jnlp.ServiceManagerStub) method. Since: 1.0 See Also: ServiceManager
Method Summary java.lang.String []
getServiceNames()
java.lang.Object
lookup(java.lang.String name) See description for ServiceManager.lookup(java.lang.String)
See description for ServiceManager.getServiceNames()
Method Detail lookup
java.lang.Object lookup(java.lang.String name) throws UnavailableServiceException
See description for ServiceManager.lookup(java.lang.String) Throws: UnavailableServiceException
getServiceNames java.lang.String[] getServiceNames()
See description for ServiceManager.getServiceNames() Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ServiceManagerStub.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface SingleInstanceListener public interface SingleInstanceListener SingleInstanceListener is a interface which should be implemented by a JNLP application if they wish to support single
instance behaviour. Since: 1.5
Method Summary void
newActivation(java.lang.String[] params)
This method should be implemented by the application to handle the single instance behaviour - how should the application handle the arguments when another instance of the application is invoked with params.
Method Detail newActivation void newActivation(java.lang.String[] params)
This method should be implemented by the application to handle the single instance behaviour - how should the application handle the arguments when another instance of the application is invoked with params. Parameters: params
- Array of parameters for the application main (arguments supplied in the jnlp file)
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/SingleInstanceListener.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface SingleInstanceService public interface SingleInstanceService
SingleInstanceService allow applications launched under Java Web Start to register themselves as singletons, and to be passed in new parameter sets when user attempts to launch new instances of them.
Since: 1.5
Method Summary void
addSingleInstanceListener(SingleInstanceListener sil)
Adds the specified SingleInstanceListener to handle how the application/applet should behave when another instance of the same application/applet is invoked. void
removeSingleInstanceListener(SingleInstanceListener sil)
Removes the specified SingleInstanceListener.
Method Detail addSingleInstanceListener void addSingleInstanceListener(SingleInstanceListener sil)
Adds the specified SingleInstanceListener to handle how the application/applet should behave when another instance of the same application/applet is invoked. If SingleInstanceListener sil is null, no exception is thrown and no action is performed. Parameters: sil - the SingleInstanceListener object to be added
removeSingleInstanceListener void removeSingleInstanceListener(SingleInstanceListener sil)
Removes the specified SingleInstanceListener. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to the application/applet. If listener sil is null, no exception is thrown and no action is performed. It is recommended that if an application/applet registered any SingleInstanceListener(s), it should call this method to remove all listeners upon exit of the application/applet. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/SingleInstanceService.html
Parameters: sil - the SingleInstanceListener object to be removed Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/SingleInstanceService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Class ServiceManager java.lang.Object javax.jnlp.ServiceManager
public final class ServiceManager extends java.lang.Object
The ServiceManager provides static methods to lookup JNLP services. This class is abstract and final and cannot be instantiated. Requests are delegated to a ServiceManagerStub object. This object must be set by the JNLP Client on startup using the setServiceManagerStub method. Since: 1.0 See Also: ServiceManagerStub
Method Summary static java.lang.String []
getServiceNames()
static java.lang.Object
lookup(java.lang.String name)
Returns the names of all services implemented by the JNLP Client. Asks the JNLP Client for a service with a given name.
static void
setServiceManagerStub(ServiceManagerStub stub) Sets the object that all lookup and getServiceNames requests are delegated to.
Methods inherited from class java.lang.Object clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
Method Detail lookup public static java.lang.Object lookup(java.lang.String name) throws UnavailableServiceException
Asks the JNLP Client for a service with a given name. The lookup must be idempotent, that is return the same object for each invocation with the same name. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ServiceManager.html
Parameters: name - Name of service to lookup. Returns: An object implementing the service. null will never be returned. Instead an exception will be thrown. Throws: UnavailableServiceException - if the service is not available, or if name is null. UnavailableServiceException
getServiceNames public static java.lang.String[] getServiceNames()
Returns the names of all services implemented by the JNLP Client.
setServiceManagerStub public static void setServiceManagerStub(ServiceManagerStub stub)
Sets the object that all lookup and getServiceNames requests are delegated to. The setServiceManagerStub call is ignored if the stub has already been set. This method should be called exactly once by the JNLP Client, and never be called by a launched application. Parameters: stub - The ServiceManagerStub object to delegate to Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ServiceManager.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Class UnavailableServiceException java.lang.Object java.lang.Throwable java.lang.Exception javax.jnlp.UnavailableServiceException
All Implemented Interfaces: java.io.Serializable
public class UnavailableServiceException extends java.lang.Exception
The UnavailableServiceException is thrown by the ServiceManager when a non-existing or unavailable service is looked up. Since: 1.0 See Also: ServiceManager,
Serialized Form
Constructor Summary UnavailableServiceException() Constructs an UnavailableServiceException with null as its error detail message. UnavailableServiceException(java.lang.String msg) Constructs an UnavailableServiceException with the specified detail message.
Method Summary Methods inherited from class java.lang.Throwable fillInStackTrace, getCause, getLocalizedMessage, getMessage, getStackTrace, initCause, printStackTrace, printStackTrace, printStackTrace, setStackTrace, toString
Methods inherited from class java.lang.Object clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
Constructor Detail UnavailableServiceException http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/UnavailableServiceException.html
public UnavailableServiceException()
Constructs an UnavailableServiceException with null as its error detail message.
UnavailableServiceException public UnavailableServiceException(java.lang.String msg)
Constructs an UnavailableServiceException with the specified detail message. The error message string s can later be retrieved by the Throwable.getMessage() method of class java.lang.Throwable. Parameters: msg - the detail message. Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/UnavailableServiceException.html
javaws
Command Line
NAME javaws
- Java Web Start launcher command
SYNOPSIS javaws [run-options] <jnlp> javaws [control-options]
PARAMETERS [run-options]
Command-line run-options. run-options may be in any order. For a discussion of the various runoptions, see RUN-OPTIONS below. <jnlp>
This can be either the path of, or the Uniform Resource Locater (URL) of the JNLP (Java Network Launching Protocol) file. [control-options]
Command-line control-options. control-options may be in any order. For a discussion of the various control-options, see CONTROL-OPTIONS below.
DESCRIPTION The javaws command launches Java Web Start, which is the reference implementation of the Java Network Launching Protocol (JNLP). Java Web Start launches Java applications/applets hosted on a network. If a JNLP file is specified, javaws will launch the Java application/applet specified in the JNLP file. The javaws launcher has a set of options that are supported in the current release. However, the options may be removed in a future release.
RUN-OPTIONS -offline
run Java Web Start in offline mode. -Xnosplash
disable the display of the initial splash screen. http://java.sun.com/javase/6/docs/technotes/tools/share/javaws.html
-open <arguments>
If specified, replaces the arguments in the jnlp file with -open <arguments>. -print <arguments>
If specified, replaces the arguments in the jnlp file with -print <arguments>. -online
run in online mode (default behavior). -wait
If specified, the javaws process will not exit until the application exits. -verbose
display additional output. -J
Related Documents
Search the guide Select from the contents below:
Overview Java Web Start Technology Where to Find Java Web Start Technology Using Java Web Start Software Requirements
Setting up the Web Site Introduction Basic Steps
Creating the Web Page That Launches the Application Introduction Detecting if Java Web Start is installed on Netscape Detecting if Java Web Start is installed on IE, and if so, the version number Launching the application if Java Web Start is Installed—or providing a link for auto-install or general download page Creating an auto-install page
Application Development Considerations Introduction Retrieving Resources from JAR files Security and Code Signing Signing JAR Files with a Test Certificate How to Encode JNLP Files Dynamic Download of HTTPS Certificates
JnlpDownloadServlet Guide Introduction Examples Servlet Configuration Specifying Resources Mapping Requests to Resources Processing of JNLP Files
JNLP File Syntax http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/contents.html
Introduction The jnlp Element The information Element The security Element The resources Element The application-desc Element The applet-desc Element
JNLP API Examples Introduction Using a BasicService Service Using a ClipboardService Service Using a DownloadService Service Using a FileOpenService Service Using a FileSaveService Service Using a PrintService Service Using a PersistenceService Service Using FileContents Using a JNLPRandomAccessFile Using a SingleInstanceService Service Using an ExtendedService Service
The javaws Command Line Interface Appendices: FAQ JNLP API (JavaDoc)
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/contents.html
Overview Select a Chapter/Topic
Java Web Start Technology Java Web Start is a helper application that gets associated with a Web browser. When a user clicks on a link that points to a special launch file (JNLP file), it causes the browser to launch Java Web Start, which then automatically downloads, caches, and runs the given Java Technology-based application. The entire process is typically completed without requiring any user interaction, except for the initial single click. From a technology standpoint, Java Web Start has a number of key benefits that make it an attractive platform to use for deploying applications:
Java Web Start is built exclusively to launch applications written to the Java(TM) Platform Standard Edition. Thus, a single application can be made available on a Web server and then deployed on a wide variety of platforms, including Windows 98/NT/2000/ME/XP, Linux, and the SolarisTM Operating Environment. The Java platform has proven to be a very robust, productive, and expressive development platform, leading to a significant cost savings due to minimized development and testing costs. Java Web Start supports multiple revisions of the Java(TM) Platform Standard Edition. Thus, an application can request a particular version of the platform it requires, such as Java SETM 1.5.0. Several applications can run at the same time on different platform revisions without causing conflicts, and Java Web Start can automatically download and install a revision of the platform if an application requests a version that is not installed on the client system. Java Web Start allows applications to be launched independently of a Web browser. This can be used for off-line operation of an application, where launching through the browser is often inconvenient or impossible. The application can also be launched through desktop shortcuts, making launching the Web-deployed application similar to launching a native application. Java Web Start takes advantage of the inherent security of the Java Platform. Applications are by default run in a protective environment (sandbox) with restricted access to local disk and network resources. It allows the user to safely run applications from sources that are not trusted. Applications launched with Java Web Start are cached locally. Thus, an already-downloaded application is launched on par with a traditionally installed application.
The technology underlying Java Web Start is the Java TM Network Launching Protocol & API (JNLP). This technology was developed via the Java Community Process (JCP). Java Web Start is the reference implementation (RI) for the JNLP specification. The JNLP technology defines, among other things, a standard file format that describes how to launch an application called a JNLP file.
Security Java Web Start is built on top of the Java(TM) SE platform, which provides a comprehensive security architecture. Applications launched with Java Web Start will, by default, run in a restricted environment ("sandbox") with limited access to files and network. Thus, launching applications using Java Web Start maintains system security and integrity. An application can request unrestricted access to your system. In this case, Java Web Start will display a Security Warning dialog when the application is launched for the first time. The security warning will show information about the vendor who developed the application. If you choose to trust the vendor, then the application will be launched. The information about the origin of the application is based on digital code signing. http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/overview.html
Where to find Java Web Start Java Web Start is included in the Java Runtime Environment available at http://java.sun.com. The JNLP specification can be found at JSR 56: Java Network Launching Protocol and API.
Using Java Web Start Software Java Web Start allows you to launch Java-technology-based applications directly from the Web. An application can be launched in three different ways:
From a Web browser by clicking on a link. From desktop icons or the Start Menu. From the Java Cache Viewer
Regardless of which way is used, Java Web Start will connect back to the Web server each time an application is launched to check whether an updated version of the application is available.
Launching from a Web browser Point your web browser to a page with a link to a jnlp application, and click on that link. Some applications require extra privileges, such as access to your local hard disk. For these applications, a security dialog will pop up with information about the origin of the application based on who digitally signed the code. The application will run only if you decide to trust the vendor. That is really all there is to using Java Web Start, but how does it work? The HTML links that launch the applications are, in fact, standard HTML links. However, instead of pointing to another Web page, they link to a special configuration file called a JNLP file. The Web browser examines the file extension and/or the MIME type of the file, and sees that it belongs to Java Web Start. It then launches Java Web Start with the downloaded JNLP file as an argument. Java Web Start proceeds with downloading, caching, and running the application as directed by the JNLP file.
Launching from desktop icons and the Start Menu (Microsoft Windows and Unix running GNOME 2.0+) Java Web Start technology can automatically create shortcuts for your application on the desktop and in the Start Menu for Web-deployed applications developed with Java technology. You can use the Java Control Panel to control the shortcut settings. Shortcuts can also be added by using the Java Web Start Cache Viewer, using the install shortcut menu item.
Using Java Web Start Software Behind a Proxy Server/Firewall Java Web Start software must be configured with the correct proxy settings in order to launch applications from outside your firewall. Java Web Start software will automatically try to detect the proxy settings from the default browser on your system (Internet Explorer or NetscapeTM browsers on Microsoft Windows, and Netscape browsers on the Solaris Operating Environment and Linux). Java Web Start technology supports most web proxy auto-configuration scripts. It can detect proxy settings in almost all environments. You can also use the Java Web Start Control Panel to view or edit the proxy configuration. Refer to the Java Control Panel for more details.
Requirements Desktop/Client requirements: The client machine requires support for the Java Runtime Environment (JRE), version 1.3 or later. Java Web Start is available for Windows 98/NT/2000/ME/XP, the Solaris Operating Environment, and Linux. http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/overview.html
Server requirements: Applications can be deployed from any standard Web server. In order to use Java Web Start, the Web server must be configured with support for a new MIME type. See Setting Up the Web Site.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/overview.html
Setting Up the Web Site Select a Chapter/Topic
Introduction Java Web Start leverages existing Internet technology, such as the HTTP protocol and Web servers, so existing infrastructure for deploying HTML-based contents can be reused to deploy Java Technology-based applications using Java Web Start. In order to deploy your application to client machines, you must make sure that all files containing your application are accessible through a Web server. This typically amounts to copying one or more JAR files, along with a JNLP file, into the Web server's directories. The set-up required for enabling the Web site to support Java Web Start is very similar to deploying HTML-based contents. The only caveat is that a new MIME type needs to be configured for the Web server.
Basic Steps 1. Configure the Web server to use the Java Web Start MIME type Configure the Web server so that all files with the .jnlp file extension are set to the application/x-java-jnlp-file MIME type. Most Web browsers use the MIME type returned with the contents from the Web server to determine how to handle the particular content. The server must return application/x-java-jnlp-file MIME type for JNLP files in order for Java Web Start to be invoked. Each Web server has a specific way in which to add MIME types. For example, for the Apache Web server you must add the following line to the .mime.types configuration file: application/x-java-jnlp-file JNLP
Check the documentation for the specifics of your Web server. 2. Create a JNLP file for the application The easiest way to create this file is to modify an existing JNLP file to your requirements. The syntax and format for the JNLP file is described in a later section. 3. Make the application accessible on the Web server Ensure your application's JAR files and the JNLP file are accessible at the URLs listed in the JNLP file. 4. Create the web page that launches the application See the next chapter, Creating the Web Page that launches the Application, for details on step 4.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/setup.html
Creating the Web Page That Launches the Application Select a Chapter/TopicTable of ContentsSearch PageOverviewSetting Up the Web SiteCreating the Web Page That Launches the ApplicationApplication Development ConsiderationsPackaging JNLP Applications in a Web ArchiveJNLP File SyntaxJNLP API Examplesjavaws Command LineFAQJNLP API (JavaDoc) This chapter includes the following topics:
Introduction Detecting if Java Web Start is installed on Netscape Detecting if Java Web Start is installed on IE, and if so, the version number Launching the application if Java Web Start is Installed—or providing a link for auto-install or general download page Creating an auto-install page
Introduction In order for an application to be launched from a web page via JNLP, the page must include a link to the JNLP file. E.g., to be able to launch application app.jnlp on a web site http://www.MySite.com, the page needs to include the following link: Launch the application
It may be the case, however, that Java Web Start is not installed on the user's computer. Thus the page needs to include logic (scripts) to take account of this. In fact, the page should include logic for the following: Detect if Java Web Start is installed
If so, launch the application. If not, detect if user is running IE on Window. If so, provide link to a page that can auto-install the JRE for Windows If not, provide a link to the general download page for the JDK/JRE.
The scripts, and the HTML for the auto-install page, are discussed below.
Detecting if Java Web Start is installed on Netscape Here is the first script that should be run on a web page for launching an application via JNLP: <SCRIPT LANGUAGE="JavaScript"> var javawsInstalled = 0; var javaws142Installed=0; var javaws150Installed=0; var javaws160Installed = 0; isIE = "false"; if (navigator.mimeTypes && navigator.mimeTypes.length) { x = navigator.mimeTypes['application/x-java-jnlp-file']; if (x) { javawsInstalled = 1; javaws142Installed=1; javaws150Installed=1; javaws160Installed = 1; } } else { isIE = "true"; }
This script looks at the navigator.mimeTypes object and the navigator.mimeTypes.length var to decide if the browser is Netscape or
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/launch.html
IE. If length is 0, it is assumed the browser is IE, as with IE the navigator.mimeTypes array is defined but always empty. If length is non-zero, then the browser is assumed to be Netscape and the JNLP MIME type is checked to see if it exists on Netscape. If so, javawsInstalled, javaws142Installed , javaws150Installed and javaws160Installed are all set to 1. With Netscape it is not possible to determine which particular version of Java Web Start is installed, so all four variables are set to 1.
Detecting if JavaWeb Start is installed on IE, and if so, the version The above JavaScript should be followed by a VBScript that sets variables related to Internet Explorer browers: <SCRIPT LANGUAGE="VBScript"> on error resume next If isIE = "true" Then If Not(IsObject(CreateObject("JavaWebStart.isInstalled"))) Then javawsInstalled = 0 Else javawsInstalled = 1 End If If Not(IsObject(CreateObject("JavaWebStart.isInstalled.1.4.2.0"))) Then javaws142Installed = 0 Else javaws142Installed = 1 End If If Not(IsObject(CreateObject("JavaWebStart.isInstalled.1.5.0.0"))) Then javaws150Installed = 0 Else javaws150Installed = 1 End If If Not(IsObject(CreateObject("JavaWebStart.isInstalled.1.6.0.0"))) Then javaws160Installed = 0 Else javaws160Installed = 1 End If End If
This VBScript is executed if the variable isIE from the preceeding JavaScript is "true"; i.e., if the end-user's browser is Internet Explorer. This script instantiates the isInstalled COM object in JavaWebStart.dll, and this object determines four things:
whether the client machine has any version of Java Web Start installed; whether the client machine has version 1.2 of Java Web Start installed; whether the client machine has versions 1.4.2 of Java Web Start installed; whether the client machine has versions 1.5.0 of Java Web Start installed. whether the client machine has versions 1.6.0 of Java Web Start installed.
After the above two scripts have been executed, the variables javawsInstalled, javaws142Installed, javawsInstalled150 and will be set to either 1 or 0, as follows:
javawsInstalled160
Browser javawsInstalled javaws142Installed javaws150Installed javaws160Installed 1 if any version of Internet 1 if Java Web Start 1.4.2 is Java Web Start is Explorer installed; 0 otherwise. installed; 0 otherwise.
1 if Java Web Start 1.5.0 is installed; 0 otherwise.
1 if Java Web Start 1.6.0 is installed; 0 otherwise.
1 if any version of Netscape 1 if any version of Java Web 1 if any version of Java Web 1 if any version of Java Web Java Web Start is Navigator Start is installed; 0 otherwise. Start is installed; 0 otherwise. Start is installed; 0 otherwise. installed; 0 otherwise.
Launching the application if Java Web Start is Installed—or providing a link for auto-install or general download page An additional JavaScript can be used to decide whether to:
provide a link to the application's jnlp file (i.e., Java Web Start is installed); initiate auto-download of JRE 6.0, which includes Java Web Start (i.e., Java Web Start is not installed and the user is running IE on Windows);
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/launch.html
or provide a link to the general download page for the 6.0 JDK/JRE (i.e., Java Web Start is not installed and the user is not running IE on Windows).
The following JavaScript handles these scenarios: <script language="JavaScript"> /* Note that the logic below always launches the JNLP application *if the browser is Gecko based. This is because it is not possible *to detect MIME type application/x-java-jnlp-file on Gecko-based browsers. */ if (javawsInstalled || (navigator.userAgent.indexOf("Gecko") !=-1)) { document.write("Launch the application"); } else { document.write("Click "); document.write("here "); document.write("to download and install JRE 5.0 and the application."); }
Notes: 1. The script only uses javawsInstalled—not javaws142Installed or javaws150Installed or javaws160Installed . 2. The line breaks following '?' and '&' are for readability purposes only; in an actual script there should be no breaks in the href string.
If javawsInstalled is 1, indicating that Java Web Start is already available on the client, then the script provides a link to the application's jnlp file. If Java Web Start is not installed on the client, the script instead provides a link to the PluginBrowserCheck program on the java.sun.com web site. PluginBrowserCheck checks whether the client uses Internet Explorer on a Microsoft Windows platform. If so, PluginBrowserCheck sends the user to the auto-install page http://www.MySite.com/download.html . (See the next section, Creating an auto-install page, for how to create an auto-install page for IE running on Windows.) If PluginBrowserCheck determines the user is not using Internet Explorer on Microsoft Windows, the user is redirected to the 6.0 JRE general download page on java.sun.com.
Creating an auto-install page
Note: The.cab file in the codebase attribute below will not be available until the GA release of the 6.0 JDK/JRE. For a complete list of JRE releases that can be autodownloaded via a .cab file, as mentioned below, see Autodownload Files (Windows Only). The download.html file should be staged on the server side. It contains special OBJECT and PARAM tags that will download to the client an auto-installer for JRE 6.0 . Along with Java Web Start, an ActiveX control will be downloaded to the client. The ActiveX control will launch the application using the newly installed Java Web Start. Here is a sample download.html file:
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/launch.html
The OBJECT tag fetches a .cab file that contains an auto-installer for JRE 6.0. The URL: http://java.sun.com/update/1.6.0/jinstall-6-windows-i586.cab will return the latest update release available for the Java SE 6 release. The string: Version=6,0,0,0 will be used to compare with the wsdetect.dll version, which is registered with the CLSID above. If the local machine has the dll installed and the version is greater than or equal to the Version specified, we will just load the dll in the local machine. Otherwise it will download and install Java from the codebase specified. The PARAM tags specify the location of the application's jnlp file so that it may be automatically launched after the JRE is installed on the client. app:
Once the Java Web Start Active-X control is installed/loaded, it will invoke Java Web Start to launch the application specified by this URL.
back:
This controls the behavior of the browser after launching the application. It can remain on the current page (download.html in this case) or navigate back to the previous page. For issues relating to application development see the next chapter, Application Development Considerations.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/launch.html
Application Development Considerations Select a Chapter/Topic
This chapter includes the following topics:
Introduction Retrieving Resources from JAR files Security and Code Signing Signing JAR Files With a Test Certificate How to Encode JNLP Files Dynamic Download of HTTPS Certificates
Introduction
Developing applications for deployment with Java Web Start is generally the same as developing stand-alone applications for the Java(TM) Platform Standard Edition. For instance, the entry point for the application is the standard public static void main(String[] argv). However, in order to support Web deployment—automatic download and launching of an application—and to ensure that an application can run in a secure sandbox, there are some additional considerations:
An application must be delivered as a set of JAR files. All application resources, such as files and images must be stored in JAR files; and they must be referenced using the getResource mechanism in the Java(TM) Platform Standard Edition (see below). If an application is written to run in a secure sandbox, it must follow these restrictions: No access to local disk. All JAR files must be downloaded from the same host. Network connections are enabled only to the host from which the JAR files are downloaded. No security manager can be installed. No native libraries may be used. Limited access to system properties. The application has read/write access to all system properties defined in the JNLP File, as well as read-only access to the same set of properties that an Applet has access to. An application is allowed to use the System.exit call. An application that needs unrestricted access to the system will need to be delivered in a set of signed JAR files. All entries in each JAR file must be signed.
Retrieving Resources from JAR files Java Web Start only transfers JAR files from the Web server to the client machine. It determines where to store the JAR files on the local machine. Thus, an application cannot use disk-relative references to resources such as images and configuration files.
All application resources must be retrieved from the JAR files specified in the resources section of the JNLP file, or retrieved explicitly using an HTTP request to the Web server. Storing resources in JAR files is recommended, since they will be cached on the local machine by Java Web Start. The following code example shows how to retrieve images from a JAR file: // Get current classloader
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/development.html
ClassLoader cl = this.getClass().getClassLoader(); // Create icons Icon saveIcon = new ImageIcon(cl.getResource("images/save.gif")); Icon cutIcon = new ImageIcon(cl.getResource("images/cut.gif")); ...
The example assumes that the following entries exist in one of the JAR files for the application: images/save.gif images/cut.gif
Security and Code Signing Java Web Start addresses the security issues:
Protecting users against malicious code (intentional & unintentional) that may affect local files; Protecting enterprises against code that may attempt to access or destroy data on networks.
Applications launched with Java Web Start are, by default, run in a restricted environment where they have limited access to local computing resources, such as storage devices and the local network. In this sandbox environment, Java Web Start can guarantee that a downloaded and potentially untrusted application cannot compromise the security of the local files or the network. An additional security feature supported by Java Web Start is digital code signing. If an application being invoked is delivered in one or more signed JAR files, Java Web Start will verify that the contents of the JAR file have not been modified since they were signed. If verification of a digital signature fails, Java Web Start will not run the application, since it may have been compromised by a third-party. The support for code signing is important for both users and for application service providers. This service makes it possible for users to verify that an application comes from a trusted source. Because the application service provider signs the code, both can be ensured that no other party can impersonate the application on the Web. A signed application that is trusted by the user can also request additional system privileges, such as access to a local disk. Java Web Start presents a dialog displaying the application's origin, based on the signer's certificate, before the application is launched. This allows the user to make an informed decision about whether or not to grant additional privileges to the downloaded code. By including the following settings in the JNLP file, an application can request full access to a client system if all its JAR files are signed :
<security>
The implementation of code signing in Java Web Start is based on the security API in the core Java(TM) Platform Standard Edition. The Java 2 SE JRE 1.4.2 supports code signing with the SHA1withDSA and MD5withRSA algorithms. Developers sign code for use with Java Web Start in the same way as for Java Applets—by using the standard jarsigner tool from the Java(TM) Platform Standard Edition. The jarsigner tool documentation provides examples of how to sign code and create test certificates, and it discusses other issues related to signing. Java Web Start also supports use of the Netscape signtool used with SDK/JRE 1.4.2. See the Netscape Web site for details: http://developer.netscape.com/software/signedobj/
Signing JAR Files With a Test Certificate http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/development.html
Here are the steps needed to sign a JAR file with a test certificate: 1. Make sure that you have an SDK 1.4.2 keytool and jarsigner in your path. These tools are located in the SDK bin directory. 2. Create a new key in a new keystore as follows: keytool -genkey -keystore myKeystore -alias myself
You will get prompted for a information about the new key, such as password, name, etc. This will create the myKeystore file on disk. 3. Then create a self-signed test certificate as follows: keytool -selfcert -alias myself -keystore myKeystore
This will prompt for the password. Generating the certificate may take a few minutes. 4. Check to make sure that everything is okay. To list the contents of the keystore, use this command: keytool -list -keystore myKeystore
It should list something like: Keystore type: jks Keystore provider: SUN Your keystore contains 1 entry: myself, Tue Jan 23 19:29:32 PST 2001, keyEntry, Certificate fingerprint (MD5): C2:E9:BF:F9:D3:DF:4C:8F:3C:5F:22:9E:AF:0B:42:9D
5. Finally, sign the JAR file with the test certificate as follows: jarsigner -keystore myKeystore test.jar myself
Repeat this step with all of your JAR files.
Note that a self-signed test certificate should only be used for internal testing, since it does not guarantee the identity of the user and therefore cannot be trusted. A trust-worthy certificate can be obtained from a certificate authority, such as VeriSign or Thawte, and should be used when the application is put into production.
How to Encode JNLP Files Beginning with Java Web Start version 1.2, JNLP files may be encoded in any character encoding supported by the Java(TM) Platform Standard Edition. (See the Java(TM) Platform Standard Edition documentation for a list of supported encodings.) To encode a JNLP file, specify an encoding in the XML prolog of that file. For example, the following line indicates that the JNLP file will be encoded in UTF-16.
The XML prolog itself must be UTF-8-encoded.
Dynamic Download of HTTPS Certificates http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/development.html
Beginning with 1.4.2, Java Web Start dynamically imports certificates in much the same way as browsers do. In order to make this work, Java Web Start now sets its own https handler, using the java.protocol.handler.pkgs system properties, to initialize defaults for SSLSocketFactory and HostnameVerifier. It sets the defaults with HttpsURLConnection.setDefaultSSLSocketFactory and HttpsURLConnection.setDefaultHostnameVerifier. If your application uses those two method, make sure they are called after the Java Web Start https handler is initialized, otherwise your custom handler will be replaced by the Java Web Start default handler. You can ensure that your own customized SSLSocketFactory and HostnameVerifiter are used by doing either of the following:
1. Installing your own https handler, which will completely replace the Java Web Start https handler (for more information, see A New Era for Java Protocol Handlers); 2. Calling HttpsURLConnection.setDefaultSSLSocketFactory or HttpsURLConnection.setDefaultHostnameVerifier only after the first https url object is created, which will execute the Java Web Start https handler initialization code first. For information on creating a download servlet see the next chapter, JnlpDownloadServlet Guide.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/development.html
JnlpDownloadServlet Guide Select a Chapter/Topic
Table of Contents Introduction Examples Servlet Configuration Specifying Resources Mapping Requests to Resources Processing of JNLP Files Pack200 Support
Introduction Java Web Start includes a servlet in the sample/jnlp directory of the JDK. It can be used on either a JNOP file and its associated resources packaged in a Web Archive (.war) file, or on an unarchived directory. The purpose of the servlet is to provide a simple and convenient packaging format for JNLP applications, so they can be easily deployed in a Web Container, such as Tomcat or a Java EE-compliant Application Server. The download servlet supports the following features:
Automatic installation of the codebase URL into JNLP files, thus eliminating manual management of hard-coded URLs into JNLP files. Explicit specification of the timestamp for a JNLP file, independent of the file-system timestamp. Supports all download protocols defined in the JNLP specification v1.0.1. These include basic download protocol, version-based download protocol, and extension download protocol. Version-based information is specified per file or per directory in the Web archive. Thus, no centralized file needs to be managed for the entire archive. Automatic generation of JARDiff files Pack200 support
The packaging support consists of one servlet: JnlpDownloadServlet. The servlet is packaged into the jnlp-servlet.jar file, which can be found in the SDK under samples/jnlp/servlet/. Below are two examples of how to use the servlet followed by a detailed description of the functionality of the servlet.
Examples The first example shows how an application can be packaged into a WAR file without using the version-based download. The JnlpDownloadServlet is used to insert the exact URL into the JNLP file at request time. The second example shows how to add support for version-based download as well.
WAR file without use of version-download protocol The example1.war contains: http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
/index.html /app/launch.jnlp /app/application.jar /app/images/icon.gif /WEB-INF/web.xml /WEB-INF/lib/jnlp-servlet.jar /WEB-INF/lib/<jar files for XML parser> (not needed if the servlet container is running J2SE 1.4+)
The JNLP file for the application would look like this: TS: 2002-04-23 19:21:05 <jnlp codebase="$$codebase">
The first line with the TS tag contains the timestamp that the servlet will return for the JNLP file. The format of the timestamp is in ISO 8601 format. If the line is omitted, the timestamp of the file in the WAR file is used. The $$codebase string is modified by the JnlpDownloadServlet to be the actual URL for the request. The web.xml file instructs the Web container to invoke the JNLPDownloadServlet for all requests to a JNLP file. <web-app> <servlet> <servlet-name>JnlpDownloadServlet <servlet-class>jnlp.sample.servlet.JnlpDownloadServlet <servlet-mapping> <servlet-name>JnlpDownloadServlet
The JnlpDownloadServlet requires an XML parser in order to work. If your servlet container is running J2SE 1.4+, there is already a XML parser integrated in it. Otherwise please add jar files that implement a Java XML parser to the WEB-INF/lib directory. The reference implementation of the parser can be downloaded from http://java.sun.com/xml.
WAR file with use of version-download protocol The example2.war contains: /index.html /app/version.xml /app/launch.jnlp /app/application.jar /app/lib__V2.1.jar /app/images/icon.gif /WEB-INF/web.xml /WEB-INF/lib/jnlp-servlet.jar /WEB-INF/lib/<jar files for XML parser> (not needed if the servlet container is running J2SE 1.4+)
The /app directory contains two JAR resources: application.jar and lib.jar. The lib.jar uses a naming convention to associate the version-id 2.1, i.e., the version information is associated on a per-file basis. The version of the application.jar http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
file is described in the version.xml file, i.e., on a per-directory basis. The version.xml file looks like this: <jnlp-versions>
The JNLP file for the application looks like this: TS: 2002-04-23 19:21:05 <jnlp codebase="$$codebase" href="$$name">
Finally, the web.xml file configures the JnlpDownloadServlet to be invoked for all requests into the /app directory. <web-app> <servlet> <servlet-name>JnlpDownloadServlet <servlet-class>jnlp.sample.servlet.JnlpDownloadServlet <servlet-mapping> <servlet-name>JnlpDownloadServlet
Servlet Configuration This section shows how to configure a WAR file to include the JnlpDownloadServlet and also how the servlet can be configured.
Adding the Servlet to a WAR archive
First the necessary servlet code must be made available to the servlet container. This is done by populating the WEB-INF/lib directory. The servlet is added to a WAR archive by including the jnlp-servlet.jar file in the WEB-INF/lib/ directory. The servlet needs access to an XML parser. If your servlet container is running J2SE 1.4+, there is already a XML parser integrated in it. Otherwise JAR files implementing a Java XML parser must also be added. They can be downloaded from http://java.sun.com/xml. Once the servlet code is available, the Web container must be told to invoke the servlet on the right set of JNLP and JAR files, http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
or on a given subdirectory. This is all configured in the WEB-INF/web.xml file inside the <web-app> tag: <web-app> ...
The first thing to do is to tell the Web container how to invoke the servlet. This is done by using the <servlet> tag: <servlet> <servlet-name>JnlpDownloadServlet <servlet-class>jnlp.sample.servlet.JnlpDownloadServlet
Secondly, the Web container must be told when to invoke the servlet. This can be done in several ways. It can be invoked for certain directories or for files with certain extensions. For example, to invoke it for JNLP files, add the following to the web.xml file: <servlet-mapping> <servlet-name>JnlpDownloadServlet
Or for a given subdirectory: <servlet-mapping> <servlet-name>JnlpDownloadServlet
See also example1 and example2 for examples on how to configure the servlet.
Logging The servlet has built-in logging capabilities to monitor its behavior. Logging messages are generated in 4 different categories: FATAL A malfunction or internal error happened inside the servlet. WARNING An error processing some of the information in the WAR file, e.g., parsing the version.xml file. INFORMATIONAL Logging all requests and replies, re-scanning of directories, etc. DEBUG Detailed internal information about how a request is processed.
The logging output is controlled by two servlet initialization parameters, logLevel and logPath. The log level can be set to either NONE, FATAL, WARNING, INFORMATIONAL, or DEBUG. The log path specifies a file where the output will be written to. If no path is specified, logging is done to the standard log for servlets (using the ServletContext.log method). For example: <servlet> <servlet-name> JnlpDownloadServlet <servlet-class> jnlp.sample.servlet.JnlpDownloadServlet
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
logLevel <param-value> DEBUG
Configuring file extensions and MIME types
The servlet treats JNLP and JAR files specially. JNLP files will be macro-expanded as described in a section below. A versionbased request for a JAR file might result in the generation for an incremental update. The servlet uses extensions to determine if a file is a JNLP or JAR file. The default extension of JNLP files is .jnlp and for JAR files is .jar. These default extensions can be overwritten by the initialization parameters: jnlp-extension and jar-extension. For example:
The MIME type that is returned for a file is also based on its extension. The MIME type is looked up in the configuration files for the Web container and the WAR file. If no mapping is specified, the default MIME types are shown below: Extension Default MIME type ------------------------------------------.jnlp application/x-java-jnlp-file .jar application/x-java-archive .jardiff application/x-java-archive-diff
A mapping can be overwritten by using the <mime-type> element in the web.xml file. For example: <web-app> ... <mime-mapping> <extension>jnlp <mime-type>text/ascii ...
Specifying Resources
Application resources such as images, JAR files, and JNLP files are stored in the WAR file. The WAR file itself is a hierarchical directory structure, and the location of a resource inside the WAR file determines what URL will be used to look it up. http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
Assume that the WAR file (or servlet) has been configured so it handles all URL requests that starts with http://www.mytool.com/tool/ . If the following requests is made: http://www.mytool.com/tool/app/launch.jnlp. Then the JnlpDownloadServlet will look for the launch.jnlp resource in the app/ directory in the WAR file.
No version information A resource that has no associated version information, such as a JNLP file for an application, is simply just added to the WAR file. For example, given the above example, then the WAR file should included the following file: /app/launch.jnlp
In general, the timestamp that will be returned for the file is the last-modified timestamp that the file has in the WAR file. The only exception is for JNLP files where it can be explicitly specified in the JNLP file (see below).
Version information and more The version-based and extension-based download protocols in the JNLP specification allows a resource to be looked up based on version-id, operating system, system architecture, and locale. The JnlpDownloadServlet provides two mechanisms for associating this information with a resource. It can be done on a per-file basis, using a naming convention, or by a perdirectory basis, using a configuration file. Both methods can be used for the same directory. The following information can be associated with a resource:
A path to the resource, e.g., /app A name for the resource, e.g., launch.jnlp A version-id, e.g., 1.1.0 A list of supported operations systems, e.g., SunOS Linux A list of supported architectures, e.g., x86 A list of supported locales, e.g., da da_DK A flag indicating if the version-id is a product version or a platform version (only used for JRE downloading)
The path is specified by the location of the resource in the WAR archive. The rest of the information is either specified by the use of a naming convention or in the version.xml file.
Resource Naming The file naming convention is used if a double underscore (__) marker is found in the filename. The filename is parsed according to the BNF notation shown below: file ::= name __ options . ext options ::= option ( __ options ) * option ::= V version-id | O os | A arch | L locale
Only one version-id can be specified per file. However, multiple os, arch, and locale fields can be specified. For example: application__V1.2__Len_US__Len.jar
will mean that the resource application.jar has a version-id of 1.2, and the following associated locales: en_US and en.
The version.xml file In each directory, a version.xml file can be placed to describe the additional properties, such as a version-id, for files in that particular directory. This is an alternative to the file naming convention. http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
For example, placing the file application-1_2-us.jar in a directory, along with a version.xml with the following content: <jnlp-versions>
will be the same as having placed the file application__V1.2__Len_US__Len.jar in the directory.
A resource can also be specified with a platform version-id in the version.xml file. Such a resource is used to match a particular platform request for a JRE. A resource with a platform version-id is specified using the
Platform version requests are generated internally by Java Web Start, when an application has requested a version of the Java platform that is currently not installed on the local system. The complete document type definition (DTD) for the version.xml is shown in the following:
jnlp-versions
Mapping Requests to Resources The JNLP specification defines four different kinds of download requests that Java Web Start (or more generally, a JNLP Client) can make to a server when requesting a resource:
Basic Download Request: This is an ordinary URL request to a specific file. The Last-Modified field of the response is used to determine if an update is available on the server. The basic download request can be used for all resource types. Version-based Download Request: This request type can be used for JAR files and images, i.e., the following elements will generate a version-based download request: <jar>,
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
operating system, system architecture, and locale. Platform-version Download Request: This is simliar to the extension download request, but used to request a particular version of the J2SE Runtime Environment (JRE). This request is generated by Java Web Start, when a JNLP file has requested a particular version of the JRE that is not currently installed on the client system.
A request is initially processed by the JNLPDownloadServlet, and it extracts the following information from the request:
Path in WAR file, Name of requested file Version string (version-id parameter or platform-version-id parameter) Current version-id (current-version-id parameter) List of operation systems (os parameter) List of architectures (arch parameter) List of locales (locale parameter)
Consider example2, and assume that it is being hosted at http://www.mytool.com/tool2/. If the following requests is made: http://www.mytool.com/tool2/app/lib.jar&version-id=2.1. Then the path of the resource would be, app/, the name would be lib.jar, the version string would be 2.1, and the lists for os, architecture, and locales would be empty. A request to a directory, e.g., http://www.mytool.com/tool2/app/, will get appended the default filename: launch.jnlp. Thus, it would be the same as http://www.mytool.com/tool2/app/launch.jnlp.
Handling a basic download request A request for which no version-id is specified (neither version-id parameter or platform-version-id parameter is specified in the request) is handled as a basic download request. The request is first checked to see if it contains a double underscore (__) or is a request to the version.xml file. If so, the request is rejected and a HTTP 404 error code is returned. The JnlpDownloadServlet will then try to locate the resource with the given path and name in the WAR file, and if found return it. If the resource is not found, a HTTP 404 error code is returned for the request. If a match is found and it is a JNLP file, then it is preprocessed as described below before returned.
Handling a version-based download request The resource lookup for resources with a version-id is uniform across the version-based download protocol, the extension download protocol, and the platform-version download request.
First, the JnlpDownloadServlet will build a database of all the resources that are located in the WAR file directory that the URL request is accessing (based on the path in the request). The database is built by scanning the version.xml file (if present), and the list of files in the directory that is using the naming convention described above. The servlet caches the information internally. It only does a re-scan if the timestamp of the version.xml file is more recent than at the last scan. Thus, if you add a file using the naming convention, make sure to touch the version.xml file to force the servlet to do a rescan.
Secondly, the servlet will scan through the entries in the database to find a match for the given request (the match rules are described below). For a non-platform request, first the resource entries in the version.xml file are scanned in the order they are specified, and then secondly the entries that are specified using the naming convention. For a platform-version request, the platform entries in the version.xml file is scanned in the order they are specified. If several entries matches the request, then the entry with the highest version-id is returned. If multiple matches is found with the same highest version-id, then the first one specified is returned. The matching rules are as follows: http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
1. The name of the resource must match the request 2. The version-id of the resource must match the version string in the request 3. For the os, arch, and locale lists the following rules are used: 1. If an empty list is specified for the resource, then it is a match 2. If a non-empty list is specified for the resource, then it is a match, if at least one of the values specified for the resource is a prefix of at least one of the values specified in the request. The x-java-jnlp-version-id returned in the response is the version-id for the matching resource, except for a platform request where it is taken from the <product-version-id> field in the version.xml file. If a match is found and it is a JNLP file, then it is preprocessed as described below before returned.
Automatic JARDiff generation
The servlet will automatically generate and return incremental updates to JAR files, if possible. If the current-version-id parameter is included in the request and the servlet can find both a match on the current-version-id and the requested version (given the above matching rules) and the request is for a JAR file (e.g., the target resource has the .jar extension), then a JARDiff file will be generated by the servlet. The JARDiff file is returned as long as its size is less than that of the requested version.
The JARDiff file is generated and stored in a temporary directory that is specific to the given Web container. The servlet locates the temporary working directory using the javax.servlet.context.tempdir context attribute.
Processing of JNLP files The JnlpDownloadServlet will automatically macro-expand certain template values in a JNLP file and replace them with URLs that are specific to the current request. This will enable JNLP files to be written and deployed without containing hardcoded URLs.
Macro expansions
The servlet will automatically substitute certain fixed keys in the JNLP file (prefixed with $$) with URLs that are based on the current request. The keys are designed so location-independent WAR files can be created and deployed into a Web container.
The table below shows the 4 keys that the servlet will look for and substitute: Pattern Value ---------------------------------------------------------------$$codebase Complete URL for request, except name of JNLP file $$name Name of the JNLP file $$context Base URL for the Web Archive $$site Web site address without the WAR context portion
For example: Consider the example1 WAR file. Lets assume that it has been deployed at the following location: http://www.mytool.com/tool . Thus, a request to http://www.mytool.com/tool/app/launch.jnlp will return the JNLP file. The values of the macro-expanded keys would be: $$codebase $$name $$context $$site
= = = =
http://www.mytool.com/tool/app/ launch.jnlp http://www.mytool.com/tool/ http://www.mytool.com/
The servlet does not validate the format of the JNLP file nor that the XML is well-formed. The value substitution is purely textual.
Explicit Timestamps http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
An explicit timestamp can be included in a JNLP file to ensure that a consistent timestamp will be returned from the Web Server. This is especially useful if a JNLP file is replicated onto multiple Web servers that are serving the same URL in a round-robin or load-balancing fashion. Note that a similar method is not provided for JAR files. The version-based download protocol should be used instead. An explicit timestamp is included in the JNLP if the first-line starts with TS:. If so, it is parsed accordingly to the ISO 8601 formatting of timestamps (see below). The first line is also removed from the contents. See example1 and example2 above for sample JNLP files using the TS: element.
ISO 8601 Formatting The general format of a timestamp is: YYYY-MM-DD hh:mm:ss
The dashes, colons, and seconds are optional: YYYYMMDDhhmm
The hh is in 24h notation. By default, the local time zone is used. A Universal Time (UTC) (also know as GMT time) can be specified by appending the capital letter Z to a time as in: 23:59:59Z or 235959Z
The strings +hh:mm, +hhmm, or +hh
can be added to the time to indicate that the used local time zone is hh hours and mm minutes ahead of UTC. For time zones west of the zero meridian, which are behind UTC, the notation -hh:mm, -hhmm, or -hh
is used instead. For example, Central European Time (CET) is +0100 and U.S./Canadian Eastern Standard Time (EST) is 0500. The following strings all indicate the same point of time: 12:00Z = 13:00+01:00 = 0700-0500
Pack200 Support
You can now host *.jar.pack.gz or *.jar.gz files together with your original *.jar files. If the client supports the pack200-gzip or gzip file formats, the servlet will return the compressed file if it is available on the server. Java Web Start 5.0 supports both compression formats. You must host both the original jar file and the pack file in the server, otherwise the servlet will not pick up the pack file. The pack file can be created with the pack200.exe command included in J2SE 5.0. For more information on the pack200 compression technology, please see Pack200 and Compression for Network Deployment.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/downloadservletguide.html
JNLP File Syntax Select a Chapter/Topic
This chapter covers the following topics:
Introduction Example JNLP Elements jnlp Element information Element security Element update Element resources Element application-desc Element applet-desc Element component-desc Element installer-desc Element
Introduction The format used in this release is that specified in the Java Network Launching Protocol & API Specification (JSR-56) version 6.0. This document describes the most commonly used elements of a JNLP file. For a complete description of the format, refer to the specification.
JNLP File Contents Element
Attributes
jnlp
Description
Since
This is the main xml element for a jnlp file. Everything is contained within the jnlp element.
1.0
spec
The spec attribute can be 1.0, 1.5.0, or 6.0 or can use the wildcards such as 1.0+. It denoted the minimum version of the JNLP Specification that this jnlp file can work woth.
1.0
codebase
The codebase attribute specifies the base location for all relative URLs specified in href attributes in the JNLP file.
1.0
href
The href specifies the URL of the JNLP file itself.
1.0
version
The version of the application being launched, as well as the version of the JNLP file itself.
1.0
The information element contains other elements that describe the application and it's source.
1.0
information
Required yes
yes
1.5.0
os
Specifies the operating system for which this information element should be considered.
arch
Specifies the architecture for which this information element should be considered
1.5.0
platform
Specifies the platform for which this information element should be considered.
1.5.0
locale
Specifies the locale for which this information element should be considered.
1.5.0
title
The title element specifies the title of the application.
1.0
yes
vendor
The vendor element specifies the provider of the application.
1.0
yes
The homepage of the application.
1.0
A URL pointing to where more information on this application can be found.
1.0
A short statement describing the application.
1.0
An indicator as to what type of description this is, legal values are one-line, short, and tooltip.
1.0
Describes an icon that can be used to identify the application to the user.
1.0
href
A URL pointing to the icon file, may be in one of the following formats: gif, jpg, png, ico.
1.0
kind
Indicates the suggested use of the icon, can be: default, selected, disabled, rollover, splash, or shortcut.
1.0
width
Can be used to indicate the resolution of the image.
1.0
height
Can be used to indicate the resolution of the image.
1.0
depth
Can be used to indicate the resolution of the image.
1.0
homepage href description kind icon
offline-allowed
Indicates that this application can operate when the client system is disconnected from the network. 1.0
shortcut
The shortcut element can be used to indicate an application's preferences for desktop integration.
1.5.0
Can be used to describe the application's preference for creating a shortcut to run online or offline.
1.5.0
desktop
Can be used to indicate an application's preference for putting a shortcut on the users desktop.
1.5.0
menu
Can be used to indicate an application's preference for putting a menu item in the users start menus. 1.5.0
online
sub-menu association extensions
Can be used to indicate an application's preference for where to place the menu item.
1.5.0
Can be used to hint to the JNLP client that it wishes to be registered with the operating system as the primary handler of certain extensions and a certain mime-type.
1.5.0
Contains a list of file extensions (separated by spaces) that the application requests it be registered to handle.
1.5.0
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
yes
yes
mime-type
Contains the mime-type that the application requests it be registered to handle.
1.5.0
Describes an additional piece of related content that may be integrated with the application.
1.5.0
A URL pointing to the related content.
1.5.0
The update element is used to indicate the preferences for how application updates should be handled by the JNLP Client.
6.0
check
Indicates the preference for when the JNLP Client should check for updates. It can be always, timeout, or background..
6.0
policy
Indicates the preference for how the JNLP Client should handle an application update when it is known an update is available before the application is launched. It can be always, prompt-update, or prompt-run.
6.0
related-content href
update
yes
1.0 security
This element can be used to request enhanced permissions.
1.0
all-permissions
Requests that the application be run with all permissions.
1.0
j2ee-applicationclient-permissions
Requests that the application be run with a permission set that meets the security specifications of the J2EE Application Client environment.
1.0 1.0
resources
Describes all the resources that are needed for an application.
1.0
os
Specifies the operating system for which the resources element should be considered.
1.0
arch
Specifies the architecture for which the resources element should be considered.
1.0
locale
Specifies that the locales for which the resources element should be considered.
java (or j2se)
yes
Specifies what version(s) of Java to run the application with.
6.0 (java)
version
Describes an ordered list of version ranges to use.
1.0
href
The URL denoting the supplier of this version of java, and where it may be downloaded from.
1.0
java-vm-args
Indicates an additional set of standard and non-standard virtual machine arguments that the application would prefer the JNLP Client to use when launching Java.
1.0
initial-heap-size
Indicates the initial size of the Java heap.
1.0
max-heap-size
Indicates the maximum size of the Java heap.
1.0
Specifies a JAR file that is part of the application's classpath.
1.0
yes
href
The URL of the jar file.
1.0
yes
version
The requested version of the jar file. Requires using the version-based download protocol
1.0
main
Indicates if this jar contains the class containing the main method of the application.
1.0
download
Can be used to indicate this jar may be downloaded lazily, or when needed.
1.0
size
Indicates the downloadable size of the jar file in bytes.
1.0
part
Can be used to group resources together so they will be downloaded at the same time.
1.0
Specifies a JAR file that contains native libraries in it's root directory.
1.0
href
The URL of the jar file.
1.0
version
The requested version of the jar file. Requires using the version-based download protocol
1.0
download
Can be used to indicate this jar may be downloaded lazily.
1.0
size
Indicates the downloadable size of the jar file in bytes.
1.0
part
Can be used to group resources together so they will be downloaded at the same time.
1.0
Contains pointer to an additional component-desc or installer-desc to be used with this application.
1.0
href
The URL to the additional extension jnlp file.
1.0
version
The version of the additional extension jnlp file.
1.0
name
The name of the additional extension jnlp file
1.0
jar
nativelib
extension
ext-download
Can be used in an extension element to denote the parts contained in a component-extension.
1.0
ext-part
Describes the name of a part that can be expected to be found in the extension.
1.0
download
Can be used to indicate this extension may be downloaded eagerly or lazily.
1.0
part
Denotes the name of a part in this jnlp file to include the extension in.
1.0
package
yes
yes
yes
yes
Can be used to indicate to the JNLP Client which packages are implemented in which JAR files.
1.0
name
Package name contained in the jar files of the given part.
1.0
yes
part
Part name containing the jar files that include the given package name.
1.0
yes
recursive
Can be used to indicated that all package names beginning with the given name, can be found in the given part.
1.0
Defines a system property that will be available through the System.getProperty and System.getProperties methods.
1.0
name
Name of the system property.
1.0
yes
value
Value it will be set to.
1.0
yes
property
1.0
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
applicaation-desc main-class argument applet-desc
Note: A jnlp file must contain one of application-desc, applet-desc, component-desc, or installerdesc
1.0
Denotes this is the jnlp file for an application.
1.0
The name of the class containing the public static void main(String[]) method of the application.
1.0
Each argument contains (in order) an additional argument to be passed to main.
1.0
yes
yes
Denotes this is the jnlp file for an applet.
1.0
main-class
This is the name of the main Applet class.
1.0
documentbase
The document base for the Applet as a URL.
1.0
name
Name of the Applet.
1.0
yes
width
The width of the applet in pixels.
1.0
yes
height
The height of the applet in pixels
1.0
yes
param
yes
A set of parameters that can be passed into the applet.
1.0
name
The name of this parameter
1.0
yes
value
The value of this parameter
1.0
yes
Denotes this is the jnlp file for a component extension.
1.0
Denotes this is the jnlp file for an installed extension.
1.0
The name of the class containing the public static void main(String[]) method of the installer.
1.0
component-desc installer-desc main-class
yes
The JNLP file is an XML document. The following shows a complete example of a JNLP file.
Example <jnlp spec="6.0+" codebase="http://my_company.com/jaws/apps" href="swingset2.jnlp">
The example shows the basic outline of the document. The root element is jnlp, which has four subelements: information, security, resources, and application-desc. In addition, Java Web Start also supports launching applets by using the applet-desc element. The elements are described in more detail below.
JNLP Elements jnlp Element spec attribute: This attribute must be 1.0 or higher to work with this release. The default value is "1.0+". Thus, it can typically be omited. Note that this version supports both spec version 1.0, version 1.5, and version 6.0, whereas previous versions support only 1.0 and 1.5. A jnlp file specifying spec="6.0+" will work with this version, but not previous versions of Java Web Start. codebase attribute: All relative URLs specified in href attributes in the JNLP file are using this URL as a base. href attribute: This is a URL pointing to the location of the JNLP file itself.
information Element title element: The name of the application. vendor element: The name of the vendor of the application. homepage element: Contains a single attribute, href, which is a URL locating the home page for the Application. It is used by the Java Application Cache Viewer to point the user to a Web page
where more information about the application can be found. description element: A short statement about the application. Description elements are optional. The kind attribute defines how the description should be used. It can have one of the following
values:
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
one-line: If a reference to the application is going to appear on one row in a list or a table, this description will be used. short: If a reference to the application is going to be displayed in a situation where there is room for a paragraph, this description is used. tooltip: If a reference to the application is going to appear in a tooltip, this description is used.
Only one description element of each kind can be specified. A description element without a kind is used as a default value. Thus, if Java Web Start needs a description of kind short, and it is not specified in the JNLP file, then the text from the description without an attribute is used. All descriptions contain plain text. No formatting, such as with HTML tags, is supported. icon element: Contains an HTTP URL to an image file in either GIF or JPEG format. The icons are used to represents the application
during launch when Java Web Start presents the application to the user; in the Java Application Cache Viewer; in desktop shortcuts.
A 64x64 icon is shown during download; in the Java Application Cache Viewer and in desktop shortcuts a 32x32 icon is used. Java Web Start automatically resizes an icon to the appropriate size. Optional width and height attributes can be used to indicate the size of the images. The optional kind="splash" attribute may be used in an icon element to indicate that the image is to be used as a "splash" screen during the launch of an application. If the JNLP file does not contain an icon element with kind="splash" attribute, Java Web Start will construct a splash screen using other items from the information Element. If the JNLP file does not contain any icon images, the splash image will consist of the application's title and vendor, as taken from the JNLP file. The first time an application is launched following the addition or modification of the icon element in the JNLP file, the old splash image will still be displayed. The new splash image will appear on the second and subsequent launches of the application. offline-allowed element: The optional offline-allowed element indicates if the application can be launched offline.
If offline-allowed is specified, then the application can be launched offline by the Java Application Cache Viewer, and shortcuts can be created which launch the application offline. If an application is launched offline, it will not check for updates and the API call BasicService.isOffline() will return true. The offline-allowed element also controls how Java Web Start checks for an update to an application. If the element is not specified—i.e., the application is required to be online to run—Java Web Start will always check for an updated version before launching the application. And if an update is found, the new application will be downloaded and launched. Thus, it is guaranteed that the user always runs the latest version of the application. The application, however, must be run online. If offline-allowed is specified, Java Web Start will also check to see if an update is available. However, if the application is already downloaded the check will timeout after a few seconds, in which case the cached application will be launched instead. Given a reasonably fast server connection, the latest version of the application will usually be run, but it is not guaranteed. The application, however, can be run offline. shortcut element: The optional shortcut element can be used to indicate an application's preferences for desktop integration. The shortcut element and it's sub-elements provide hints that the JNLP Client may or may not use. The shortcut element can contain the optional online attribute, and the two optional sub-elements, desktop and menu. association element: The optional association element is a hint to the JNLP client that it wishes to be registered with the operating system as the primary handler of certain extensions and a certain
mime-type. The association element must have the extensions and mime-type attributes.
related-content element: The optional related-content element describes an additional piece of related content, such as a readme file, help pages, or links to registration pages, as a hint to a JNLP
Client. The application is asking that this content be included in its desktop integration. The related-content element has a mandatory href and title attribute. It can contain any of the following two sub-elements:
description element: A short description of the related content. icon element: The icon can be used by the JNLP Client to identify the related content to the user.
security Element Each application is, by default, run in a restricted execution environment, similar to the Applet sandbox. The security element can be used to request unrestricted access. If the all-permissions element is specified, the application will have full access to the client machine and local network. If an application requests full access, then all JAR files must be signed. The user will be prompted to accept the certificate the first time the application is launched. update Element The update element is used to indicate the preferences for how application updates should be handled by Java Web Start. The update element can contain the following two optional attributes: check attribute: The check attribute indicates the preference for when the JNLP Client should check for updates, and can have one of the three values: "always", "timeout", and "background"
A value of "always" means to always check for updates before launching the application. A value of "timeout" (default) means to check for updates until timeout before launching the application. If the update check is not completed before the timeout, the application is launched, and the update check will continue in the background. A value of "background" means to launch the application while checking for updates in the background. policy attribute: The policy attribute indicates the preference for how the JNLP Client should handle an application update when it is known an update is available before the application is
launched, and can have one of the following three values: "always", "prompt-update", and "prompt-run" A value of "always" (default) means to always download updates without any prompt. A value of "prompt-update" means to ask the user if he/she wants to download and run the updated version, or launch the cached version. A value of "prompt-run" means to ask the user if he/she wants to download and run the updated version, or cancel and abort runing the application. For example:
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
The resources element has six different possible subelements: jar, nativelib, j2se, property, package, and extension. The package and extension elements are not discussed in this developer's guide. See the Java Network Launching Protocol & API Specification (JSR-56) version 6.0 for details. A jar element specifies a JAR file that is part of the application's classpath. For example: <jar href="myjar.jar"/>
The jar file will be loaded into the JVM using a ClassLoader object. The jar file will typically contain Java classes that contain the code for the particular application, but can also contain other resources, such as icons and configuration files, that are available through the getResource mechanism. A nativelib element specifies a JAR file that contains native libraries. For example:
By default, jar and nativelib resources will be downloaded eagerly, i.e., they are downloaded and available locally to the JVM running the application before the application is launched. The jar and nativelib elements also allow a resource to be specified as lazy. This means the resource does not have to be downloaded onto the client system before the application is launched. The download attribute is used to control whether a resource is downloaded eagerly or lazily. For example: <jar href="sound.jar" download="lazy"/>
The j2se element specifies what Java(TM) Platform Standard Edition Runtime Environment (JRE) versions an application is supported on, as well as standard parameters to the Java Virtual Machine. If several JREs are specified, this indicates a prioritized list of the supported JREs, with the most preferred version first. For example: <j2se version="1.3" initial-heap-size="64m" max-heap-size="128m"/> <j2se version="1.4.2+" href="http://java.sun.com/products/autodl/j2se" java-vm-args="-esa -Xnoclassgc"/> The version attribute refers, by default, to a platform version (specification version) of the Java(TM) Platform Standard Edition. Currently defined platform versions are 1.2, 1.3, 1.4, 1.5 and 1.6. (A platform version will not normally contain a micro version number; e.g., 1.4.2.) Exact product versions (implementation versions) may also be specified. by including the href attribute. For example, 1.3.1_07, 1.4.2, or 1.5.0-beta2 by Sun Microsystems, Inc. For example, <j2se version="1.4.2" href="http://java.sun.com/products/autodl/j2se"/ or <j2se version="1.4.2_04" href="http://java.sun.com/products/autodl/j2se"/> If a platform version is specified (i.e., no href attribute is provided), Java Web Start will not consider an installed non-FCS (i.e., milestone) JRE as a match. E.g., a request of the form <j2se version="1.4+"/>
would not consider an installed 1.4.1-ea or 1.4.2-beta JRE as a match for the request. Starting with 1.3.0, a JRE from Sun Microsystems, Inc., is by convention a non-FCS (milestone) JRE if there is a dash (-) in the version string. The java-vm-args attribute of the j2se element specifies a preferred set of virtual machine arguments to use when launching java. <j2se version="1.4+" java-vm-args="-ea -Xincgc"/>
The following java-vm-args are supported by this version: -d32,
/* use a 32-bit data model if available */ -client, /* to select the client VM */ -server, /* to select the server VM */ -verbose, /* enable verbose output */ -version, /* print product version and exit */ -showversion, /* print product version and continue */ -help, /* print this help message */ -X, /* print help on non-standard options */ -ea, /* enable assertions */ -enableassertions, /* enable assertions */ -da, /* disable assertions */ -disableassertions, /* disable assertions */ -esa, /* enable system assertions */ -enablesystemassertions, /* enable system assertions */ -dsa, /* disable system assertione */ -disablesystemassertions, /* disable system assertione */ -Xmixed, /* mixed mode execution (default) */ -Xint, /* interpreted mode execution only */ -Xnoclassgc, /* disable class garbage collection */ -Xincgc, /* enable incremental garbage collection */ -Xbatch, /* disable background compilation */ -Xprof, /* output cpu profiling data */ -Xdebug, /* enable remote debugging */ -Xfuture, /* enable strictest checks, anticipating future default */ -Xrs, /* reduce use of OS signals by Java/VM (see documentation) */ -XX:+ForceTimeHighResolution, /* use high resolution timer */ -XX:-ForceTimeHighResolution, /* use low resolution (default) */
Plus any argument starting with one of the following: -ea, /* enable assertions for classes */ -enableassertions, /* enable assertions for classes */ -da, /* disable assertions for classes */ -disableassertions, /* disable assertions for classes */ -verbose, /* enable verbose output */ -Xms, /* set initial Java heap size */ -Xmx, /* set maximum Java heap size */
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
-Xss, /* set java thread stack size */ -XX:NewRatio, /* set Ratio of new/old gen sizes */ -XX:NewSize, /* set initial size of new generation */ -XX:MaxNewSize, /* set max size of new generation */ -XX:PermSize, /* set initial size of permanent gen */ -XX:MaxPermSize, /* set max size of permanent gen */ -XX:MaxHeapFreeRatio, /* heap free percentage (default 70) */ -XX:MinHeapFreeRatio, /* heap free percentage (default 40) */ -XX:UseSerialGC, /* use serial garbage collection */ -XX:ThreadStackSize, /* thread stack size (in KB) */ -XX:MaxInlineSize, /* set max num of bytecodes to inline */ -XX:ReservedCodeCacheSize, /* Reserved code cache size (bytes) */ -XX:MaxDirectMemorySize,
The property element defines a system property that will be available through the System.getProperty and System.setProperties methods. It has two required attributes: name and value. For example: <property name="key" value="overwritten"/> Properties set in the jnlp file will normally be set by Java Web Start after the VM is started but before the application is invoked. Some properties are considered "secure" properties and can be passed as -Dkey=value arguments on the java invocation command line. The following properties are considered "secure" and will be passed to the VM in this way: sun.java2d.noddraw, javax.swing.defaultlf, javaws.cfg.jauthenticator, swing.useSystemFontSettings, swing.metalTheme, http.agent, http.keepAlive, sun.awt.noerasebackground, sun.java2d.opengl, sun.java2d.d3d, java.awt.syncLWRequests, java.awt.Window.locationByPlatform, sun.awt.erasebackgroundonresize, swing.noxp, swing.boldMetal, awt.useSystemAAFontSettings, sun.java2d.dpiaware,
For an untrusted application, system properties set in the JNLP file will only be set by Java Web Start if they are considered secure, or if the property name begins with "jnlp." or "javaws.". application-desc Element The application element indicates that the JNLP file is launching an application (as opposed to an applet). The application element has an optional attribute, main-class, which can be used to specify the name of the application's main class, i.e., the class that contains the public static void main(String argv[]) method where execution must begin. The main-class attribute can be omitted if the first JAR file specified in the JNLP file contains a manifest file containing the main class. Arguments can be specified to the application by including one or more nested argument elements. For example:
applet-desc Element Java Web Start has support for launching Java applets. This support provides easy migration of existing code to Java Web Start. An applet is launched using the applet-desc element instead of the application-desc element. For example:
The JAR files that make up the applet are described using the resources element as for applications. The documentBase must be provided explicitly since a JNLP file is not embedded in an HTML page. The rest of the attributes correspond to the respective HTML applet tag elements. The main-class attribute is used instead of the code attribute. The main-class attribute is assigned the name of the Applet class (without the .class extension). This attribute can be omitted if the Applet class can be found from the Main-Class manifest entry in the main JAR file. Note: Applets must be packaged in JAR files in order to work with Java Web Start. component-desc Element The component-desc element denotes that this jnlp file is not an application or an applet but an extension that can be used as a resource in an application, applet or another extension. A component extension is typically used to factor out a set of resources that are shared between multiple applications or that have separate security needs. installer-desc Element The installer-desc element denotes that this jnlp file is an installer extension that defines an application that will be run only once, the first time this extension jnlp file is used in an application, applet or another extension. An installer extension is typically used to install platform specific native code that requires a more complicated setup than simply loading a native library into the VM.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/syntax.html
JNLP API Examples Select a Chapter/Topic
This chapter includes the following topics:
Introduction Using a BasicService Service Using a ClipboardService Service Using a DownloadService Service Using a FileOpenService Service Using a FileSaveService Service Using a PrintService Service Using a PersistenceService Service Using FileContents Using a JNLPRandomAccessFile Using a SingleInstanceService Service Using a ExtendedService Service
Introduction The JNLP API is designed to provide additional information to the application that would otherwise not be available using the standard Java(TM) Platform Standard Edition API. The following code examples show how the following services can be used: BasicService, ClipboardService, DownloadService, FileOpenService, FileSaveService, PrintService, and PersistenceService.
The public classes and interfaces in the JNLP API are included in the jnlp.jar file. This JAR file must be included in the classpath when compiling source files that use the JNLP API. For example on Windows: javac -classpath .;jnlp.jar *.java
The jnlp.jar file is included in the JNLP Developers Pack.
Using a BasicService Service The javax.jnlp.BasicService service provides a set of methods for querying and interacting with the environment similar to what the AppletContext provides for a Java Applet. The showURL method uses the JNLP API to direct the default browser on the platform to show the given URL. The method returns true if the request succeeds, otherwise false. import javax.jnlp.*; ... // Method to show a URL boolean showURL(URL url) { try { // Lookup the javax.jnlp.BasicService object BasicService bs = (BasicService)ServiceManager.lookup("javax.jnlp.BasicService"); // Invoke the showDocument method return bs.showDocument(url);
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
} catch(UnavailableServiceException ue) { // Service is not supported return false; } }
Using a ClipboardService Service The javax.jnlp.ClipboardService service provides methods for accessing the shared system-wide clipboard, even for applications that are running in the restricted execution environment. Java Web Start will warn the user of the potential security risk of letting an untrusted application access potentially confidential information stored in the clipboard, or overwriting contents stored in the clipboard. import javax.jnlp; ... private ClipboardService cs; try { cs = (ClipboardService)ServiceManager.lookup ("javax.jnlp.ClipboardService"); } catch (UnavailableServiceException e) { cs = null; } if (cs != null) { // set the system clipboard contents to a string selection StringSelection ss = new StringSelection("Java Web Start!"); cs.setContents(ss); // get the contents of the system clipboard and print them Transferable tr = cs.getContents(); if (tr.isDataFlavorSupported(DataFlavor.stringFlavor)) { try { String s = (String)tr.getTransferData(DataFlavor.stringFlavor); System.out.println("Clipboard contents: " + s); } catch (Exception e) { e.printStackTrace(); } } }
Using a DownloadService Service The javax.jnlp.DownloadService service allows an application to control how its own resources are cached. The service allows an application to determine which of its resources are cached, to force resources to be cached, and to remove resources from the cache. import javax.jnlp.*; ... DownloadService ds; try { ds = (DownloadService)ServiceManager.lookup("javax.jnlp.DownloadService"); } catch (UnavailableServiceException e) { ds = null; }
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
if (ds != null) { try { // determine if a particular resource is cached URL url = new URL("http://java.sun.com/javase/technologies/desktop/javawebstart/lib/draw.jar"); boolean cached = ds.isResourceCached(url, "1.0"); // remove the resource from the cache if (cached) { ds.removeResource(url, "1.0"); } // reload the resource into the cache DownloadServiceListener dsl = ds.getDefaultProgressWindow(); ds.loadResource(url, "1.0", dsl); } catch (Exception e) { e.printStackTrace(); } }
Using a FileOpenService Service The javax.jnlp.FileOpenService service provides methods for importing files from the local disk, even for applications that are running in the restricted execution environment. This interface is designed to provide the same kind of of disk access to potentially untrusted Web-deployed applications that a Web developer has when using HTML. HTML forms support the inclusion of files by displaying a file open dialog. import javax.jnlp.*; ... FileOpenService fos; try { fos = (FileOpenService)ServiceManager.lookup("javax.jnlp.FileOpenService"); } catch (UnavailableServiceException e) { fos = null; } if (fos != null) { try { // ask user to select a file through this service FileContents fc = fos.openFileDialog(null, null); // ask user to select multiple files through this service FileContents[] fcs = fos.openMultiFileDialog(null, null); } catch (Exception e) { e.printStackTrace(); } }
Using a FileSaveService Service The javax.jnlp.FileSaveService service provides methods for exporting files to the local disk, even for applications that are running in the restricted execution environment. This interface is designed to provide the same level of disk access to potentially untrusted Web-deployed applications that a Web browser provides for contents that it is displaying. Most browsers provide a Save As... dialog as part of their user interface. import javax.jnlp.*; ... FileSaveService fss;
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
FileOpenService fos; try { fos = (FileOpenService)ServiceManager.lookup("javax.jnlp.FileOpenService"); fss = (FileSaveService)ServiceManager.lookup ("javax.jnlp.FileSaveService"); } catch (UnavailableServiceException e) { fss = null; fos = null; } if (fss != null && fos != null) { try { // get a file with FileOpenService FileContents fc = fos.openFileDialog(null, null); // one way to save a file FileContents newfc = fss.saveFileDialog(null, null, fc.getInputStream(), "newFileName.txt"); // another way to save a file FileContents newfc2 = fss.saveAsFileDialog(null, null, fc); } catch (Exception e) { e.printStackTrace(); } }
Also see Using FileContents.
Using a PrintService Service The javax.jnlp.PrintService service provides methods for access to printing, even for applications that are running in the restricted execution environment. Using this service, an application can submit a print job. Java Web Start will then show this request to the user and, if accepted, queue the request to the printer. In Java Web Start 5.0, you can now directly use the Java Printing APIs, and Java Web Start will pop up a security dialog asking the user to grant PrintPermission if the application is running in a sandbox. There is no need to use the JNLP Printing APIs anymore. You can have full access to the Java Printing APIs in any JNLP application. import javax.jnlp.*; ... PrintService ps; try { ps = (PrintService)ServiceManager.lookup("javax.jnlp.PrintService"); } catch (UnavailableServiceException e) { ps = null; } if (ps != null) { try { // get the default PageFormat PageFormat pf = ps.getDefaultPage(); // ask the user to customize the PageFormat PageFormat newPf = ps.showPageFormatDialog(pf); // print the document with the PageFormat above ps.print(new DocToPrint()); } catch (Exception e) { e.printStackTrace();
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
} }
// Code to construct the Printable Document class DocToPrint implements Printable { public int print(Graphics g, PageFormat pageformat, int PageIndex){ // code to generate what you want to print } }
Using a PersistenceService Service The javax.jnlp.PersistenceService service provides methods for storing data locally on the client system, even for applications that are running in the restricted execution environment.
The service is designed to be somewhat similar to that which the cookie mechanism provides to HTML-based applications. Cookies allow a small amount of data to be stored locally on the client system. That data can be securely managed by the browser and can only be retrieved by HTML pages which originate from the same URL as the page that stored the data. import javax.jnlp.*; ... PersistenceService ps; BasicService bs; try { ps = (PersistenceService)ServiceManager.lookup("javax.jnlp.PersistenceService"); bs = (BasicService)ServiceManager.lookup("javax.jnlp.BasicService"); } catch (UnavailableServiceException e) { ps = null; bs = null; } if (ps != null && bs != null) { try { // find all the muffins for our URL URL codebase = bs.getCodeBase(); String [] muffins = ps.getNames(url); // get the attributes (tags) for each of these muffins. // update the server's copy of the data if any muffins // are dirty int [] tags = new int[muffins.length]; URL [] muffinURLs = new URL[muffins.length]; for (int i = 0; i < muffins.length; i++) { muffinURLs[i] = new URL(codebase.toString() + muffins[i]); tags[i] = ps.getTag(muffinURLs[i]); // update the server if anything is tagged DIRTY if (tags[i] == PersistenceService.DIRTY) { doUpdateServer(muffinURLs[i]); } } // read in the contents of a muffin and then delete it FileContents fc = ps.get(muffinURLs[0]); long maxsize = fc.getMaxLength(); byte [] buf = new byte[fc.getLength()]; InputStream is = fc.getInputStream(); long pos = 0; while((pos = is.read(buf, pos, buf.length - pos)) > 0) { // just loop } is.close(); ps.delete(muffinURLs[0]);
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
// re-create the muffin and repopulate its data ps.create(muffinURLs[0], maxsize); fc = ps.get(muffinURLs[0]); // don't append OutputStream os = fc.getOutputStream(false); os.write(buf); os.close(); } catch (Exception e) { e.printStackTrace(); } } void doUpdateServer(URL url) { // update the server's copy of the persistent data // represented by the given URL ... ps.setTag(url, PersistenceService.CACHED); }
Using FileContents javax.jnlp.FileContents objects encapsulate the name and contents of a file. An object of this class is used by the FileOpenService, FileSaveService and PersistenceService. Here is an example of how an instance of a FileContents can
be used to read from and write to a file:
import javax.jnlp.*; ... FileOpenService fos; //Initialize fos (see Using a FileOpenService Service example) ... if (fos != null) { try { // get a FileContents object to work with from the // FileOpenService FileContents fc = fos.openFileDialog(null, null); // get the InputStream from the file and read a few bytes byte [] buf = new byte[fc.getLength()]; InputStream is = fc.getInputStream(); int pos = 0; while ((pos = is.read(buf, pos, buf.length - pos)) > 0) { // just loop } is.close(); // get the OutputStream and write the file back out if (fc.canWrite()) { // don't append OutputStream os = fc.getOutputStream(false); os.write(buf); } } catch (Exception e) { e.printStackTrace(); } }
Using a JNLPRandomAccessFile http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
Instances of javax.jnlp.JNLPRandomAccessFile support both reading and writing to a random access file. A random access file behaves like a large array of bytes stored in the file system. Here is an example of how an instance of a JNLPRandomAccessFile can be used to write to a random access file: import javax.jnlp.*; ... FileOpenService fos; //Initialize fos (see Using a FileOpenService Service example) ... if (fos != null) { try { // ask the user to choose a file to open FileContents fc = fos.openFileDialog(null, null); // attempt to increase the maximum file length long grantedLength = fc.getLength(); if (grantedLength + 1024 > fc.getMaxLength()) { // attempt to increase the maximum file size defined by // the client grantedLength = fc.setMaxLength(grantedLength + 1024); } // if we were able to increase the maximum allowable file size, // get a JNLPRandomAccessFile representation of the file, and // write to it if (fc.getMaxSize() > fc.getLength() && fc.canWrite()) { JNLPRandomAccessFile raf = fc.getRandomAccessFile("rw"); raf.seek(raf.length() - 1); raf.writeUTF("Java Web Start!"); raf.close(); } } catch (Exception e) { e.printStackTrace(); } }
Using a SingleInstanceService Service The javax.jnlp.SingleInstanceService provides a set of methods for applications to register themselves as singletons, and to register listener(s) for handling arguments passed in from different instances of applications. import javax.jnlp.*; ... SingleInstanceService sis; ... try { sis = (SingleInstanceService)ServiceManager.lookup("javax.jnlp.SingleInstanceService"); } catch (UnavailableServiceException e) { sis=null; } ... // Register the single instance listener at the start of your application SISListener sisL = new SISListener(); sis.addSingleInstanceListener(sisL); ...
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
// Remember to remove the listener before your application exits sis.removeSingleInstanceListener(sisL); System.exit(0);
// Implement the SingleInstanceListener for your application class SISListener implements SingleInstanceListener { public void newActivation(String[] params) { // your code to handle the new arguments here ... } }
Using an ExtendedService Service The javax.jnlp.ExtendedService provides additional support to the current JNLP API. It allows applications to open specific file(s) in the client's file system. import javax.jnlp.*; ... ExtendedService es; ... try { es = (ExtendedService)ServiceManager.lookup("javax.jnlp.ExtendedService"); } catch (UnavailableServiceException e) { es=null; } ... // Open a specific file in the local machine File a = new File("c:\somefile.txt"); ... // Java Web Start will pop up a dialog asking the user to grant permission // to read/write the file c:\somefile.txt FileContents fc_a = es.openFile(a); // You can now use the FileContents object to read/write the file ... // Open a specific set of files in the local machine File[2] fArray = new File[2]; fArray[0] = a; fArray[1] = new File("c:\anotherFile.txt"); // Java Web Start will pop up a dialog asking the user to grant permission // to read/write files in fArray
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
FileContents[] fc_Array = es.OpenFiles(fArray); // You can now read/write the set of files in fc_Array using the // FileContents objects }
For detailed information on using javaws, see the javaws Command Line Interface.
http://java.sun.com/javase/6/docs/technotes/guides/javaws/developersguide/examples.html
Package Class Tree Index PREV PACKAGE NEXT PACKAGE
FRAMES NO FRAMES All Classes
Package javax.jnlp Interface Summary BasicService ClipboardService
The BasicService interface provides access to the codebase of the application, if an application is run in offline mode, and simple interaction with the native browser on the given platform. ClipboardService provides methods for accessing the shared system-wide clipboard, even for
applications that are running in the untrusted execution environment.
DownloadService
DownloadService service allows an application to control how its own resources are cached, to determine which of its resources are currently cached, to force resources to be cached, and to remove resources from the cache.
DownloadServiceListener
The DownloadServiceListener provides an interface for a callback object implementation, which may be used by a DownloadService implementation.
ExtendedService
ExtendedService provides additional support to the current JNLP API, which allow
applications to open a specific file in the client's file system.
ExtensionInstallerService
The ExtensionInstallerService is used by an extension installer to communicate with the JNLP Client.
FileContents
FileContents objects encapsulate the name and contents of a file.
FileOpenService
FileOpenService service allows the user to choose a file from the local file system, even for applications that are running in the untrusted execution environment.
FileSaveService
FileSaveService service allows the user to save a file to the local file system, even for applications that are running in the untrusted execution environment.
JNLPRandomAccessFile Instances of this class support both reading and writing to a random access file. PersistenceService PrintService ServiceManagerStub SingleInstanceListener SingleInstanceService
PersistenceService provides methods for storing data locally on the client system, even for
applications that are running in the untrusted execution environment.
PrintService provides methods for access to printing functions, even for applications that are
running in the untrusted execution environment.
A ServiceManagerStub object implements the particular lookup of JNLP services by the JNLP Client. SingleInstanceListener is a interface which should be implemented by a JNLP application if
they wish to support single instance behaviour. SingleInstanceService allow applications launched under Java Web Start to register
themselves as singletons, and to be passed in new parameter sets when user attempts to launch new instances of them.
Class Summary ServiceManager The ServiceManager provides static methods to lookup JNLP services.
Exception Summary http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/package-summary.html
UnavailableServiceException
The UnavailableServiceException is thrown by the ServiceManager when a nonexisting or unavailable service is looked up.
Package Class Tree Index PREV PACKAGE NEXT PACKAGE
FRAMES NO FRAMES All Classes
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/package-summary.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface BasicService public interface BasicService
The BasicService interface provides access to the codebase of the application, if an application is run in offline mode, and simple interaction with the native browser on the given platform. This interface mimics loosely the AppletContext functionality. Since: 1.0
Method Summary java.net.URL
getCodeBase()
Returns the codebase for the application. boolean
isOffline()
Determines if the system is offline. boolean
isWebBrowserSupported()
Checks if a Web browser is supported on the current platform and by the given JNLP Client. boolean
showDocument(java.net.URL url)
Directs a browser on the client to show the given URL.
Method Detail getCodeBase java.net.URL getCodeBase()
Returns the codebase for the application. The codebase is either specified directly in the JNLP file, or it is the location of the JAR file containing the main class of the application. Returns: a URL with the codebase of the application
isOffline boolean isOffline()
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/BasicService.html
Determines if the system is offline. The return value represents the JNLP client's "best guess" at the online / offline state of the client system. The return value is does not have to be guaranteed to be reliable, as it is sometimes difficult to ascertain the true online / offline state of a client system. Returns: true if the system is offline, otherwise false
showDocument boolean showDocument(java.net.URL url)
Directs a browser on the client to show the given URL. This will typically replace the page currently being viewed in a browser with the given URL, or cause a browser to be launched that will show the given URL. Parameters: url - an URL giving the location of the document. A relative URL will be relative to the codebase. Returns: true if the request succeded, otherwise false
isWebBrowserSupported boolean isWebBrowserSupported()
Checks if a Web browser is supported on the current platform and by the given JNLP Client. If this is not the case, then showDocument(java.net.URL) will always return false. Returns: true if a Web browser is supported, otherwise false
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/BasicService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface ClipboardService public interface ClipboardService ClipboardService provides methods for accessing the shared system-wide clipboard, even for applications that are running in the
untrusted execution environment. Implementors should warn the user of the potential security risk of letting an untrusted application have access to potentially confidential information stored in the clipboard, or overwriting the contents of the clipboard. Since: 1.0
Method Summary java.awt.datatransfer.Transferable
getContents()
Returns a Transferable object representing the current contents of the clipboard. void
setContents(java.awt.datatransfer.Transferable contents) Sets the current contents of the clipboard to the specified Transferable object.
Method Detail getContents java.awt.datatransfer.Transferable getContents()
Returns a Transferable object representing the current contents of the clipboard. If the clipboard currently has no contents, it returns null. Returns: The current Transferable object on the clipboard.
setContents void setContents(java.awt.datatransfer.Transferable contents)
Sets the current contents of the clipboard to the specified Transferable object. Parameters: contents
- The Transferable object representing clipboard content.
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ClipboardService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface DownloadService public interface DownloadService DownloadService service allows an application to control how its own resources are cached, to determine which of its
resources are currently cached, to force resources to be cached, and to remove resources from the cache. The JNLP Client is responsible for providing a specific implementation of this service. Since: 1.0
Method Summary DownloadServiceListener
getDefaultProgressWindow() Return a default DownloadServiceListener implementation which, when passed to a load
method, should pop up and update a progress window as the load progresses. boolean
isExtensionPartCached(java.net.URL ref, java.lang.String version, java.lang.String part) Returns true if the given part of the given extension is cached, and the extension and part are
mentioned in the JNLP file for the application.
boolean
isExtensionPartCached(java.net.URL ref, java.lang.String version, java.lang.String[] parts) Returns true if the given parts of the given extension are cached, and the extension and parts
are mentioned in the JNLP file for the application.
boolean
isPartCached(java.lang.String part) Returns true if the part referred to by the given string is cached, and that part is mentioned in
the JNLP file for the application.
boolean
isPartCached(java.lang.String[] parts) Returns true if the parts referred to by the given array are cached, and those parts are
mentioned in the JNLP file for the application.
boolean
isResourceCached(java.net.URL ref, java.lang.String version) Returns true if the resource referred to by the given URL and version is cached, and that
resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or the calling application has been granted all-permissions.
void
loadExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String [] parts, DownloadServiceListener progress)
Downloads the given parts of the given extension, if the parts and the extension are mentioned in the JNLP file for the application. void
loadExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String part, DownloadServiceListener progress)
Downloads the given part of the given extension, if the part and the extension are mentioned in the JNLP file for the application. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
void
loadPart(java.lang.String[] parts, DownloadServiceListener progress)
Downloads the given parts, if the parts are mentioned in the JNLP file for the application. void
loadPart(java.lang.String part, DownloadServiceListener progress)
Downloads the given part, if the part is mentioned in the JNLP file for the application. void
loadResource(java.net.URL ref, java.lang.String version, DownloadServiceListener progress)
Downloads the given resource, if the resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or if the calling application has been granted all-permissions. void
removeExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String part)
Removes the given part of the given extension from the cache, if the part and the extension are mentioned in the JNLP file for the application. void
removeExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String [] parts)
Removes the given parts of the given extension from the cache, if the parts and the extension are mentioned in the JNLP file for the application. void
removePart(java.lang.String part)
Removes the given part from the cache, if the part is mentioned in the JNLP file for the application. void
removePart(java.lang.String[] parts)
Removes the given parts from the cache, if the parts are mentioned in the JNLP file for the application. void
removeResource(java.net.URL ref, java.lang.String version)
Removes the given resource from the cache, if the resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or if the calling application has been granted all-permissions.
Method Detail isResourceCached boolean isResourceCached(java.net.URL ref, java.lang.String version)
Returns true if the resource referred to by the given URL and version is cached, and that resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or the calling application has been granted all-permissions. . Parameters: ref - The URL for the resource. version - The version string, or null for no version. Returns: true if the above conditions are met, and false otherwise.
isPartCached boolean isPartCached(java.lang.String part)
Returns true if the part referred to by the given string is cached, and that part is mentioned in the JNLP file for the http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
application. Parameters: part - The name of the part. Returns: true if the above conditions are met, and false otherwise.
isPartCached boolean isPartCached(java.lang.String[] parts)
Returns true if the parts referred to by the given array are cached, and those parts are mentioned in the JNLP file for the application. Parameters: parts - An array of part names. Returns: true if the above conditions are met, and false otherwise.
isExtensionPartCached boolean isExtensionPartCached(java.net.URL ref, java.lang.String version, java.lang.String part)
Returns true if the given part of the given extension is cached, and the extension and part are mentioned in the JNLP file for the application. Parameters: ref - The URL for the resource. version - The version string, or null for no version. part - The name of the part. Returns: true if the above conditions are met, and false otherwise.
isExtensionPartCached boolean isExtensionPartCached(java.net.URL ref, java.lang.String version, java.lang.String[] parts)
Returns true if the given parts of the given extension are cached, and the extension and parts are mentioned in the JNLP file for the application. Parameters: ref - The URL for the resource. version - The version string, or null for no version. parts - An array of part names. Returns: true if the above conditions are met, and false otherwise. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
loadResource void loadResource(java.net.URL ref, java.lang.String version, DownloadServiceListener progress) throws java.io.IOException
Downloads the given resource, if the resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or if the calling application has been granted all-permissions. This method will block until the download is completed or an exception occurs. Parameters: ref - The URL for the resource. version - The version string, or null for no version. progress - Download progress callback object. Throws: java.io.IOException
loadPart void loadPart(java.lang.String part, DownloadServiceListener progress) throws java.io.IOException
Downloads the given part, if the part is mentioned in the JNLP file for the application. This method will block until the download is completed or an exception occurs. Parameters: part - The name of the part. progress - Download progress callback object. Throws: java.io.IOException
loadPart void loadPart(java.lang.String[] parts, DownloadServiceListener progress) throws java.io.IOException
Downloads the given parts, if the parts are mentioned in the JNLP file for the application. This method will block until the download is completed or an exception occurs. Parameters: parts - An array of part names. progress - Download progress callback object. Throws: java.io.IOException
loadExtensionPart http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
void loadExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String part, DownloadServiceListener progress) throws java.io.IOException
Downloads the given part of the given extension, if the part and the extension are mentioned in the JNLP file for the application. This method will block until the download is completed or an exception occurs. Parameters: ref - The URL for the resource. version - The version string, or null for no version. part - The name of the part. progress - Download progress callback object. Throws: java.io.IOException
loadExtensionPart void loadExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String[] parts, DownloadServiceListener progress) throws java.io.IOException
Downloads the given parts of the given extension, if the parts and the extension are mentioned in the JNLP file for the application. This method will block until the download is completed or an exception occurs. Parameters: ref - The URL for the resource. version - The version string, or null for no version. parts - An array of part names to load. progress - Download progress callback object. Throws: java.io.IOException
removeResource void removeResource(java.net.URL ref, java.lang.String version) throws java.io.IOException
Removes the given resource from the cache, if the resource is either mentioned in the calling applications JNLP file, is within the codebase of the calling applications JNLP file, or if the calling application has been granted all-permissions. Parameters: ref - The URL for the resource. version - The version string, or null for no version. Throws: java.io.IOException
removePart http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
void removePart(java.lang.String part) throws java.io.IOException
Removes the given part from the cache, if the part is mentioned in the JNLP file for the application. Parameters: part - The name of the part. Throws: java.io.IOException
removePart void removePart(java.lang.String[] parts) throws java.io.IOException
Removes the given parts from the cache, if the parts are mentioned in the JNLP file for the application. Parameters: parts - An array of part names. Throws: java.io.IOException
removeExtensionPart void removeExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String part) throws java.io.IOException
Removes the given part of the given extension from the cache, if the part and the extension are mentioned in the JNLP file for the application. Parameters: ref - The URL for the resource. version - The version string, or null for no version. part - The name of the part. Throws: java.io.IOException
removeExtensionPart void removeExtensionPart(java.net.URL ref, java.lang.String version, java.lang.String[] parts) throws java.io.IOException
Removes the given parts of the given extension from the cache, if the parts and the extension are mentioned in the JNLP file for the application. Parameters: ref - The URL for the resource. version - The version string, or null for no version. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
parts
- An array of part names.
Throws:
java.io.IOException
getDefaultProgressWindow DownloadServiceListener getDefaultProgressWindow()
Return a default DownloadServiceListener implementation which, when passed to a load method, should pop up and update a progress window as the load progresses. Returns: A DownloadServiceListener object representing a download progress listener. Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface DownloadServiceListener public interface DownloadServiceListener
The DownloadServiceListener provides an interface for a callback object implementation, which may be used by a DownloadService implementation. The DownloadServiceListener implementation's methods should be invoked by the DownloadService implementation at various stages of the download, allowing an application that uses the JNLP API to display a progress bar during a DownloadService download. Since: 1.0 See Also: DownloadService
Method Summary void
downloadFailed(java.net.URL url, java.lang.String version) A JNLP client's DownloadService implementation should call this method if a download fails or aborts
unexpectedly. void
progress(java.net.URL url, java.lang.String version, long readSoFar, long total, int overallPercent) A JNLP client's DownloadService implementation should call this method several times during a download.
void
upgradingArchive(java.net.URL url, java.lang.String version, int patchPercent, int overallPercent) A JNLP client's DownloadService implementation should call this method at least several times when applying
an incremental update to an in-cache resource. void
validating(java.net.URL url, java.lang.String version, long entry, long total, int overallPercent) A JNLP client's DownloadService implementation should call this method at least several times during
validation of a download.
Method Detail progress void progress(java.net.URL url, java.lang.String version, long readSoFar, long total, int overallPercent)
A JNLP client's DownloadService implementation should call this method several times during a download. A http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadServiceListener.html
DownloadServiceListener implementation may display a progress bar and / or update information based on the
parameters.
Parameters: url - The URL representing the resource being downloaded. version - The version of the resource being downloaded. readSoFar - The number of bytes downloaded so far. total - The total number of bytes to be downloaded, or -1 if the number is unknown. overallPercent - The percentage of the overall update operation that is complete, or -1 if the percentage is unknown.
validating void validating(java.net.URL url, java.lang.String version, long entry, long total, int overallPercent)
A JNLP client's DownloadService implementation should call this method at least several times during validation of a download. Validation often includes ensuring that downloaded resources are authentic (appropriately signed). A DownloadServiceListener implementation may display a progress bar and / or update information based on the parameters. Parameters: url - The URL representing the resource being validated. version - The version of the resource being validated. entry - The number of JAR entries validated so far. total - The total number of entries to be validated. overallPercent - The percentage of the overall update operation that is complete, or -1 if the percentage is unknown.
upgradingArchive void upgradingArchive(java.net.URL url, java.lang.String version, int patchPercent, int overallPercent)
A JNLP client's DownloadService implementation should call this method at least several times when applying an incremental update to an in-cache resource. A DownloadServiceListener implementation may display a progress bar and / or update information based on the parameters. Parameters: url - The URL representing the resource being patched. version - The version of the resource being patched. patchPercent - The percentage of the patch operation that is complete, or -1 if the percentage is unknown. overallPercent - The percentage of the overall update operation that is complete, or -1 if the percentage is unknown.
downloadFailed http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadServiceListener.html
void downloadFailed(java.net.URL url, java.lang.String version)
A JNLP client's DownloadService implementation should call this method if a download fails or aborts unexpectedly. In response, a DownloadServiceListener implementation may display update information to the user to reflect this.
Parameters: url - The URL representing the resource for which the download failed. version - The version of the resource for which the download failed.
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/DownloadServiceListener.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface ExtendedService public interface ExtendedService ExtendedService provides additional support to the current JNLP API, which allow applications to open a specific file in the
client's file system. Since: 1.5
Method Summary FileContents
openFile(java.io.File file)
Asks the user the permission to open the specified file if the file has not been opened before. FileContents []
openFiles(java.io.File[] files)
Asks the user the permission to open the specified list of files if any of the files has not been opened before.
Method Detail openFile FileContents openFile(java.io.File file) throws java.io.IOException
Asks the user the permission to open the specified file if the file has not been opened before. The contents of the file is returned as a FileContents object. The returned FileContents object contains the contents the file. Parameters: file - the file object Returns: A FileContent object with information about the opened file Throws: java.io.IOException - - if there is any I/O error
openFiles FileContents[] openFiles(java.io.File[] files) throws java.io.IOException
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtendedService.html
Asks the user the permission to open the specified list of files if any of the files has not been opened before. The contents of each file is returned as a FileContents object in the FileContents array. The returned FileContents object contains the contents the file. Parameters: files - the array of files Returns: A FileContent[] object with information about each opened file Throws: java.io.IOException - - if there is any I/O error Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtendedService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface ExtensionInstallerService public interface ExtensionInstallerService
The ExtensionInstallerService is used by an extension installer to communicate with the JNLP Client. It provides the following type of functionality:
Access to prefered installation location, and other information about the JNLP Client Manipulation of the JNLP Client's download screen Methods for updating the JNLP Client with the installed code
The normal sequence of events for an installer is: 1. 2. 3. 4.
Get service using ServiceManager.lookup("javax.jnlp.ExtensionInstallerService"). Update status, heading, and progress as install progresses (setStatus, setHeading and updateProgress). Invoke either setJREInfo or setNativeLibraryInfo depending on if a JRE or a library is installed If successful invoke installSucceeded, otherwise invoke installFailed.
Since: 1.0
Method Summary java.net.URL
getExtensionLocation()
Returns the location of the extension being installed java.lang.String
getExtensionVersion()
Returns the version of the extension being installed java.lang.String
getInstalledJRE(java.net.URL url, java.lang.String version)
Returns the path to the executable for the given JRE. java.lang.String
getInstallPath()
Returns the directory where the installer is recommended to install the extension in. void
hideProgressBar()
Hides the progress bar. void
hideStatusWindow()
Hides the status window. void
installFailed()
This should be invoked if the install fails. void
installSucceeded(boolean needsReboot)
Installers should invoke this upon a succesful installation of the extension. void
setHeading(java.lang.String heading)
Updates the status of the installer process. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtensionInstallerService.html
void
setJREInfo(java.lang.String platformVersion, java.lang.String jrePath)
Informs the JNLP Client of the path to the executable for the JRE, if this is an installer for a JRE, and about platform-version this JRE implements. void
setNativeLibraryInfo(java.lang.String path)
Informs the JNLP Client of a directory where it should search for native libraries. void
setStatus(java.lang.String status)
Updates the status of the installer process. void
updateProgress(int value)
Updates the progress bar.
Method Detail getInstallPath java.lang.String getInstallPath()
Returns the directory where the installer is recommended to install the extension in. It is not required that the installer install in this directory, this is merely a suggested path.
getExtensionVersion java.lang.String getExtensionVersion()
Returns the version of the extension being installed
getExtensionLocation java.net.URL getExtensionLocation()
Returns the location of the extension being installed
hideProgressBar void hideProgressBar()
Hides the progress bar. Any subsequent calls to updateProgress will force it to be visible.
hideStatusWindow void hideStatusWindow()
Hides the status window. You should only invoke this if you are going to provide your own feedback to the user as to the progress of the install.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtensionInstallerService.html
setHeading void setHeading(java.lang.String heading)
Updates the status of the installer process.
setStatus void setStatus(java.lang.String status)
Updates the status of the installer process.
updateProgress void updateProgress(int value)
Updates the progress bar. Parameters: value - progress bar value - should be between 0 and 100.
installSucceeded void installSucceeded(boolean needsReboot)
Installers should invoke this upon a succesful installation of the extension. This will cause the JNLP Client to regain control and continue its normal operation. Parameters: needsReboot
- If true, a reboot is needed
installFailed void installFailed()
This should be invoked if the install fails. The JNLP Client will continue its operation, and inform the user that the install has failed.
setJREInfo void setJREInfo(java.lang.String platformVersion, java.lang.String jrePath)
Informs the JNLP Client of the path to the executable for the JRE, if this is an installer for a JRE, and about platformversion this JRE implements.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtensionInstallerService.html
setNativeLibraryInfo void setNativeLibraryInfo(java.lang.String path)
Informs the JNLP Client of a directory where it should search for native libraries.
getInstalledJRE java.lang.String getInstalledJRE(java.net.URL url, java.lang.String version)
Returns the path to the executable for the given JRE. This method can be used by extensions that needs to find information in a given JRE, or enhance a given JRE. Parameters: url - product location of the JRE version - product version of the JRE Returns: The path to the executable for the given JRE, or null if the JRE is not installed. Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtensionInstallerService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface FileContents public interface FileContents FileContents objects encapsulate the name and contents of a file. An implementation of this class is used by the FileOpenService, FileSaveService, and PersistenceService .
The FileContents implementation returned by PersistenceService.get(java.net.URL), FileOpenService, and FileSaveService should never truncate a file if the maximum file length is set to be less that the current file length. Since: 1.0 See Also: FileOpenService, FileSaveService
Method Summary boolean
canRead()
Returns whether the file can be read. boolean
canWrite()
Returns whether the file can be written to. java.io.InputStream
long
getInputStream() Gets an InputStream from the file. getLength()
Gets the length of the file. long
getMaxLength()
Gets the maximum file length for the file, as set by the creator of this object. java.lang.String
getName()
Gets the file name as a String. java.io.OutputStream
getOutputStream(boolean overwrite) Gets an OutputStream to the file.
JNLPRandomAccessFile
getRandomAccessFile(java.lang.String mode) Returns a JNLPRandomAccessFile representing a random access interface to the file's contents.
long
setMaxLength(long maxlength)
Sets the maximum file length for the file.
Method Detail getName http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileContents.html
java.lang.String getName() throws java.io.IOException
Gets the file name as a String. Returns: a string containing the file name. Throws: java.io.IOException - if an I/O exception occurs.
getInputStream java.io.InputStream getInputStream() throws java.io.IOException
Gets an InputStream from the file. Returns: an InputStream to the file. Throws: java.io.IOException - if an I/O exception occurs.
getOutputStream java.io.OutputStream getOutputStream(boolean overwrite) throws java.io.IOException
Gets an OutputStream to the file. A JNLP client may implement this interface to return an OutputStream subclass which restricts the amount of data that can be written to the stream. Returns: an OutputStream from the file. Throws: java.io.IOException - if an I/O exception occurs.
getLength long getLength() throws java.io.IOException
Gets the length of the file. Returns: the length of the file as a long. Throws: java.io.IOException - if an I/O exception occurs.
canRead http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileContents.html
boolean canRead() throws java.io.IOException
Returns whether the file can be read. Returns: true if the file can be read, false otherwise. Throws: java.io.IOException - if an I/O exception occurs.
canWrite boolean canWrite() throws java.io.IOException
Returns whether the file can be written to. Returns: true if the file can be read, false otherwise. Throws: java.io.IOException - if an I/O exception occurs.
getRandomAccessFile JNLPRandomAccessFile getRandomAccessFile(java.lang.String mode) throws java.io.IOException
Returns a JNLPRandomAccessFile representing a random access interface to the file's contents. The mode argument must either be equal to "r" or "rw", indicating the file is to be opened for input only or for both input and output, respectively. An IllegalArgumentException will be thrown if the mode is not equal to "r" or "rw". Parameters: mode - the access mode. Returns: a JNLPRandomAccessFile. Throws: java.io.IOException - if an I/O exception occurs.
getMaxLength long getMaxLength() throws java.io.IOException
Gets the maximum file length for the file, as set by the creator of this object. Returns: the maximum length of the file. Throws: java.io.IOException - if an I/O exception occurs.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileContents.html
setMaxLength long setMaxLength(long maxlength) throws java.io.IOException
Sets the maximum file length for the file. A JNLP client may enforce restrictions on setting the maximum file length. A JNLP client should not truncate a file if the maximum file length is set that is less than the current file size, but it also should not allow further writes to that file. Parameters:
maxlength - the requested new maximum file length. Returns: the maximum file length that was granted. Throws: java.io.IOException - if an I/O exception occurs.
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileContents.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface FileOpenService public interface FileOpenService FileOpenService service allows the user to choose a file from the local file system, even for applications that are running in
the untrusted execution environment. The JNLP Client is the mediator and is therefore responsible for providing the specific implementation of this, if any. This service provides a similar function as the file input field for HTML-based forms. Since: 1.0 See Also: FileSaveService, FileContents
Method Summary FileContents
openFileDialog(java.lang.String pathHint, java.lang.String[] extensions)
Asks the user to choose a single file. FileContents []
openMultiFileDialog(java.lang.String pathHint, java.lang.String[] extensions)
Asks the user to choose one or more files.
Method Detail openFileDialog FileContents openFileDialog(java.lang.String pathHint, java.lang.String[] extensions) throws java.io.IOException
Asks the user to choose a single file. The contents of a potential selected file is returned as a FileContents object. The returned FileContents object contains the contents along with the name of the file. The full path is not returned. Parameters: - A hint from the application to the initial directory for the file chooser. This might be ignored by the JNLP Client. extensions - A list of default extensions to show in the file chooser. For example, String[] { "txt", "java" }. This might be ignored by the JNLP Client. Returns: A FileContent object with information about the chosen file, or null if the user did not choose a file. Throws: IOException - if the request failed in any way other than the user did not choose to select a file. pathHint
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileOpenService.html
java.io.IOException
openMultiFileDialog FileContents[] openMultiFileDialog(java.lang.String pathHint, java.lang.String[] extensions) throws java.io.IOException
Asks the user to choose one or more files. Otherwise similar to openFileDialog(java.lang.String, java.lang.String[])
Throws: java.io.IOException
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileOpenService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface FileSaveService public interface FileSaveService FileSaveService service allows the user to save a file to the local file system, even for applications that are running in the
untrusted execution environment. The JNLP Client is the mediator and is therefore responsible for providing the specific implementation of this, if any. This service provides similar functionatlity as the Save as... functionality provided by most browsers. Since: 1.0 See Also: FileOpenService, FileContents
Method Summary FileContents
saveAsFileDialog(java.lang.String pathHint, java.lang.String[] extensions, FileContents contents)
Asks the users to save a file. FileContents
saveFileDialog(java.lang.String pathHint, java.lang.String[] extensions, java.io.InputStream stream, java.lang.String name)
Asks the users to save a file.
Method Detail saveFileDialog FileContents saveFileDialog(java.lang.String pathHint, java.lang.String[] extensions, java.io.InputStream stream, java.lang.String name) throws java.io.IOException
Asks the users to save a file. Parameters: pathHint
- A hint from the application to the default directory to be used. This might be ignored by the JNLP
Client.
extensions - A list of default extensions to show in the file chooser. For example, String[] { "txt", "java" }. These might be ignored by the JNLP Client. stream - The content of the file to save along represented as an InputStream name - The suggested filename, which might be ignored by the JNLP client
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileSaveService.html
Returns: A FileContents object for the saved file if the save was successfully, or null if the user canceled the request. Throws: IOException - if the requested failed in any way other than the user chose not to save the file java.io.IOException
saveAsFileDialog FileContents saveAsFileDialog(java.lang.String pathHint, java.lang.String[] extensions, FileContents contents) throws java.io.IOException
Asks the users to save a file. Parameters: pathHint
- A hint from the application to the default directory to be used. This might be ignored by the JNLP
Client.
extensions - A list of default extensions to show in the file chooser. For example, String[] { "txt", "java" }. These might be ignored by the JNLP Client. contents - The content of the file to save along with the suggested filename. The suggested filename might be
ignored by the JNLP Client. Returns: A FileContents object for the saved file if the save was successfully, or null if the user canceled the request. Throws: IOException - if the requested failed in any way other than the user chose not to save the file java.io.IOException
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/FileSaveService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface JNLPRandomAccessFile All Superinterfaces: java.io.DataInput, java.io.DataOutput
public interface JNLPRandomAccessFile extends java.io.DataInput, java.io.DataOutput
Instances of this class support both reading and writing to a random access file. A random access file behaves like a large array of bytes stored in the file system. There is a kind of cursor, or index into the implied array, called the file pointer; input operations read bytes starting at the file pointer and advance the file pointer past the bytes read. If the random access file is created in read/write mode, then output operations are also available; output operations write bytes starting at the file pointer and advance the file pointer past the bytes written. Output operations that write past the current end of the implied array cause the array to be extended. The file pointer can be read by the getFilePointer method and set by the seek method.
It is generally true of all the reading routines in this class that if end-of-file is reached before the desired number of bytes has been read, an EOFException (which is a kind of IOException) is thrown. If any byte cannot be read for any reason other than end-of-file, an IOException other than EOFException is thrown. In particular, an IOException may be thrown if the stream has been closed.
Implementations are encouraged to enforce a maximum amount of data that may be written to a file. Since: 1.0
Method Summary void
close()
Closes this random access file stream and releases any system resources associated with the stream. long
getFilePointer()
Returns the current offset in this file. long
length()
Returns the length of this file. int
read()
Reads a byte of data from this file. int
read(byte[] b)
Reads up to b.length bytes of data from this file into an array of bytes. int
boolean
byte
read(byte[] b, int off, int len) Reads up to len bytes of data from this file into an array of bytes. readBoolean() Reads a boolean from this file. readByte()
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Reads a signed eight-bit value from this file. char
readChar()
Reads a Unicode character from this file. double
float
readDouble() Reads a double from this file. readFloat()
Reads a float from this file. void
readFully(byte[] b) Reads b.length bytes from this file into the byte array, starting at the current file pointer.
void
readFully(byte[] b, int off, int len) Reads exactly len bytes from this file into the byte array, starting at the current file pointer.
int
readInt()
Reads a signed 32-bit integer from this file. java.lang.String
readLine()
Reads the next line of text from this file. long
readLong()
Reads a signed 64-bit integer from this file. short
readShort()
Reads a signed 16-bit number from this file. int
readUnsignedByte()
Reads an unsigned eight-bit number from this file. int
readUnsignedShort()
Reads an unsigned 16-bit number from this file. java.lang.String
readUTF()
Reads in a string from this file. void
seek(long pos)
Sets the file-pointer offset, measured from the beginning of this file, at which the next read or write occurs. void
setLength(long newLength)
Sets the length of this file. int
skipBytes(int n)
Attempts to skip over n bytes of input discarding the skipped bytes. void
write(byte[] b) Writes b.length bytes from the specified byte array to this file, starting at the current file pointer.
void
write(byte[] b, int off, int len) Writes len bytes from the specified byte array starting at offset off to this file.
void
write(int b)
Writes the specified byte to this file. void
writeBoolean(boolean v) Writes a boolean to the file as a one-byte value.
void
writeByte(int v) Writes a byte to the file as a one-byte value.
void
writeBytes(java.lang.String s)
Writes the string to the file as a sequence of bytes. void
writeChar(int v) Writes a char to the file as a two-byte value, high byte first.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
void
writeChars(java.lang.String s)
Writes a string to the file as a sequence of characters. void
writeDouble(double v)
Converts the double argument to a long using the doubleToLongBits method in class Double, and then writes that long value to the file as an eight-byte quantity, high byte first. void
writeFloat(float v)
Converts the float argument to an int using the floatToIntBits method in class Float, and then writes that int value to the file as a four-byte quantity, high byte first. void
writeInt(int v) Writes an int to the file as four bytes, high byte first.
void
writeLong(long v) Writes a long to the file as eight bytes, high byte first.
void
writeShort(int v) Writes a short to the file as two bytes, high byte first.
void
writeUTF(java.lang.String str)
Writes a string to the file using UTF-8 encoding in a machine-independent manner.
Method Detail close void close() throws java.io.IOException
Closes this random access file stream and releases any system resources associated with the stream. A closed random access file cannot perform input or output operations and cannot be reopened. Throws: java.io.IOException
- if an I/O error occurs.
length long length() throws java.io.IOException
Returns the length of this file. Returns: the length of this file, measured in bytes. Throws: java.io.IOException - if an I/O error occurs.
getFilePointer long getFilePointer() throws java.io.IOException
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Returns the current offset in this file. Returns: the offset from the beginning of the file, in bytes, at which the next read or write occurs. Throws: java.io.IOException - if an I/O error occurs.
read int read() throws java.io.IOException
Reads a byte of data from this file. The byte is returned as an integer in the range 0 to 255 (0x00-0x0ff). This method blocks if no input is yet available. Although JNLPRandomAccessFile is not a subclass of InputStream, this method behaves in exactly the same way as the read method of InputStream. Returns: the next byte of data, or -1 if the end of the file has been reached. Throws: java.io.IOException - if an I/O error occurs. Not thrown if end-of-file has been reached.
read int read(byte[] b, int off, int len) throws java.io.IOException
Reads up to len bytes of data from this file into an array of bytes. This method blocks until at least one byte of input is available. Although JNLPRandomAccessFile is not a subclass of InputStream, this method behaves in the exactly the same way as the read(byte[], int, int) method of InputStream. Parameters: b - the buffer into which the data is read. off - the start offset of the data. len - the maximum number of bytes read. Returns: the total number of bytes read into the buffer, or -1 if there is no more data because the end of the file has been reached. Throws: java.io.IOException - if an I/O error occurs.
read int read(byte[] b) throws java.io.IOException
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Reads up to b.length bytes of data from this file into an array of bytes. This method blocks until at least one byte of input is available. Although JNLPRandomAccessFile is not a subclass of InputStream, this method behaves in the exactly the same way as the read(byte[]) method of InputStream. Parameters: b - the buffer into which the data is read. Returns: the total number of bytes read into the buffer, or -1 if there is no more data because the end of this file has been reached. Throws: java.io.IOException - if an I/O error occurs.
readFully void readFully(byte[] b) throws java.io.IOException
Reads b.length bytes from this file into the byte array, starting at the current file pointer. This method reads repeatedly from the file until the requested number of bytes are read. This method blocks until the requested number of bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readFully in interface java.io.DataInput
Parameters: b - the buffer into which the data is read. Throws: EOFException - if this file reaches the end before reading all the bytes. java.io.IOException - if an I/O error occurs.
readFully void readFully(byte[] b, int off, int len) throws java.io.IOException
Reads exactly len bytes from this file into the byte array, starting at the current file pointer. This method reads repeatedly from the file until the requested number of bytes are read. This method blocks until the requested number of bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readFully in interface java.io.DataInput Parameters: b - the buffer into which the data is read. off - the start offset of the data. len - the number of bytes to read. Throws: EOFException - if this file reaches the end before reading all the bytes. java.io.IOException - if an I/O error occurs.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
skipBytes int skipBytes(int n) throws java.io.IOException
Attempts to skip over n bytes of input discarding the skipped bytes. This method may skip over some smaller number of bytes, possibly zero. This may result from any of a number of conditions; reaching end of file before n bytes have been skipped is only one possibility. This method never throws an EOFException. The actual number of bytes skipped is returned. If n is negative, no bytes are skipped. Specified by: skipBytes in interface java.io.DataInput Parameters: n - the number of bytes to be skipped. Returns: the actual number of bytes skipped. Throws: java.io.IOException - if an I/O error occurs.
readBoolean boolean readBoolean() throws java.io.IOException
Reads a boolean from this file. This method reads a single byte from the file, starting at the current file pointer. A value of 0 represents false. Any other value represents true. This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown. Specified by: readBoolean in interface java.io.DataInput Returns: the boolean value read. Throws: EOFException - if this file has reached the end. java.io.IOException - if an I/O error occurs.
readByte byte readByte() throws java.io.IOException
Reads a signed eight-bit value from this file. This method reads a byte from the file, starting from the current file pointer. If the byte read is b, where 0 <= b <= 255, then the result is: (byte)(b)
This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown. Specified by: readByte in interface java.io.DataInput
Returns:
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
the next byte of this file as a signed eight-bit byte. Throws: EOFException - if this file has reached the end. java.io.IOException - if an I/O error occurs.
readUnsignedByte int readUnsignedByte() throws java.io.IOException
Reads an unsigned eight-bit number from this file. This method reads a byte from this file, starting at the current file pointer, and returns that byte. This method blocks until the byte is read, the end of the stream is detected, or an exception is thrown. Specified by: readUnsignedByte in interface java.io.DataInput Returns: the next byte of this file, interpreted as an unsigned eight-bit number. Throws: EOFException - if this file has reached the end. java.io.IOException - if an I/O error occurs.
readShort short readShort() throws java.io.IOException
Reads a signed 16-bit number from this file. The method reads two bytes from this file, starting at the current file pointer. If the two bytes read, in order, are b1 and b2, where each of the two values is between 0 and 255, inclusive, then the result is equal to: (short)((b1 << 8) | b2)
This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readShort in interface java.io.DataInput Returns: the next two bytes of this file, interpreted as a signed 16-bit number. Throws: EOFException - if this file reaches the end before reading two bytes. java.io.IOException - if an I/O error occurs.
readUnsignedShort int readUnsignedShort() throws java.io.IOException
Reads an unsigned 16-bit number from this file. This method reads two bytes from the file, starting at the current file http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
pointer. If the bytes read, in order, are b1 and b2, where 0 <= b1, b2 <= 255, then the result is equal to: (b1 << 8) | b2
This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readUnsignedShort in interface java.io.DataInput Returns: the next two bytes of this file, interpreted as an unsigned 16-bit integer. Throws: EOFException - if this file reaches the end before reading two bytes. java.io.IOException - if an I/O error occurs.
readChar char readChar() throws java.io.IOException
Reads a Unicode character from this file. This method reads two bytes from the file, starting at the current file pointer. If the bytes read, in order, are b1 and b2, where 0 <= b1, b2 <= 255, then the result is equal to: (char)((b1 << 8) | b2)
This method blocks until the two bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readChar in interface java.io.DataInput
Returns: the next two bytes of this file as a Unicode character. Throws: EOFException - if this file reaches the end before reading two bytes. java.io.IOException - if an I/O error occurs.
readInt int readInt() throws java.io.IOException
Reads a signed 32-bit integer from this file. This method reads 4 bytes from the file, starting at the current file pointer. If the bytes read, in order, are b1, b2, b3, and b4, where 0 <= b1, b2, b3, b4 <= 255, then the result is equal to: (b1 << 24) | (b2 << 16) + (b3 << 8) + b4
This method blocks until the four bytes are read, the end of the stream is detected, or an exception is thrown. Specified by:
readInt in interface java.io.DataInput Returns: the next four bytes of this file, interpreted as an int.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Throws: EOFException - if this file reaches the end before reading four bytes. java.io.IOException - if an I/O error occurs.
readLong long readLong() throws java.io.IOException
Reads a signed 64-bit integer from this file. This method reads eight bytes from the file, starting at the current file pointer. If the bytes read, in order, are b1, b2, b3, b4, b5, b6, b7, and b8, where: 0 <= b1, b2, b3, b4, b5, b6, b7, b8 <=255,
then the result is equal to: ((long)b1 << 56) + ((long)b2 << 48) + ((long)b3 << 40) + ((long)b4 << 32) + ((long)b5 << 24) + ((long)b6 << 16) + ((long)b7 << 8) + b8
This method blocks until the eight bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readLong in interface java.io.DataInput
Returns: the next eight bytes of this file, interpreted as a long. Throws: EOFException - if this file reaches the end before reading eight bytes. java.io.IOException - if an I/O error occurs.
readFloat float readFloat() throws java.io.IOException
Reads a float from this file. This method reads an int value, starting at the current file pointer, as if by the readInt method and then converts that int to a float using the intBitsToFloat method in class Float. This method blocks until the four bytes are read, the end of the stream is detected, or an exception is thrown. Specified by:
readFloat in interface java.io.DataInput Returns: the next four bytes of this file, interpreted as a float. Throws: EOFException - if this file reaches the end before reading four bytes. java.io.IOException - if an I/O error occurs. See Also: readInt()
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
readDouble double readDouble() throws java.io.IOException
Reads a double from this file. This method reads a long value, starting at the current file pointer, as if by the readLong method and then converts that long to a double using the longBitsToDouble method in class Double. This method blocks until the eight bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readDouble in interface java.io.DataInput
Returns: the next eight bytes of this file, interpreted as a double. Throws: EOFException - if this file reaches the end before reading eight bytes. java.io.IOException - if an I/O error occurs. See Also: readLong()
readLine java.lang.String readLine() throws java.io.IOException
Reads the next line of text from this file. This method successively reads bytes from the file, starting at the current file pointer, until it reaches a line terminator or the end of the file. Each byte is converted into a character by taking the byte's value for the lower eight bits of the character and setting the high eight bits of the character to zero. This method does not, therefore, support the full Unicode character set. A line of text is terminated by a carriage-return character ('\r'), a newline character ('\n'), a carriage-return character immediately followed by a newline character, or the end of the file. Line-terminating characters are discarded and are not included as part of the string returned. This method blocks until a newline character is read, a carriage return and the byte following it are read (to see if it is a newline), the end of the file is reached, or an exception is thrown. Specified by: readLine in interface java.io.DataInput Returns: the next line of text from this file, or null if end of file is encountered before even one byte is read. Throws: java.io.IOException - if an I/O error occurs.
readUTF java.lang.String readUTF() throws java.io.IOException
Reads in a string from this file. The string has been encoded using a modified UTF-8 format. The first two bytes are read, starting from the current file pointer, as if by readUnsignedShort. This value gives the number of following bytes that are in the encoded string, not the length of the resulting string. The following bytes are http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
then interpreted as bytes encoding characters in the UTF-8 format and are converted into characters. This method blocks until all the bytes are read, the end of the stream is detected, or an exception is thrown. Specified by: readUTF in interface java.io.DataInput
Returns: a Unicode string. Throws: EOFException - if this file reaches the end before reading all the bytes. java.io.IOException - if an I/O error occurs. UTFDataFormatException - if the bytes do not represent valid UTF-8 encoding of a Unicode string. See Also: readUnsignedShort()
seek
void seek(long pos) throws java.io.IOException
Sets the file-pointer offset, measured from the beginning of this file, at which the next read or write occurs. The offset may be set beyond the end of the file. Setting the offset beyond the end of the file does not change the file length. The file length will change only by writing after the offset has been set beyond the end of the file. Parameters: pos - the offset position, measured in bytes from the beginning of the file, at which to set the file pointer. Throws: java.io.IOException - if pos is less than 0 or if an I/O error occurs.
setLength void setLength(long newLength) throws java.io.IOException
Sets the length of this file. If the present length of the file as returned by the length method is greater than the newLength argument then the file will be truncated. In this case, if the file offset as returned by the getFilePointer method is greater then newLength then after this method returns the offset will be equal to newLength. If the present length of the file as returned by the length method is smaller than the newLength argument then the file will be extended. In this case, the contents of the extended portion of the file are not defined. Parameters: newLength
- The desired length of the file
Throws:
java.io.IOException
- If an I/O error occurs
write void write(int b)
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
throws java.io.IOException
Writes the specified byte to this file. The write starts at the current file pointer. Specified by: write in interface java.io.DataOutput Parameters: b - the byte to be written. Throws: java.io.IOException - if an I/O error occurs.
write void write(byte[] b) throws java.io.IOException
Writes b.length bytes from the specified byte array to this file, starting at the current file pointer. Specified by: write in interface java.io.DataOutput Parameters: b - the data. Throws: java.io.IOException - if an I/O error occurs.
write void write(byte[] b, int off, int len) throws java.io.IOException
Writes len bytes from the specified byte array starting at offset off to this file. Specified by: write in interface java.io.DataOutput Parameters: b - the data. off - the start offset in the data. len - the number of bytes to write. Throws: java.io.IOException - if an I/O error occurs.
writeBoolean void writeBoolean(boolean v) throws java.io.IOException
Writes a boolean to the file as a one-byte value. The value true is written out as the value (byte)1; the value false is written out as the value (byte)0. The write starts at the current position of the file pointer. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Specified by: writeBoolean in interface java.io.DataOutput Parameters: v - a boolean value to be written. Throws: java.io.IOException - if an I/O error occurs.
writeByte void writeByte(int v) throws java.io.IOException
Writes a byte to the file as a one-byte value. The write starts at the current position of the file pointer. Specified by: writeByte in interface java.io.DataOutput
Parameters: v - a byte value to be written. Throws: java.io.IOException - if an I/O error occurs.
writeShort void writeShort(int v) throws java.io.IOException
Writes a short to the file as two bytes, high byte first. The write starts at the current position of the file pointer. Specified by: writeShort in interface java.io.DataOutput
Parameters: v - a short to be written. Throws: java.io.IOException - if an I/O error occurs.
writeChar void writeChar(int v) throws java.io.IOException
Writes a char to the file as a two-byte value, high byte first. The write starts at the current position of the file pointer. Specified by: writeChar in interface java.io.DataOutput
Parameters: v - a char value to be written. Throws: java.io.IOException - if an I/O error occurs.
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
writeInt void writeInt(int v) throws java.io.IOException
Writes an int to the file as four bytes, high byte first. The write starts at the current position of the file pointer. Specified by: writeInt in interface java.io.DataOutput Parameters: v - an int to be written. Throws: java.io.IOException - if an I/O error occurs.
writeLong void writeLong(long v) throws java.io.IOException
Writes a long to the file as eight bytes, high byte first. The write starts at the current position of the file pointer. Specified by: writeLong in interface java.io.DataOutput Parameters: v - a long to be written. Throws: java.io.IOException - if an I/O error occurs.
writeFloat void writeFloat(float v) throws java.io.IOException
Converts the float argument to an int using the floatToIntBits method in class Float, and then writes that int value to the file as a four-byte quantity, high byte first. The write starts at the current position of the file pointer. Specified by: writeFloat in interface java.io.DataOutput
Parameters: v - a float value to be written. Throws: java.io.IOException - if an I/O error occurs.
writeDouble void writeDouble(double v) throws java.io.IOException
Converts the double argument to a long using the doubleToLongBits method in class Double, and then writes that long value to the file as an eight-byte quantity, high byte first. The write starts at the current position of the file pointer. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Specified by: writeDouble in interface java.io.DataOutput Parameters: v - a double value to be written. Throws: java.io.IOException - if an I/O error occurs.
writeBytes void writeBytes(java.lang.String s) throws java.io.IOException
Writes the string to the file as a sequence of bytes. Each character in the string is written out, in sequence, by discarding its high eight bits. The write starts at the current position of the file pointer. Specified by: writeBytes in interface java.io.DataOutput Parameters: s - a string of bytes to be written. Throws: java.io.IOException - if an I/O error occurs.
writeChars void writeChars(java.lang.String s) throws java.io.IOException
Writes a string to the file as a sequence of characters. Each character is written to the data output stream as if by the writeChar method. The write starts at the current position of the file pointer. Specified by:
writeChars in interface java.io.DataOutput Parameters: s - a String value to be written. Throws: java.io.IOException - if an I/O error occurs. See Also: writeChar(int)
writeUTF void writeUTF(java.lang.String str) throws java.io.IOException
Writes a string to the file using UTF-8 encoding in a machine-independent manner. First, two bytes are written to the file, starting at the current file pointer, as if by the writeShort method giving the number of bytes to follow. This value is the number of bytes actually written out, not the length of the string. Following the length, each character of the string is output, in sequence, using the UTF-8 encoding for each character. Specified by: http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
writeUTF in interface java.io.DataOutput
Parameters: str - a string to be written. Throws: java.io.IOException - if an I/O error occurs. Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/JNLPRandomAccessFile.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface PersistenceService public interface PersistenceService PersistenceService provides methods for storing data locally on the client system, even for applications that are running in
the untrusted execution environment. The service is somewhat similar to that which the cookie mechanism provides to HTMLbased applications. Each entry in the persistence data store is named with a URL. This provides a similar hierarchical structure as a traditional file system. An application is only allowed to access data stored with a URL that is based on its codebase. For example, given the codebase http://www.mysite.com/apps/App1/, the application would be allowed to access the data at the associated URLs:
http://www.mysite.com/apps/App1/ http://www.mysite.com/apps/ http://www.mysite.com/
This scheme allows sharing of data between different applications from the same host. For example, if another application is located at http://www.mysite.com/apps/App2/, then they can share data between them in the http://www.mysite.com/ and http://www.mysite.com/apps/ directories. A JNLP client should track the amount of storage that a given application uses. A PersistenceService implementation provides methods to get the current storage usage and limits and to request more storage. Storage is allocated on a per file basis, but a JNLP Client will typically grant or deny the request based on the total storage is use by an application.
Data stored using this mechanism is intended to be a local copy of data stored on a remote server. The individual entries can be tagged as either cached, meaning the server has an up-to-date copy, dirty, meaning the server does not have an up-to-date copy, or temporary, meaning that the file can always be recreated. Since: 1.0
Field Summary static int
CACHED
static int
DIRTY
static int
TEMPORARY
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PersistenceService.html
Method Summary long
create(java.net.URL url, long maxsize)
Creates a new persistent storage entry on the client side named with the given URL. void
delete(java.net.URL url)
Removes the stream associated with the given URL from the client-side date persistence store. FileContents
java.lang.String [] int
get(java.net.URL url) Returns a FileContents object representing the contents of this file. getNames(java.net.URL url)
Returns an array of Strings containing the names of all the entries for a given URL. getTag(java.net.URL url) Returns an int corresponding to the current value of the tag for the persistent data store entry
associated with the given URL. void
setTag(java.net.URL url, int tag)
Tags the persistent data store entry associated with the given URL with the given tag value.
Field Detail CACHED static final int CACHED
See Also: Constant Field Values
TEMPORARY static final int TEMPORARY
See Also: Constant Field Values
DIRTY static final int DIRTY
See Also: Constant Field Values
Method Detail create long create(java.net.URL url, long maxsize) throws java.net.MalformedURLException, java.io.IOException
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PersistenceService.html
Creates a new persistent storage entry on the client side named with the given URL. Parameters: url - the URL representing the name of the entry in the persistent data store. maxsize - maximum size of storage that can be written to this entry. Returns: the maximum size of storage that got granted, in bytes. Throws: java.net.MalformedURLException - if the application is denied access to the persistent data store represented by the given URL. java.io.IOException - if an I/O exception occurs, or the entry already exists.
get FileContents get(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException, java.io.FileNotFoundException
Returns a FileContents object representing the contents of this file. Parameters: url - the URL representing the persistent data store entry. Returns: the file contents as a FileContents. Throws: java.io.IOException - if an I/O error occurs. java.net.MalformedURLException - if the application is denied access to the persistent data store represented by the given URL. java.io.FileNotFoundException - if a persistence store for the given URL is not found.
delete void delete(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException
Removes the stream associated with the given URL from the client-side date persistence store. Parameters: url - the URL representing the entry to delete from the persistent data store. Throws: java.net.MalformedURLException - if the application is denied access to the persistent data store represented by the given URL. java.io.IOException - if an I/O exception occurs.
getNames java.lang.String[] getNames(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PersistenceService.html
Returns an array of Strings containing the names of all the entries for a given URL. Parameters: url - the URL representing the root directory to search for entry names. Returns: a String array containing the entries names. Throws: java.net.MalformedURLException - if the application is denied access to the persistent data store represented by the given URL. java.io.IOException - if an I/O exception occurs.
getTag int getTag(java.net.URL url) throws java.net.MalformedURLException, java.io.IOException
Returns an int corresponding to the current value of the tag for the persistent data store entry associated with the given URL. Parameters: url - the URL representing the persistent data store entry for which the tag value is requested. Returns: an int containing one of the following tag values:
Throws:
CACHED TEMPORARY DIRTY
java.net.MalformedURLException
by the given URL. java.io.IOException
- if the application is denied access to the persistent data store represented
- if an I/O exception occurs.
setTag void setTag(java.net.URL url, int tag) throws java.net.MalformedURLException, java.io.IOException
Tags the persistent data store entry associated with the given URL with the given tag value. Parameters: url - the URL representing the persistent data store entry for which to set the tag value. tag - the tag value to set. Throws: java.net.MalformedURLException - if the application is denied access to the persistent data store represented by the given URL. java.io.IOException - if an I/O exception occurs. Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PersistenceService.html
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PersistenceService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface PrintService public interface PrintService PrintService provides methods for access to printing functions, even for applications that are running in the untrusted
execution environment. Using this service, an application can submit a print job to the JNLP client. The client can then display this request to the user, and if accepted, queue the request to the printer. Since: 1.0
Method Summary java.awt.print.PageFormat
getDefaultPage()
Creates a new PageFormat instance and sets it to the default size and orientation. boolean
print(java.awt.print.Pageable document) Prints a document using the given Pageable object
boolean
print(java.awt.print.Printable painter) Prints a document using the given Printable object
java.awt.print.PageFormat
showPageFormatDialog(java.awt.print.PageFormat page) Displays a dialog that allows modification of a PageFormat instance.
Method Detail getDefaultPage java.awt.print.PageFormat getDefaultPage()
Creates a new PageFormat instance and sets it to the default size and orientation. Returns: a PageFormat set to the default size and orientation.
showPageFormatDialog java.awt.print.PageFormat showPageFormatDialog(java.awt.print.PageFormat page)
Displays a dialog that allows modification of a PageFormat instance. The page argument is used to initialize controls in the page setup dialog. If the user cancels the dialog then this method returns the original page object unmodified. If the http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PrintService.html
user okays the dialog then this method returns a new PageFormat object with the indicated changes. In either case, the original page object is not modified.
Parameters: page - the default PageFormat presented to the user for modification. Returns: the original page object if the dialog is cancelled; a new PageFormat object containing the format indicated by the user if the dialog is acknowledged.
print boolean print(java.awt.print.Pageable document)
Prints a document using the given Pageable object Parameters: document
- the pages to be printed. It can not be null.
Returns:
true if printing was successfull, false otherwise.
print boolean print(java.awt.print.Printable painter)
Prints a document using the given Printable object Parameters: painter
Returns:
- the Printable called to render each page of the document.
true if printing was successfull, false otherwise.
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/PrintService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface ServiceManagerStub public interface ServiceManagerStub
A ServiceManagerStub object implements the particular lookup of JNLP services by the JNLP Client. The object is registered with the ServiceManager using the ServiceManager.setServiceManagerStub(javax.jnlp.ServiceManagerStub) method. Since: 1.0 See Also: ServiceManager
Method Summary java.lang.String []
getServiceNames()
java.lang.Object
lookup(java.lang.String name) See description for ServiceManager.lookup(java.lang.String)
See description for ServiceManager.getServiceNames()
Method Detail lookup
java.lang.Object lookup(java.lang.String name) throws UnavailableServiceException
See description for ServiceManager.lookup(java.lang.String) Throws: UnavailableServiceException
getServiceNames java.lang.String[] getServiceNames()
See description for ServiceManager.getServiceNames() Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ServiceManagerStub.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface SingleInstanceListener public interface SingleInstanceListener SingleInstanceListener is a interface which should be implemented by a JNLP application if they wish to support single
instance behaviour. Since: 1.5
Method Summary void
newActivation(java.lang.String[] params)
This method should be implemented by the application to handle the single instance behaviour - how should the application handle the arguments when another instance of the application is invoked with params.
Method Detail newActivation void newActivation(java.lang.String[] params)
This method should be implemented by the application to handle the single instance behaviour - how should the application handle the arguments when another instance of the application is invoked with params. Parameters: params
- Array of parameters for the application main (arguments supplied in the jnlp file)
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/SingleInstanceListener.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Interface SingleInstanceService public interface SingleInstanceService
SingleInstanceService allow applications launched under Java Web Start to register themselves as singletons, and to be passed in new parameter sets when user attempts to launch new instances of them.
Since: 1.5
Method Summary void
addSingleInstanceListener(SingleInstanceListener sil)
Adds the specified SingleInstanceListener to handle how the application/applet should behave when another instance of the same application/applet is invoked. void
removeSingleInstanceListener(SingleInstanceListener sil)
Removes the specified SingleInstanceListener.
Method Detail addSingleInstanceListener void addSingleInstanceListener(SingleInstanceListener sil)
Adds the specified SingleInstanceListener to handle how the application/applet should behave when another instance of the same application/applet is invoked. If SingleInstanceListener sil is null, no exception is thrown and no action is performed. Parameters: sil - the SingleInstanceListener object to be added
removeSingleInstanceListener void removeSingleInstanceListener(SingleInstanceListener sil)
Removes the specified SingleInstanceListener. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to the application/applet. If listener sil is null, no exception is thrown and no action is performed. It is recommended that if an application/applet registered any SingleInstanceListener(s), it should call this method to remove all listeners upon exit of the application/applet. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/SingleInstanceService.html
Parameters: sil - the SingleInstanceListener object to be removed Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/SingleInstanceService.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Class ServiceManager java.lang.Object javax.jnlp.ServiceManager
public final class ServiceManager extends java.lang.Object
The ServiceManager provides static methods to lookup JNLP services. This class is abstract and final and cannot be instantiated. Requests are delegated to a ServiceManagerStub object. This object must be set by the JNLP Client on startup using the setServiceManagerStub method. Since: 1.0 See Also: ServiceManagerStub
Method Summary static java.lang.String []
getServiceNames()
static java.lang.Object
lookup(java.lang.String name)
Returns the names of all services implemented by the JNLP Client. Asks the JNLP Client for a service with a given name.
static void
setServiceManagerStub(ServiceManagerStub stub) Sets the object that all lookup and getServiceNames requests are delegated to.
Methods inherited from class java.lang.Object clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
Method Detail lookup public static java.lang.Object lookup(java.lang.String name) throws UnavailableServiceException
Asks the JNLP Client for a service with a given name. The lookup must be idempotent, that is return the same object for each invocation with the same name. http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ServiceManager.html
Parameters: name - Name of service to lookup. Returns: An object implementing the service. null will never be returned. Instead an exception will be thrown. Throws: UnavailableServiceException - if the service is not available, or if name is null. UnavailableServiceException
getServiceNames public static java.lang.String[] getServiceNames()
Returns the names of all services implemented by the JNLP Client.
setServiceManagerStub public static void setServiceManagerStub(ServiceManagerStub stub)
Sets the object that all lookup and getServiceNames requests are delegated to. The setServiceManagerStub call is ignored if the stub has already been set. This method should be called exactly once by the JNLP Client, and never be called by a launched application. Parameters: stub - The ServiceManagerStub object to delegate to Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ServiceManager.html
Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
javax.jnlp
Class UnavailableServiceException java.lang.Object java.lang.Throwable java.lang.Exception javax.jnlp.UnavailableServiceException
All Implemented Interfaces: java.io.Serializable
public class UnavailableServiceException extends java.lang.Exception
The UnavailableServiceException is thrown by the ServiceManager when a non-existing or unavailable service is looked up. Since: 1.0 See Also: ServiceManager,
Serialized Form
Constructor Summary UnavailableServiceException() Constructs an UnavailableServiceException with null as its error detail message. UnavailableServiceException(java.lang.String msg) Constructs an UnavailableServiceException with the specified detail message.
Method Summary Methods inherited from class java.lang.Throwable fillInStackTrace, getCause, getLocalizedMessage, getMessage, getStackTrace, initCause, printStackTrace, printStackTrace, printStackTrace, setStackTrace, toString
Methods inherited from class java.lang.Object clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
Constructor Detail UnavailableServiceException http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/UnavailableServiceException.html
public UnavailableServiceException()
Constructs an UnavailableServiceException with null as its error detail message.
UnavailableServiceException public UnavailableServiceException(java.lang.String msg)
Constructs an UnavailableServiceException with the specified detail message. The error message string s can later be retrieved by the Throwable.getMessage() method of class java.lang.Throwable. Parameters: msg - the detail message. Package Class Tree Index PREV CLASS NEXT CLASS SUMMARY: NESTED | FIELD | CONSTR | METHOD
FRAMES NO FRAMES All Classes DETAIL: FIELD | CONSTR | METHOD
Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved
http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/UnavailableServiceException.html
javaws
Command Line
NAME javaws
- Java Web Start launcher command
SYNOPSIS javaws [run-options] <jnlp> javaws [control-options]
PARAMETERS [run-options]
Command-line run-options. run-options may be in any order. For a discussion of the various runoptions, see RUN-OPTIONS below. <jnlp>
This can be either the path of, or the Uniform Resource Locater (URL) of the JNLP (Java Network Launching Protocol) file. [control-options]
Command-line control-options. control-options may be in any order. For a discussion of the various control-options, see CONTROL-OPTIONS below.
DESCRIPTION The javaws command launches Java Web Start, which is the reference implementation of the Java Network Launching Protocol (JNLP). Java Web Start launches Java applications/applets hosted on a network. If a JNLP file is specified, javaws will launch the Java application/applet specified in the JNLP file. The javaws launcher has a set of options that are supported in the current release. However, the options may be removed in a future release.
RUN-OPTIONS -offline
run Java Web Start in offline mode. -Xnosplash
disable the display of the initial splash screen. http://java.sun.com/javase/6/docs/technotes/tools/share/javaws.html
-open <arguments>
If specified, replaces the arguments in the jnlp file with -open <arguments>. -print <arguments>
If specified, replaces the arguments in the jnlp file with -print <arguments>. -online
run in online mode (default behavior). -wait
If specified, the javaws process will not exit until the application exits. -verbose
display additional output. -J
Related Documents
Java Web Start Guide
July 2020 13
Java Web Start
June 2020 8
Java Web Developers Guide
April 2020 9
Faq Java Web Start By Gopi
November 2019 9
Java Guide
May 2020 15