I lllll llllllll Ill lllll lllll lllll lllll lllll 111111111111111111111111111111111
`US007478142Bl
`
`c12) United States Patent
`Veditz
`
`(IO) Patent No.:
`(45) Date of Patent:
`
`US 7,478,142 Bl
`Jan.13,2009
`
`(54) SELF-CONTAINED APPLICATIONS THAT
`ARE APPLIED TO BE RECEIVED BY AND
`PROCESSED WITHIN A BROWSER
`ENVIRONMENT AND THAT HAVE A FIRST
`PACKAGE THAT INCLUDES A MANIFEST
`FILE AND AN ARCHIVE OF FILES
`INCLUDING A MARKUP LANGUAGE FILE
`AND SECOND PACKAGE
`
`(75)
`
`Inventor: Daniel P. Veditz, Felton, CA (US)
`
`(73) Assignee: Netscape Communications
`Corporation, Mountain View, CA (US)
`
`( *) Notice:
`
`Subject to any disclaimer, the term ofthis
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 0 days.
`
`(21) Appl. No.: 09/163,041
`
`(22) Filed:
`
`Sep.29,1998
`
`(51)
`
`(52)
`(58)
`
`Int. Cl.
`(2006.01)
`G06F 15116
`U.S. Cl. ...................................................... 709/218
`Field of Classification Search . ... ... ... ... .. .. 709/201,
`709/202, 219, 249, 218; 717/121, 162, 172,
`717/177
`See application file for complete search history.
`
`(56)
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`
`5,617,526 A *
`5,727,156 A
`5,790,793 A
`5,799,285 A
`5,805,804 A *
`5,870,559 A
`5,870,767 A
`5,877,766 A *
`5,893,127 A
`5,905,248 A
`5,913,215 A
`5,944,783 A *
`5,946,464 A *
`
`4/1997 Oran et al. .................. 715/779
`3/1998 Herr-Hoyman et al.
`..... 709/219
`8/1998 Higley ........................ 709/218
`8/1998 Klingman .................... 705/26
`911998 Laursen et al.
`211999 Leshem et al. .............. 709/224
`2/1999 Kraft, IV ................. 707/501.1
`3/1999 Bates et al .................. 715/854
`4/1999 Tyan et al.
`.................. 707/513
`5/1999 Russell et al ........... 235/462.15
`6/1999 Rubinstein et al. ............ 707/10
`8/ 1999 Nieten ........................ 709/202
`8/ 1999 Kito et al. ................... 709/202
`
`5,964,836 A * 10/1999 Rowe et al. ................. 709/221
`5,968,116 A * 10/1999 Day, II et al . ............... 709/202
`5,974,441 A * 10/1999 Rogers et al.
`5,974,454 A * 10/1999 Apfel et al.
`5,983,233 A * 1111999 Potonniee
`5,999,940 A * 12/1999 Ranger
`6,009,456 A * 12/1999 Frew et al. .................. 709/202
`
`(Continued)
`
`OTHER PUBLICATIONS
`
`R. Englander, "Developing Java Beans", Book Overview Section, p.
`1, O'Reilly, Jun. 1997.*
`
`(Continued)
`
`Primary Examiner-Andrew Caldwell
`Assistant Examiner-John M Macllwinen
`(74) Attorney, Agent, or Firm-Fish & Richardson P.C.
`
`(57)
`
`ABSTRACT
`
`An implementation of a self-contained application may be
`distributed and automatically executed within a network cli(cid:173)
`ent environment, such as within a web browser environment.
`implementation of the self-contained application
`The
`includes a first package that includes a manifest and an
`archive of files. The archive of files includes a markup lan(cid:173)
`guage file that is the initial file to be processed and that
`includes instructions for initiating execution of the applica(cid:173)
`tion. In the implementation, the archive of files also includes
`other files needed to execute the application and a second
`package that may be of the same type as the first package. The
`manifest file includes an initial file identifier that instructs the
`application to process the markup language initial file before
`processing the other files.
`
`42 Claims, 6 Drawing Sheets
`
`S6-1
`
`START
`
`RECENE SELF-CONTAINED SOFTWARE PACKAGE
`(E.g., .XJR FILE)
`
`S6-2
`
`SPAWN BROWSER ENVIRONMENT (NETWORK
`CLIENT) AND LOAD/INPUT SELF-CONTAINED
`SOFTWARE PACKAGE (E.g., XJR FILE) WITHIN
`BROWSER ENVIRONMENT
`
`S6-3
`
`BROWSER ENVIRONMENT ACCESSES AND
`EXTRACTS OBJECTS FROM MANIFEST AND .XJR
`ALE AND EXECUTES ACCORDING TO
`INSTRUCTIONS CONTAINED WITiilN CONTENT
`FILES THEREOF (E.g., IN INITIAL CONTENT FILE,
`ETC. -- HTML FILES, ETC.
`
`S6-4
`
`~S6-5
`
`IPR2017-00184
`UNIFIED EX1018
`
`

`
`US 7,478,142 Bl
`Page 2
`
`U.S. PATENT DOCUMENTS
`
`6,029,175 A *
`212000 Chow et al.
`6,041,342 A *
`3/2000 Yamaguchi ................. 709/202
`6,047,323 A *
`412000 Krause
`6,049,819 A *
`412000 Buckle et al. ............... 709/202
`6,052,531 A *
`412000 Waldin et al. ............... 717 /170
`6,065,024 A *
`512000 Renshaw .................... 715/513
`6,092,178 A *
`712000 Jindal et al.
`6,112,023 A *
`8/2000 Dave et al.
`6,ll5,040 A *
`912000 Bladowetal. .............. 715/741
`6,202,207 Bl *
`3/2001 Donohue
`6,216,212 Bl*
`4/2001 Challenger et al.
`6,314,565 Bl* 1112001 Kenner et al.
`6,347,398 Bl*
`212002 Parthasarathy et al.
`6,351,816 Bl*
`212002 Mueller et al. .............. 713/176
`6,385,643 Bl*
`512002 Jacobs et al. ................ 709/203
`6,397,220 Bl*
`512002 Deisinger et al.
`........... 707/102
`6,430,739 Bl*
`8/2002 Ballard ....................... 717 /100
`6,587,836 Bl*
`7/2003 Ahlberg et al. ................ 705/26
`6,623,527 Bl*
`9/2003 Harnzy ....................... 715/513
`6,839,733 Bl*
`1/2005 Lange et al.
`................ 709/202
`2001/0029605 Al* 10/2001 Forbes et al. .................. 717/11
`
`OTHER PUBLICATIONS
`
`R. Englander, "Developing Java Beans", Section 6.1, pp. 1-2,
`O'Reilly, Jun. 1997.*
`R. Englander, "Developing Java Beans", Section 6.2, pp. 1-3,
`O'Reilly, Jun. 1997.*
`R. Englander, "Developing Java Beans", Section 6.3, p. 1, O'Reilly,
`Jun. 1997.*
`R. Englander, "Developing Java Beans", Section 6.4, p. 1, O'Reilly,
`Jun. 1997.*
`R. Englander, "Developing Java Beans", Section 6.5, p. 1, O'Reilly,
`Jun. 1997.*
`R. Englander, "Developing Java Beans", Section 1.2.2, pp. 1-2,
`O'Reilly, Jun. 1997.*
`
`Netscape Smartupdate (Press Release 1). http://wp.netscape.com/
`newsref/pr/newsrelease461.htrnl. Aug. 18, 1997. pp. 1-3.*
`Netscape Smartupdate (Press Release 2). http://cgi.netscape.com/
`newsref/pr/newsrelease523.htrnl. Nov. 3, 1997. pp, 1-3.*
`Netscape Smartupdate Jar Support. microsoft.public.inetexplorer.
`ie4.java_applets. Andrew Spyker. http://groups.google.com/group/
`mircosoft.public.inetexplorer.ie4.java_applets/browse_thread/
`thread/2ebc647eee3b4cb7/dfe3e90a4a55e6eO?Ink~st
`&q~locally+install+java+applet+support#dfe3e90a4a55e6e0. Sep.
`25, 1997. pp. 1-2.*
`Nesting CAB Files. microsoft.public.java.cab. http://groups.google.
`corn/group/microsoft.public.java.cab/browse_thread/thread/
`5c7c5al23el4dec8/4ebl 530cd9d33b01 ?ink~st
`&q~create+cab+within+cab#. Mar. 6-25, 1998. pp. 1-7.*
`"JAR File Format" retrieved via the Internet and World-Wide-Web at
`http://j ava. sun.corn/ docs/books/tutorial/postl .O/whatnew/jar.htrnl
`on Sep. 22, 1998 at 1 :55pm, p. 1 of 1.
`"The Java Archive (JAR) File Format" retrieved via the Internet and
`World-Wide-Web at http://java.sun.com/docs/books/tutorial/jar/in(cid:173)
`dex.html on Sep. 22, 1998 at 1:55pm, pp. 1-2.
`"Using JAR Files: The Basics" retrieved via the Internet and World(cid:173)
`Wide-Web at http://java.sun.com/docs/books/tutorial/jar/basics/in(cid:173)
`dex.html on Sep. 22, 1998n at 1:56 pm, pp. 1-2 ..
`"Modifying a Manifest File" retrieved via the Internet and World(cid:173)
`Wide-Web
`at http://java.sun.com/docs/books/tutorial/jar/basics/
`mod.html on Sep. 22, 1998 at 1:56 pm, pp. 1-3.
`"Understanding the Manifest" retrieved via the Internet and World(cid:173)
`wide-Web
`at http://java.sun.com/docs/books/tutorial/jar/basics/
`manifest.html on Sep. 22, 1998 at 1:58pm, pp. 1-4.
`"Manifest Format" retrieved via the Internet and World-Wide-Web at
`http://j ava. sun.corn/products/j dk/ 1.2/docs/ guide/j ar/manifest.htrnl
`on Sep. 22, 1998 at 2:12pm, pp. 1-7.
`"JAR file (Java Archive file)" retrieved via the Internet and World(cid:173)
`Wide-Web at http://whatis.com/jar.htm on Sep. 22, 1998 at 2: 13pm,
`p. 1 of 1.
`* cited by examiner
`
`

`
`U.S. Patent
`
`Jan.13,2009
`
`Sheet 1of6
`
`US 7,478,142 Bl
`
`102
`
`WEB SERVER/
`ENTERPRISE
`SERVER
`(.XJR FILES)
`
`100
`
`~
`
`INTERNET/NETWORK
`
`106
`
`ISP
`
`CLIENT
`SYSTEM
`(BROWSER)
`
`108
`
`" ,,
`" ''"'-, -~ ',
`
`.XJR FILES '-...
`
`/110
`
`SOFTWARE
`DISTRIBUTOR
`(ENCAPSULATED APPS)
`
`FIG. 1
`
`

`
`U.S. Patent
`
`Jan.13,2009
`
`Sheet 2 of 6
`
`US 7,478,142 Bl
`
`108
`
`PROCESSOR
`ARRANGEMENT
`
`202
`
`DATA STORAGE
`SUBSYSTEM
`
`204
`
`I/O
`
`206
`
`FIG. 2
`
`

`
`U.S. Patent
`
`Jan.13,2009
`
`Sheet 3 of 6
`
`US 7,478,142 Bl
`
`INPUTS
`.XJR, CONTENT, ETC.
`VIA NETWORK CONNECTION,
`COMPUTER-READABLE MEDIA, ETC.
`
`/300
`
`CONTENT
`RENDERING
`AND LAYOUT
`MODULES
`AND
`OBJECTS
`
`-
`
`-
`
`/302
`
`I/O MODULES AND
`OBJECTS
`
`PROCESSING ENGINE
`MODULES AND OBJECTS
`
`(E.g. .XJR PROCESSING
`MODULES)
`
`"\..304
`
`'
`OUTPUTS
`MULTI-MEDIA
`OUTPUT SUCH AS
`SCREEN OUTPUT,
`SOUND OUTPUT,
`PRINTED OUTPUT, ETC.
`
`FIG. 3
`
`

`
`U.S. Patent
`
`Jan.13,2009
`
`Sheet 4 of 6
`
`US 7,478,142 Bl
`
`Manifest-Version: 1.0
`Author: Jane Doe
`Version: 1.0
`Date: 11/09/97
`Copyright: (C) 1997 MySite.com All Rights Reserved
`
`archive-type: WebApp
`Initial-File: index.html
`
`Name: index.html
`Content-type: text/html
`rHTML - FOR WEB-BASED APPLICATION>
`402-' Name: components/MyComponent.JAR\_
`Content-type: application/java-archive
`404
`
`Name: components/MyOtherComponent.JAR
`Content-type: application/j ava-archive
`
`FIG. 4
`
`

`
`U.S. Patent
`
`Jan.13,2009
`
`Sheet 5 of 6
`
`US 7,478,142 Bl
`
`/504
`
`Manifest-Version: 1.0
`Author: Jane Doe
`Version: 1.0
`Date: 11/09/97
`Copyright: (C) 1997 MySite.com All Rights Reserved
`
`FIG. 5
`
`

`
`U.S. Patent
`
`Jan. 13,2009
`
`Sheet 6 of 6
`
`US 7,478,142 Bl
`
`START
`
`S6-l
`
`RECEIVE SELF-CONTAINED SOFTWARE PACKAGE
`(E.g., .XJR FILE)
`
`/S6-2
`
`,,
`
`SPAWN BROWSER ENVIRONMENT (NETWORK
`CLIENT) AND LOAD/INPUT SELF-CONTAINED
`SOFTWARE PACKAGE (E.g., XJR FILE) WITHIN
`BROWSER ENVIRONMENT
`
`/S6-3
`
`BROWSER ENVIRONMENT ACCESSES AND
`EXTRACTS OBJECTS FROM MANIFEST AND .XJR
`FILE AND EXECUTES ACCORDING TO
`INSTRUCTIONS CONTAINED WITHIN CONTENT
`FILES THEREOF (E.g., IN INITIAL CONTENT FILE,
`ETC. -- HTML FILES, ETC.
`
`vs6-4
`
`~S6-5
`
`FIG. 6
`
`

`
`US 7,478,142 Bl
`
`1
`SELF-CONTAINED APPLICATIONS THAT
`ARE APPLIED TO BE RECEIVED BY AND
`PROCESSED WITHIN A BROWSER
`ENVIRONMENT AND THAT HAVE A FIRST
`PACKAGE THAT INCLUDES A MANIFEST
`FILE AND AN ARCHIVE OF FILES
`INCLUDING A MARKUP LANGUAGE FILE
`AND SECOND PACKAGE
`
`BACKGROUND OF THE INVENTION
`
`1. Field of the Invention
`The present invention relates to applications such as web(cid:173)
`based applications (software systems) which are intended to
`be executed and manifested within a network client such as 15
`within a world wide web (WWW) browser environment.
`2. Description of the Related Art
`Network clients such as world wide web (WWW) enabled
`browsers are well known. In fact, browsers have become so
`widely used, that millions of people rely on the same to carry 20
`out their normal affairs. For example, consumers can now
`access the Internet to make travel arrangements, buy house(cid:173)
`hold items, and even trade securities such as stocks and bonds
`online. Also, users within organizations can access company
`web sites via internal networks commonly referred to as 25
`"intranets" to learn about company events, complete expense
`reports, exchange project information, etc. As a result, the
`browser has become almost a staple part of the way people use
`their computers to generate and receive information.
`Although the browser network client, as a tool, has become 30
`very powerful and popular in terms of its inherent ability
`access server systems to receive content therefrom, the
`browser still remains limited in the functionality it can pro(cid:173)
`vide or allow. That is, browsers are designed to access remote
`server systems (computers) and receive content therefrom 35
`instead of providing stand-alone functionality. In other
`words, although capable of loading files and processing the
`same from local storage facilitates, they are targeted at
`accessing remote systems, receiving rich content, and provid(cid:173)
`ing a "current" web site experience. To date, browsers have 40
`not been utilized as general interfaces to facilitate general
`computing functionality that has traditionally been provided
`by stand-alone native applications and executable programs
`(e.g., form filling applications, etc.).
`The aforementioned comments are not to be taken to indi- 45
`cate that developers have not created feature rich applications
`to operate within browser environments. To the contrary,
`many developers have created elaborate applications written
`as JAVA applications or "applets," for example, and have
`distributed the same for execution within a browser network 50
`client. Typically, however, such applets are executed within a
`processing space (e.g., within a window) inside of a browser
`environment to deliver a particular feature set. Unfortunately,
`such applets are also intended to be distributed from a server
`system via a network connection and merely form part of a 55
`larger web site environment which usually includes content
`of various types including, but not limited to, hyper-text con(cid:173)
`tent (i.e., hyper-text markup language (HTML) content),
`images, sound files, JAVA, JAVA Script, etc.
`Despite the inherent ability of a browser to access server 60
`systems and receive and manifest feature rich content (e.g.,
`such as that provided via JAVA, etc.), browsers continue to
`remain under-utilized. Such under-utilization also is due, in
`large part, to the fact that there is no current, effective and
`efficient way to package content and distribute the same via 65
`network connection, physical passage (e.g., via computer(cid:173)
`readable media such as compact discs, etc.). There is no
`
`2
`current way for developers to package all content that may be
`related to a particular web-based application (e.g., one that
`would normally be served to a browser from a remote server
`system in the context of a web site, for example) and to
`distribute the same in an effective and efficient manner. For
`example, many people utilize open-standards based tools
`(e.g., HTML, etc.) to produce presentations, documentation
`sets, etc. which often include whole collections of files,
`images, etc. Save for successfully storing all such files in a
`10 commonly accessible directory, there is no way for a person to
`package all such files and make the same available or distrib(cid:173)
`ute such a package to client systems equipped with browsers.
`As such, there is no current way for a complete web-based
`application to be packaged for automatic processing within a
`browser environment and without the need for server (URL)
`distribution.
`To address the aforementioned problems, developers have
`proposed several solutions which have not heretofore effec(cid:173)
`tively allowed people to encapsulate complete web-based
`applications such as web sites. For example, many developers
`have developed file archiving formats to produce archive files
`containing all files related to a particular web application.
`Unfortunately, such currently available archiving schemes
`are not directed to the needs of a web-based application; that
`is, they are not directed to including the actual content nec(cid:173)
`essary for a browser to render or layout web based data-e. g.,
`HTML, etc. Moreover, such archiving schemes are not suited
`to produce auto-executable or auto-processable files within a
`browser environment-for example, there is no way to iden(cid:173)
`tify a starting file to cause a browser to instantly and auto(cid:173)
`matically load and render a web-based application. And,
`despite their ability to encapsulate files, such currently avail(cid:173)
`able archiving schemes have no ability to provide a stand(cid:173)
`alone file that may reside next to a native application and
`which may be treated within an operating environment as one
`in the same.
`Thus, there exists a need to allow web based application
`(e.g., those normally associated with a WWW site, etc.) to be
`encapsulated within a standard file structure, distributed via
`any form of data distribution, and which may be automati(cid:173)
`cally executed within a browser environment without having
`to cause to the browser environment to access a remote server
`system for files forming part of the web based application.
`Accordingly, there exists a need to provide new and improved
`systems and methods for encapsulating a web-based applica(cid:173)
`tion into an open-standards based file format and structure
`which may be processed by a correspondingly equipped net(cid:173)
`work client or web browser. To be viable, such a system and
`method of encapsulation must be easy to use.
`
`SUMMARY OF THE INVENTION
`
`The present invention solves the aforementioned problems
`and, in so doing, provides certain benefits not heretofore
`realized with other network clients and software packaging
`schemes. In particular, the present invention provides a soft(cid:173)
`ware component packaging scheme and corresponding net(cid:173)
`work client that facilitates the receipt and processing of self(cid:173)
`contained software systems (e.g., web sites, web-based
`applications, etc.) without requiring network access, etc. The
`present invention will allow developers and users to package
`whole collections of open-standards based content (e.g., all
`content associated with a web site, etc.) and to distribute the
`same to users who may access the same as though they were
`native, executable applications. Accordingly, the present
`invention extends the functionality of current-day web brows(cid:173)
`ers beyond that of network content access tool to allow the
`
`

`
`US 7,478,142 Bl
`
`4
`tions related to a particular intended functionality, and auto(cid:173)
`matically processing the manifest, the reference(s), and the
`initial content source within a web browser environment. The
`initial content source controls the browser environment in
`accordance with the instructions to achieve the particular
`intended functionality.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`3
`same to be considered as application processing environ(cid:173)
`ments capable of rich content manifestation, etc. Developers
`can utilize the present invention to deliver applications based
`on open-standards without having to be concerned with
`screen layout, content rendering, and other infrastructure
`issues which normally must be dealt with when developing
`stand-alone, native applications. Users will benefit from the
`present invention by becoming accustomed to a standard
`application processing environment in which many, if not all,
`of their applications are executed and run. And, users who are 10
`not otherwise connected or coupled to a network server (e.g.,
`users of disconnected laptop computers, etc.) can now receive
`whole web-based applications and run the same like native
`applications without having to login into or access a remote
`server system.
`The present invention solves the aforementioned problems
`and provides the above-described benefits by providing new
`and improved systems and methods for producing and pro(cid:173)
`cessing self-contained software systems. In particular the
`present invention provides a self-contained software package 20
`that is adapted to be automatically processed within a browser
`environment. The self-contained software package includes,
`but is not limited to, a manifest containing meta-data about
`the self-contained software package, and at least one refer(cid:173)
`ence to an initial content source. The initial content source 25
`includes instructions related to a particular intended function(cid:173)
`ality such as that corresponding to a web site, open-standards
`application, etc. The manifest and reference(s) to the initial
`content source are adapted to be automatically received by
`and processed within a network client environment (e.g., 30
`within a world wide web-WWW browser). The initial con(cid:173)
`tent source is configured to control the network client envi(cid:173)
`ronment in accordance with the instructions to achieve the
`intended functionality.
`According to another aspect of the present invention, pro- 35
`vided is a web browser adapted to receive and process a
`self-contained software package. The web browser includes
`an input module for inputting a manifest containing meta(cid:173)
`data about the self-contained software package, and at least
`one reference to an initial content source. The initial content 40
`source includes instructions related to a particular intended
`functionality such as that provided at or by a web site or by a
`web based/open standards application, etc. The manifest and
`reference(s) to the initial content source are automatically
`received by and processed within the web browser. The initial 45
`content source controls the web browser in accordance with
`the instructions to achieve the particular intended functional(cid:173)
`ity.
`According to another aspect of the present invention, pro(cid:173)
`vided is a method for generating and automatically process- 50
`ing a self-contained software package within a web browser
`environment. The method includes the steps of generating a
`manifest containing meta-data about the self-contained soft(cid:173)
`ware package, generating at least one reference to an initial
`content source that includes instructions related to a particu- 55
`lar intended functionality, automatically receiving the mani(cid:173)
`fest, the reference(s ), and the initial content source, and auto(cid:173)
`matically processing the manifest, the reference(s), and the
`initial content source within the browser environment. The
`initial content source controls the browser environment in
`accordance with the instructions to achieve the particular
`intended functionality.
`According to another aspect of the present invention, pro(cid:173)
`vided is a method of using a web browser that includes the
`steps of receiving a manifest containing meta-data about a
`self-contained software package, receiving at least one refer(cid:173)
`ence to an initial content source that further includes instruc-
`
`The present invention is discussed in detail below with
`regard to the drawing figures attached hereto, of which:
`FIG.1 is a diagram of a system in which a client computing
`system (e.g., a personal data processing system such as a
`personal computer) is equipped with a network client (e.g., a
`15 world wide web browser software system) which is config(cid:173)
`ured to receive and process a self-contained software package
`in accordance with a preferred embodiment of the present
`invention;
`FIG. 2 is a block diagram of the client computing system
`depicted in FIG. 1;
`FIG. 3 is a block diagram of a exemplary software system
`arranged and configured as a network client such as a web
`browser configured to be operated within the client comput-
`ing system depicted in FIG. 2 and which is enabled to receive
`and process a self-contained software package in accordance
`with a preferred embodiment of the present invention;
`FIG. 4 is a programmatic listing of a manifest file associ(cid:173)
`ated with a self-contained software package (e.g., archive,
`etc.) provided in accordance with a preferred embodiment of
`the present invention;
`FIG. 5 is a progranimatic listing of a manifest file corre(cid:173)
`sponding to an object referenced in the manifest file depicted
`in FIG. 4; and
`FIG. 6 is a flowchart that illustrates process steps which are
`performed to allow a network client such as a web browser to
`receive and process a self-contained software package in
`accordance with a preferred embodiment of the present
`invention.
`
`DETAILED DESCRIPTION OF THE PREFERRED
`EMBODIMENTS
`
`The present invention is now discussed in detail with
`regard to the drawing figures that were briefly described
`above. Unless otherwise indicated, like parts and processes
`are referred to with like reference numerals.
`Referring now to FIG. 1, depicted therein is a diagram of a
`system 100 that includes the Internet 104 and/or other net(cid:173)
`works and wherein a client system equipped with a network
`client software package (e.g., a world-wide-web browser,
`etc.) may receive and process self-contained software pack-
`ages in accordance with the present invention. In particular,
`system 100 includes a web server system 102 such as one
`equipped with a web server software system similar or like
`the NETSCAPE ENTERPRISE SERVER which is manufac(cid:173)
`tured and marketed by NETSCAPE COMMUNICATIONS,
`INC. System 100 also includes the Internet 104 or other
`networks such as an intranet, etc. In the context of the present
`invention, a network is a collection of automatic data process-
`60 ing systems which are coupled together via data communica(cid:173)
`tions links. System 100 further includes an ISP 106 (Internet
`Service Provider) that is capable of allowing user systems to
`access Internet 104 via modem facilities, ISDN facilities,
`leased data communications links, etc. Coupled to ISP 106 is
`65 client system 108 which is equipped, in accordance with the
`present invention, with a browser software system which is
`configured to receive self-contained software packages.
`
`

`
`US 7,478,142 Bl
`
`10
`
`5
`It should be noted that there is no requirement that ISP 108
`be present in the context of the present invention. For
`example, if network 104 is an Intranet or other private/self(cid:173)
`contained network, there is no need to provide for network
`access to outside users, etc. that may otherwise be remotely
`connected to network resources and who may require dial-up
`connections, etc.
`In system 100, a software distributor 110 is shown as being
`coupled to client system 108 via a dashed line. The dashed
`line in system 100 is meant to indicate that the coupling
`thereof may be an electronic data communications coupling,
`or one that allows a client system owner and/operator to
`acquire an executable, encapsulated software application
`(e.g., web-based application, etc.) in accordance with the
`present invention such as via other means such as through 15
`retail charmels, etc.
`Referring now to FIG. 2, depicted therein is an exemplary
`arrangement of client system 108 as originally depicted in
`FIG. 1. In particular, client system 108 is a personal automatic
`data processing system such as one similar or like a personal
`computer manufactured and marketed by IBM CORPORA(cid:173)
`TION and which includes a processor arrangement 202 of
`one or more processing elements, a data storage subsystem
`204, and an I/O subsystem 206 to allow network communi(cid:173)
`cations, etc. Data storage subsystem 204 may be configured
`with a disk array to allow software packages to be loaded
`thereon and loaded into appropriate memory systems for
`execution by processor arrangement 202. Furthermore, client
`system 108 is configured to operate, in accordance with the
`present invention, a network client such as a world wide web
`(WWW) browser software package that is further configured
`to receive encapsulated, self-contained executable software
`modules which may control the browser environment.
`In regard to FIGS. 1 and 2, a self-contained executable
`software package that may be distributed to client system 108
`has been developed. Such a self-contained, executable soft(cid:173)
`ware package may be used to wrap up web pages, scripts,
`images, sound files, JAVA, etc. into a self-contained unit for
`processing within a browser software environment in accor(cid:173)
`dance with the present invention. With such a self-contained
`unit, one could e-mail the executable package (or a link to it,
`etc.) to people and it would run automatically within a
`browser environment as provided by the present invention.
`An enterprise technology department could update the self(cid:173)
`contained unit onto all of their employee's machines, for 45
`example, such as for mission critical internal web applica(cid:173)
`tions thus saving repeated downloads and resources. More(cid:173)
`over, a sales person could take a slide presentation on the
`road, or distribute the same without having to worry about
`losing pages or images during other archiving processes. 50
`Sales people could even pack an entire web site or Visual
`JAVAscript project, etc., and take it on the road. The same
`would run without having to install a server software system
`to run the same on a laptop computer, for example, Thus, in
`order to make more powerful web based applications, the 55
`present invention provides a convenient way for Visual JAVA(cid:173)
`script and tools like it or similar to it to create a single file that
`is self-contained with everything needed to run a web based
`application (e.g., a web site). Accordingly, the present inven(cid:173)
`tion provides what may be referred to as a .XJR file. An .XJR 60
`file, in accordance with the present invention, uses the stan(cid:173)
`dard .JAR file format as proposed by NETSCAPE COMMU(cid:173)
`NICATIONS INC. and SUN MICROSYSTEMS, INC., with
`the extension change from .JAR to .XJR for "executable
`.JAR". The .XJR file format allows for a new mime type (e.g., 65
`like or similar to "applications/crossware-app", etc.). The
`.XJR file, however, has some special headers in its manifest
`
`6
`file. Manifest files will be immediately understood by those
`skilled in the art as they relate to .JAR type files. For example,
`the initial page or file (e.g., HTML file) to use when loading
`an encapsulated web application into an equipped browser is
`identified, in accordance with the present invention, in a
`manifest file associated with an archive containing all content
`necessary for a particular web application. The content (e.g.,
`initial content-HTML-may also be included directly in the
`.XJR provided by the present invention). Additionally, an
`.XJR file manifest contains a new archive type identifier such
`as "WebApp" to indicate that the associated archive (.XJR
`archive) is a web based application such as one that corre(cid:173)
`sponds to a web site, etc. (e.g., one having HTML and other
`types of content).
`The creation of an .XJR file in accordance with the present
`invention will be similar to the creation of .JAR type files and
`archives as is well known in the art. It is the present inven(cid:173)
`tion's addition of initial content identifiers, etc. (e.g., the
`inclusion of an initial content source like or similar to an
`20 initial HTML file) that allows .XJR files to be created and
`processed by a browser (web browser, etc.)that is equipped to
`handle and process the same.
`Referring now to FIG. 3, depicted therein is a block dia(cid:173)
`gram of a software system arranged and configured as a
`25 network client such as a WWW browser software system. In
`particular, network client 300 includes I/O modules to facili(cid:173)
`tate input and output of content and other data, a processing
`engine 304 to facilitate control of the other software modules
`and components within network client 300, and a rendering
`30 and layout engine to facilitate multimedia output such as
`screen output, sound output, printed output, etc. It is impor(cid:173)
`tant to note that network client 300 and the block diagram
`depicted in FIG. 3 illustrates exemplary structures which
`would be found within a browser environment and, according
`35 to the present invention, one that is configured to receive
`self-contained software packages which may be loaded into
`processing engine 304 to facilitate a feature set related to a
`particular web based application. Such a self-contained appli(cid:173)
`cation will come in the form of an .XJR file or equivalent
`40 thereof received via a network connection, a computer read(cid:173)
`able media such as a compact disc, etc. Processing engine 304
`is configured with modules and objects to facilitate process(cid:173)
`ing of .XJR and equivalent files in accordance with the
`present invention.
`Accordingly, with reference to FIG. 4, depicted therein is a
`manifest file 400 which is associated with an .XJR file and a
`related archive that contains all content related to a self(cid:173)
`contained web application (as indicated at the new "archive
`type" identifier referred to as "WebApp") in accordance with
`the present invention. Manifest file 400 includes a reference
`to an object 402 known as "index.html" which contains
`HTML content corresponding to a web based application as
`provided by the present invention. Accordingly, the present
`invention's use of a .JAR type file structure (archive) and
`manifest file to allow identification of web application com(cid:173)
`ponents now allows web developers to facilitate the distribu-
`tion of self-contained, executable software applications (web
`sites, web applications, etc.) to users to run the same within
`appropriately equipped web browser environments such as
`one similar or like that which is depicted in FIG. 3. By using
`a standard file structure like the .JAR file st