(12) United States Patent
`Baker et al.
`
`USOO6430599B1
`(10) Patent No.:
`US 6,430,599 B1
`(45) Date of Patent:
`Aug. 6, 2002
`
`(54)
`
`(75)
`
`(73)
`
`(21)
`(22)
`
`(51)
`
`(52)
`
`(58)
`
`(56)
`
`Int. Cl................................................... G06F 9/46
`U.S. Cl. ........................................ 709203. 709310
`s
`Field of Search ............................ 705/35; 700/100,
`700/102, 104; 713/201; 235/492; 709/201-203,
`213–219, 310,313–318,330; 379/93.01;
`717/108,118; 707/10, 103 R, 103 Y; 455/3.01
`
`ABSTRACT
`
`JUST-IN-TIME SERVICES FOR SMALL
`FOOTPRINT DEVICES
`
`Inventors: Mark Baker; Josh Duggan, both of
`Ottawa (CA)
`
`Notice:
`
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 0 days.
`
`Appl. No.: 09/333,422
`Filed:
`Jun. 15, 1999
`
`OTHER PUBLICATIONS
`www.google.com (2) computer Search listing, Aug. 6,
`2001.*
`Fuentes et al., “A Java Framework for Web-Based Multi
`media and Collaborative Applications,” IEEE Internet Com
`Assignee: Sun Microsystems, Inc., Palo Alto, CA puting, vol. 3, No. 2, Mar. 1999, pp.55-64.
`(US)
`Frank, “PersonalJava and Inferno for Today's Consumer
`Devices,” Java Developers Journal, vol. 3, Iss. 3, Mar. 1998,
`pp. 8-14.
`Clark, “Network nirvana and the intelligent device,” IEEE
`Concurrency, vol. 7, No. 2, Apr. 1999, pp. 16-19.
`Dolvane et al., “PersonalJava & Information Appliance, Part
`I,” Dr. Dobb's Journal, Jan. 1999, pp. 60, 62, 64–68.
`Search Report for International Application No. PCT/US
`00/14173, mailed Nov. 6, 2000.
`* cited by examiner
`Primary Examiner Kakali Chaki
`(74). Attorney, Agent, or Firm—Conley, Rose & Tayon, PC;
`B. Noël Kivlin
`(57)
`
`A lightweight containment framework Supporting share able
`program modules. The containment framework is Suffi
`ciently compact and efficient to run on a wide variety of
`resource-constrained, Small footprint devices, Such as per
`Sonal data assistants (PDAS), Smart cellular phones, global
`References Cited
`positioning System (GPS) receivers, etc. The containment
`framework provides module management Services Such as
`U.S. PATENT DOCUMENTS
`module registration, lookup, instance tracking, etc. The
`4,991,199 A * 2/1991 Parekh et al............. 379/93.01
`basic functionality provided by the framework may be
`5,485,370 A
`1/1996 Moss et al. ................. 709/217
`extended by adding System modules into the framework.
`5,923,552 A * 7/1999 Brown et al. ............... 700/100
`The shareable program modules may implement Services.
`5,933,816 A
`8/1999 Zeanah et al. ................ 705/35
`Modules may be both service providers and clients of other
`6,115,641 A * 9/2000 Brown et al. .....
`... 700/102
`Service modules. The lightweight and efficient nature of the
`6,115,642 A : 9/2000 Brown et al. .....
`... 700/104
`ES R : 33. Snor et al. .......... S. System enables application programs traditionally associated
`as
`,
`,
`,
`, ...I.7.71, with desktop computer Systems, such as Web browsers,
`6339826 B2 * 1/2002 Hayes et al. ...
`... 709/226
`email clients, etc., to run on Small footprint devices. The
`6,349,333 B1 * 2/2002 Panikatt et al. ...
`... 709/223
`on-device applications/services built on the containment
`6,351,751 B1 * 2/2002 Traversat et al. ....... 707/103 Y
`framework may be integrated with off-device Services run
`ning on network Service providers.
`FOREIGN PATENT DOCUMENTS
`98/37486
`8/1998
`
`WO
`
`9 Claims, 11 Drawing Sheets
`
`Central framework instance receives a
`module lookup request from a module
`300
`
`
`
`Todule matches the
`eves scription)
`6
`
`Register requestof module as a module user
`314
`I
`Return reference to mained module to requestor
`
`y
`
`KH
`
`Ex.1018
`APPLE INC. / Page 1 of 20
`
`

`

`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 1 of 11
`
`US 6,430,599 B1
`
`PrOCeSSOr
`100
`
`Input Mechanism
`104
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`On-Device Applications/Services
`130
`
`
`
`Containment Framework
`128
`
`Java API Class Libraries
`126
`
`Java Virtual Machine
`124
`
`- -
`
`Operating System
`122
`
`Off-Device Services
`132
`
`
`
`
`
`Hardware
`120
`
`Fig. 2
`
`Ex.1018
`APPLE INC. / Page 2 of 20
`
`

`

`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 2 of 11
`
`US 6,430,599 B1
`
`
`
`UOISIAS|S|}OUIS}U]
`
`adlAle
`Ssdnyoo7
`
`9cl
`
`ZeL
`
`
`
`BdIAIBSGAMA
`
`
`
`S|deLa}u]YIOMEWEI4jualuuUle}uoD
`
`zl
`
`OLJaluld
`
`
`
`BOIAI@SJUUd
`
`gel
`
`
`
`
`
`quodJEINJeDHeWS,,
`
`¢bl
`
`yUaUUIe}UuoD
`
`
`
`pplomewel4
`
`QPLSd1IAIaS
`
`dnyoo]
`
`vel
`
`JaSMOJGGEM
`
`srl
`
`qualigews
`
`ost
`
`
`
`ZG|Jeziueblo
`
`eBuoslad
`
`Ex.1018
`APPLEINC./ Page 3 of 20
`
`Ex.1018
`APPLE INC. / Page 3 of 20
`
`
`
`
`
`

`

`U.S. Patent
`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 3 of 11
`
`US 6,430,599 B1
`US 6,430,599 B1
`
`
`
`adIAagdnyoo7]
`
`091
`
`
`
`
`
`
`
`pbig
`
`
`
`sanquyeSdlAJas
`
`
`
`sepnordsoniesyy,
`
`
`yoalqosolAles
`2/
`
`yual|d
`
`z9L
`
`Ex.1018
`APPLEINC./ Page 4 of 20
`
`Ex.1018
`APPLE INC. / Page 4 of 20
`
`
`
`
`

`

`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 4 of 11
`
`US 6,430,599 B1
`
`
`
`
`
`
`
`
`
`Ex.1018
`APPLE INC. / Page 5 of 20
`
`

`

`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 5 of 11
`
`US 6,430,599 B1
`
`
`
`
`
`
`
`Ex.1018
`APPLE INC. / Page 6 of 20
`
`

`

`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 6 of 11
`
`US 6,430,599 B1
`
`
`
`Ex.1018
`APPLE INC. / Page 7 of 20
`
`

`

`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 7 of 11
`
`US 6,430,599 B1
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`Central
`Framework instance
`170
`
`Framework Metadata
`180
`
`List of Loaded
`Modules
`182
`
`Publicly
`Accessible
`Methods
`178
`
`Reflection
`176
`
`Legend
`-D Read/Write
`
`-D Read only
`
`
`
`
`
`Fig. 8
`
`Ex.1018
`APPLE INC. / Page 8 of 20
`
`

`

`U.S. Patent
`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 8 of 11
`
`US 6,430,599 B1
`US 6,430,599 B1
`
`
`
`6big
`
`
`
`JaBeuep
`
`061
`
`sdlAJac/uoneo|ddy—TSSS¢@—HV
`GeAA\ saualsr]
`
`
`v6Lc6LO61961GS9IAJESJULVWS0IAI@SJUJaBbeueyyjuJESMolg
`jwuld
` Bd1IM@SIdVWS01NagJUL
`
`velZ6L
`
`OL‘big861
`
`Sa|NPOW
`
`ysanbey
`
`Ex.1018
`APPLEINC./ Page 9 of 20
`
`Ex.1018
`APPLE INC. / Page 9 of 20
`
`

`

`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 9 of 11
`
`US 6,430,599 B1
`
`
`
`
`
`Personal Information
`Manager Parcel
`200
`
`Calendar
`Module
`202
`
`User Interface
`Module
`206
`
`
`
`
`
`
`
`Contact List
`Module
`204
`
`Appointment
`Module
`208
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`Fig. 11
`
`Ex.1018
`APPLE INC. / Page 10 of 20
`
`

`

`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 10 of 11
`
`US 6,430,599 B1
`
`Central framework instance receives a
`module lookup request from a module
`300
`
`
`
`Request
`listener
`register
`Eg
`302
`
`
`
`
`
`
`
`
`
`Request
`listener can
`provide requested
`mgye
`
`Yes
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`A loaded
`module matches the
`request description?
`306
`
`Matched
`module is
`multi-instantiable?
`308
`
`
`
`A
`module. Y
`Play s
`present in list o
`loaded modules?
`310
`
`
`
`NO
`Stop
`
`Module
`provider
`module can provide
`requested
`Se;
`312
`
`No
`Stop
`
`Register requestor module as a module user
`314
`
`Return reference to matched module to requestor
`316
`
`Fig. 12
`
`Ex.1018
`APPLE INC. / Page 11 of 20
`
`

`

`U.S. Patent
`
`Aug. 6, 2002
`
`Sheet 11 of 11
`
`US 6,430,599 B1
`
`Central framework instance receives a module
`release notice from a user module
`330
`
`Remove user module from list of
`USer modules
`332
`
`
`
`
`
`
`
`
`
`Other user
`modules are in user
`module list?
`334
`
`
`
`Call Can Finalize method of the
`released module
`336
`
`
`
`
`
`
`
`
`
`Canfinalize
`returns "False'?
`338
`
`
`
`
`
`Call Finalize method of the released module
`340
`
`Fig. 13
`
`Ex.1018
`APPLE INC. / Page 12 of 20
`
`

`

`US 6,430,599 B1
`
`1
`JUST-IN-TIME SERVICES FOR SMALL
`FOOTPRINT DEVICES
`
`BACKGROUND OF THE INVENTION
`
`15
`
`1. Field of the Invention
`The present invention relates to the field of resource
`constrained Small footprint devices Such as handheld
`computers, personal data assistants (PDAS), cellular phones,
`etc. More particularly, the present invention comprises a
`lightweight framework Supporting shareable Services in
`Small footprint devices.
`2. Description of the Related Art
`The field of “smart” small footprint devices is growing
`and changing rapidly. Small footprint devices include hand
`held computers, personal data assistants (PDAS), cellular
`phones, global positioning System (GPS) receivers, game
`consoles, and many more Such devices. These devices are
`becoming more intelligent and interconnected. Technologies
`such as JiniTM from Sun Microsystems, Inc. and initiatives
`such as the Open Service Gateway Initiative (OSGI) are
`expanding the traditional concepts of computer networks to
`include Small footprint devices.
`This increased device interconnection has introduced a
`need for both new types of computing Services and new
`ways to integrate computing Services, both inter-device
`based and intra-device-based Services. A “Service' is an
`entity implemented within or accessible from a device that
`can be used by a perSon, an application, or another Service.
`The concept of a Service is broad and can be considered at
`many different Scales. For example, Services include familiar
`network-based Services Such as Shared printing, email,
`telephony, etc. Services also include less familiar examples
`Such as an energy management Service which may control
`the power consumption of devices within a local network, a
`diagnostic Service which allows a device to Send information
`to a Service technician when an error occurs, a health
`monitoring Service which immediately notifies health pro
`fessionals of an emergency, etc.
`Services also include modules or applications located and
`executable within a local machine or device. For example,
`local application programs may utilize a calendar Service, a
`contact list Service, a bookmark Service, etc. In this example,
`an application program may use these Services together to
`allow a user to Select a person from the contact list, record
`an appointment time for a meeting with the perSon, and
`create a bookmark for easy access to the appointment entry.
`It is becoming more common today to execute multiple
`Services and applications together in a Single Small footprint
`device. However, Since memory, processing power, and
`other resources are typically very limited in Small footprint
`devices, a specialized lightweight Software framework is
`necessary to achieve the desired integration of Services and
`applications. It is also desirable that the framework be
`flexible and extendable enough to provide Support for any
`types of Services and applications for any kind of Small
`footprint device. A further goal may be that the framework
`be compatible and integrated with off-device Services Such
`as services available to devices in a JiniTM network. A
`60
`lightweight, extendable containment framework for
`applications/Services running on a Small footprint device is
`described herein.
`
`25
`
`35
`
`40
`
`45
`
`50
`
`55
`
`SUMMARY OF THE INVENTION
`The present invention comprises a System and method to
`contain and manage program modules in a Small footprint
`
`65
`
`2
`device. AS used herein, a module is an executable Software
`component. The invention comprises a containment frame
`work for shareable modules. One embodiment of this con
`tainment framework is referred to as York 1.1. The contain
`ment framework enables module registration, lookup,
`instance tracking, etc. Modules in the containment frame
`work may be used by other modules as services. The
`containment framework may be dynamic, allowing modules
`to be registered and loaded as desired or needed.
`Modules may be grouped into parcels and managed as a
`unit. Parcels may serve Several purposes. For example,
`much of a modules runtime context may be determined by
`the parcel from which it originates. Also, applications may
`be managed by parcel, including installation and upgrade
`procedures. Also, the parcel System enables the Support of
`multiple target development (i.e., development groups may
`use parcels to develop for different platforms or Systems
`Simultaneously without breaking reliance on common
`libraries).
`AS described above, a containment framework for a Small
`footprint device should be lightweight. The present contain
`ment framework is able to function on a device with very
`little memory. For example, in one embodiment the con
`tainment framework may function on a device with only 300
`KB writeable memory and Still leave enough memory Space
`for Several modules to operate. In addition, the containment
`framework may be responsive on devices with low proceSS
`ing power, such as Small footprint devices with 16 MHz
`class chips.
`One aspect of the containment framework which aids in
`achieving its lightweight Status is that it is a non-hierarchical
`framework. Hierarchical containment can be a very useful
`feature in a framework, providing a standard way to group
`modules and allow them to discover and use each other's
`Services. However, hierarchical containment is generally
`expensive to achieve in terms of the resources required to
`implement it. The present containment framework provides
`many of the advantages associated with a hierarchical
`framework, without the usual overhead. Modules may inter
`cept module lookup requests by other modules, thereby
`allowing them to customize the requesting module's envi
`rOnment.
`The containment framework may be based on common
`Standards. For example, in one embodiment, the contain
`ment framework may be written in pure JavaTM and may be
`fully compliant with and executed in the PersonalJavaTM 3.0
`application environment. PersonalJavaTM is a JavaTM appli
`cation environment Specifically designed for consumer
`devices for home, office, and mobile use. It comprises the
`JavaTM virtual machine (JVM) and a subset of the JavaTM
`Application Programming Interface (API), including core
`and optional APIs and class libraries. In addition, the Per
`sonalJavaTM API includes specific features required by con
`Sumer applications in resource-limited environments. It is
`noted that the containment framework may also be com
`prised in hardware ROM or be compiled into native code.
`Because the containment framework may be based on
`common Standards, it may be ported easily to different
`device types and to devices made by different vendors,
`which greatly reduces time-to-market and development
`costs. The extendable architecture of the framework may
`also allow new modules to be introduced into the framework
`as needed or desired for different devices or services. The
`architecture may also allow for customizable and Scaleable
`user interfaces. For example, the user interface component
`of an application may be Swapped out as appropriate to the
`display type for different devices.
`
`Ex.1018
`APPLE INC. / Page 13 of 20
`
`

`

`US 6,430,599 B1
`
`3
`AS described in more detail below, the containment
`framework maintains a list of loaded modules, as well as
`related System data. Modules normally access the module
`list or the System data only indirectly, e.g., by calling
`methods of a central framework instance. However, certain
`modules, referred to as System modules, may have the
`ability to access or modify the system data themselves. This
`type of direct data access to core data helps to keep the
`containment framework lightweight. Since System modules
`have access to the core System data, any necessary or desired
`extended functionality beyond the basic module manage
`ment performed by the central framework instance may be
`introduced to a System by adding an appropriate System
`module. Thus, the containment framework is also highly
`extendable.
`A System may comprise a set of core Service modules
`available for other modules to use. These core Services may
`include Services Such as the calendar, contact list, and
`bookmark Services described in an example above. Together
`with Such core Services, the containment framework pro
`vides a complete architecture for running an integrated Suite
`of applications and Services on a Small footprint device. For
`example, the Personal Applications Suite available from Sun
`Microsystems, Inc. is built around one embodiment of the
`containment framework. The Personal Applications Suite
`comprises an integrated Set of compact, memory-efficient
`applications, including the Personal Applications Browser,
`the Personal Applications Email Client, and the Personal
`Organizer.
`Although the System and method of the present invention
`may be associated with managing modules running on a
`Small footprint device, it is noted that they are not limited to
`this use. To the contrary, many aspects of the present
`invention may be useful in Systems that do not have Such a
`large resource constraint. On the other hand, embodiments
`of the containment framework may be designed So that they
`are easily transferable to environments with an even greater
`constraint in resources than the Small footprint devices
`described above. For example, an embodiment of the con
`tainment framework may run in an Embedded Java TM appli
`cation environment with little or no modification.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`Other objects and advantages of the invention will
`become apparent upon reading the following detailed
`description and upon reference to the accompanying draw
`ings in which:
`FIG. 1 is a block diagram illustrating the hardware
`architecture of a typical Small footprint device;
`FIG. 2 illustrates a typical hierarchy of hardware/software
`layers involved in a System running applications and Ser
`vices within the containment framework;
`FIG. 3 illustrates an exemplary network in which a small
`footprint device running applications/services in the con
`tainment framework is connected to a local Service-based
`network;
`FIG. 4 illustrates the discovery process, in which a service
`provider finds a lookup Service;
`FIG. 5 illustrates the join process, in which a service
`provider registers its Service with a lookup Service;
`FIG. 6 illustrates the lookup process, in which a client
`requests a Service from a lookup Service;
`FIG. 7 illustrates the service invocation process, in which
`a client invokes a Service using a Service object received
`from a lookup Service;
`
`4
`FIG. 8 is an abstract block diagram illustrating the basic
`architecture of the containment framework,
`FIGS. 9 and 10 illustrate the use of module request
`listeners in the containment framework to Simulate a hier
`archical containment environment;
`FIG. 11 illustrates the use of parcels to group modules
`together;
`FIG. 12 is a flowchart diagram illustrating a typical
`lookup process that the central framework instance may
`perform when it receives a lookup request for a Service
`module from a client module; and
`FIG. 13 is a flowchart diagram illustrating the module
`release process.
`While the invention is susceptible to various modifica
`tions and alternative forms, specific embodiments thereof
`are shown by way of example in the drawings and are herein
`described in detail. It should be understood, however, that
`the drawings and detailed description thereto are not
`intended to limit the invention to the particular form
`disclosed, but on the contrary, the intention is to cover all
`modifications, equivalents and alternatives falling within the
`Spirit and Scope of the present invention as defined by the
`appended claims.
`DETAILED DESCRIPTION OF THE
`INVENTION
`FIG. 1-Hardware Architecture Block Diagram
`FIG. 1 is a block diagram illustrating the hardware
`architecture of a typical Small footprint device. AS used
`herein, a Small footprint device is a hardware device com
`prising computing resources Such as a processor and a
`System memory, but having Significantly greater constraints
`on one or more of these resources than a typical desktop
`computer has. For example, a Small footprint device may
`have two megabytes of memory or less, whereas a typical
`desktop System may have 64 megabytes or more. Also a
`typical Small footprint device may have Significantly leSS
`processing power than a typical desktop computing System,
`either interns of processor type, or processor Speed, or both.
`For example, a personal data assistant device may have a 16
`MHZ processor, whereas a typical desktop System may have
`a processor speed of 100 MHz or higher. Also, a typical
`Small footprint device may have a display size significantly
`Smaller than the display Screen of a desktop computing
`System. For example, the display Screen of a handheld
`computer is typically Small compared to the display Screen
`of a desktop monitor.
`It is noted that the Specific numbers given are exemplary
`only and are used for comparison purposes. For example, a
`personal data assistant having eight megabytes of memory
`or more may still be a Small footprint device, although the
`device has more memory than the typical figure of two
`megabytes given above.
`Small footprint devices may also have constraints on
`other resource types compared to typical desktop computing
`Systems, besides the memory, processor, and display size
`resources described above. For example, a typical Small
`footprint device may not have a hard disk, may not have a
`network connection, or may have an intermittent network
`connection, or may have a wireleSS network connection, etc.
`Many Small footprint devices are portable and/or are
`Small compared to desktop computers, but are not necessar
`ily So. Also, many Small footprint devices are primarily or
`exclusively battery-operated. Also, Small footprint devices
`may typically have a more limited or narrow range of usage
`possibilities than a typical desktop computing System. Small
`footprint devices include, but are not limited to, the follow
`
`15
`
`25
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`Ex.1018
`APPLE INC. / Page 14 of 20
`
`

`

`S
`ing examples: handheld computers, wearable devices (e.g.,
`wristwatch computers), personal data assistants (PDAS),
`“Smart” cellular telephones, Set-top boxes, game consoles,
`global positioning System (GPS) units, electronic textbook
`devices, etc. Since new classes of consumer devices are
`rapidly emerging, it is not possible to provide an exhaustive
`list of small footprint devices. However, the term “small
`footprint device' is intended to include Such devices as may
`reasonably be included within the Spirit and Scope of the
`term as described above.
`FIG. 1 illustrates a block diagram of a typical small
`footprint device. It is noted that the small footprint device
`may have various different architectures, as desired. The
`hardware elements not necessary to understand the operation
`of the present invention have been omitted for simplicity.
`As shown in FIG. 1, the small footprint device contains a
`processor 100. The processor 100 may be any of various
`types, including an x86 processor, e.g., a Pentium class, a
`PowerPC processor, as well as other less powerful proces
`SorS or processors developed specifically for Small footprint
`devices. The processor 100 may have various clock speeds,
`including clock Speeds Similar to those found in desktop
`computer-class processors, as well as lower Speeds Such as
`16 MHZ.
`Also shown in FIG. 1 the device includes a system
`memory 102. The system memory 102 may comprise
`memory of various types including RAM or ROM. A typical
`Small footprint device may have a very Small memory
`Storage capacity compared to a typical desktop computer
`System.
`A Small footprint device may also comprise one or more
`input mechanisms. An input mechanism 104 is illustrated in
`FIG. 1. The input mechanism 104 may be any of various
`types, as appropriate to a particular device. For example, the
`input mechanism may be a keypad, mouse, trackball, touch
`pen, microphone, etc.
`A Small footprint device may also comprise one or more
`display mechanisms. A display 106 is illustrated in FIG. 1.
`However, a Small footprint device may not comprise a
`display, or may comprise another type of output mechanism,
`Such as an audio Speaker. The display mechanism 106 may
`be any of various types, as appropriate to a particular device.
`The display mechanism for a typical Small footprint device,
`Such as a Smart cellular phone, may be Small compared to the
`display of a desktop computer System.
`FIG. 2-Hardware/Software Hierarchy Diagram
`FIG. 2 illustrates a typical hierarchy of hardware/software
`layers involved in a System running applications and Ser
`vices within the containment framework. The drawing is
`exemplary, and various layerS may be added, combined, or
`omitted as appropriate for a particular device or implemen
`tation.
`The base layer shown in FIG. 2 is the device hardware
`layer 120, which comprises the hardware resources neces
`Sary to Support a Software System, Such as a processor and
`System memory. In one embodiment, the hardware of a Small
`footprint device, Such as the Small footprint device hardware
`example illustrated in FIG. 1, implements the hardware layer
`120 illustrated in FIG. 2. However, in other embodiments,
`the hardware layer 120 may be implemented in other types
`of devices, Such a device with even greater resource con
`Straints than a typical Small footprint device, Such as a Smart
`card.
`As shown in FIG. 2, the next layer up from the hardware
`layer is the operating System layer 122. AS is well known in
`the art, the operating System functions as an interface layer
`between the device hardware and Software running on the
`
`15
`
`25
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`US 6,430,599 B1
`
`6
`device and Serves as a manager for low-level taskS Such as
`input/output, memory management, etc. The operating Sys
`tem 122 illustrated in FIG.2 may be any particular operating
`System which Supports the higher layerS shown in FIG. 2.
`The operating System 122 may be a Small and efficient one
`that is Suitable for or written particularly for use in a Small
`footprint device. For example, the operating System 122 may
`be the Java"MOS operating system available from Sun
`MicroSystems, Inc.
`In one embodiment, the containment framework is imple
`mented in a Java' application environment as one or more
`JavaTM classes. As shown in FIG. 2, the JavaTM virtual
`machine layer 124 and Java' application programming
`interface (API) class libraries layer 126 are the next layers
`up from the operating System. These two layers together
`make up the JavaTM application environment, or JavaTM
`platform. Classes implementing the containment framework
`may be built using the JavaTM libraries 126 and compiled
`into bytecodes. The bytecodes are instructions which
`execute on the JavaTM virtual machine 124, which interacts
`with the operating System 122 and/or the device hardware
`120.
`In one embodiment, the containment framework is imple
`mented in the PersonalJava Java TM application environment,
`which is a JavaTM platform designed to be highly scalable,
`modular, and configurable, while requiring minimal System
`resources. PersonalJavaTM comprises the JavaTM virtual
`machine and a subset of the JavaTM API, including core and
`optional APIs and class libraries. In addition, the Personal
`JavaTM API includes specific features required by consumer
`applications in resource-limited environments, Such as a
`specialized version of the Java TM abstract window toolkit
`(AWT). The PersonalJava"M AWT library is targeted and
`tuned for consumer product look and feel, providing graph
`ics and windowing features while Supporting low-resolution
`displays and alternate input devices (via an extended event
`model for mouse- and keyboard-less devices).
`Referring again to FIG. 2, the containment framework
`128 is shown as the next layer up from the JavaTM platform
`layer. As noted above, the containment framework 128 may
`also be based on other platforms. As described in detail
`below, the containment framework 128 manages program
`modules, e.g. by enabling module registration, lookup,
`instance tracking, etc. Modules may provide various Ser
`vices. The containment framework 128 enables modules to
`request other modules, in order to use their Services. Appli
`cations may be implemented as modules that utilize the
`Services of other modules. The containment framework 128
`thus provides a lightweight, extendable Service and appli
`cation framework, enabling applications to coexist and Share
`a modular code base.
`This type of extendable architecture enabling multiple
`program modules to cooperate is an important development
`for small footprint devices. Small footprint devices have
`historically been limited to relatively narrow uses. For
`example, cellular phones were typically used for telephony
`and little else. However, as various technologies are devel
`oped allowing Small footprint devices to become “Smarter',
`having general-purpose processors, larger display Screens,
`etc., it has become desirable to expand the Scope of appli
`cations used in Small footprint devices.
`The present containment framework may enable the types
`of applications and Services generally associated with desk
`top computing environments to work together in a Small
`footprint device, in a manner that desktop computer users
`are familiar with. As illustrated in FIG. 2 and described
`above, Services and applications 130 running on a Small
`
`Ex.1018
`APPLE INC. / Page 15 of 20
`
`

`

`7
`footprint device may be implemented as modules built on
`the containment framework layer 128. For example, the
`Personal Applications suite available from Sun
`MicroSystems, Inc. is built using one embodiment of the
`containment framework 128. The Personal Applications
`Suite comprises an integrated Set of applications Such as a
`browser, an email client, and a personal organizer.
`FIG. 2 also illustrates the ability of some embodiments of
`the containment framework 128 to integrate off-device ser
`vices 132 with on-device applications/services 130. For
`example, the containment framework 128 may provide an
`interface between a Small footprint device and a network
`such as a JiniTM network. A small footprint device system
`may register its Services for use by other devices or clients
`in a network. The containment framework may also enable
`Services and applications within the Small footprint device to
`look up and use Services provided by other network devices.
`The integration of services of the small footprint device with
`network Services is discussed in more detail below for FIG.
`3.
`FIGS. 3–7: Exemplary Network Device and Service Fed
`eration
`FIG. 3 illustrates an exemplary network in which a small
`footprint device running applications/services in the con
`tainment framework is connected to a local Service-based
`network. In the example shown, a Smart cellular phone 134
`utilizing the containment framework 144 is connected to the
`network. Also shown attached to the network are a printer
`130 and an internet-enabled television 132. In this example,
`it is assumed that the printer 130 and television 132 devices
`are operable to export Services to a network and possibly use
`the Services of other devices on the network. For example,
`the printer may export its print Service 138, and the internet
`television may look up the print Service and use it to print a
`web page. To facilitate the federation of devices and Services
`in this manner, a lookup Service 136 is located on the
`network. The lookup Service 136 may reside on a Separate
`device Such as a network Server.
`The federation of devices and Services may be imple
`mented in various ways. For example, Jini' technology,
`available from Sun MicroSystems, Inc., comprises compo
`nents and a programming model which enables the type of
`distributed system illustrated in FIG. 3. In one embodiment,
`the local network shown in FIG.3 may be a JiniTM network,
`and the printer 130 and internet television 132 may be
`JiniTM-enabled devices. Each device is operable to find the
`JiniTM network lookup service and register the services it
`offers with the lookup Service. The lookup Service maps
`interfaces indicating the functionality provided by a Service
`to Sets of objects that implement the Service.
`To add its Services to a Service federation, a device or
`other Service provider may first locate an appropriate lookup
`service by using a “discovery” protocol. FIG. 4 illustrates
`the discovery process. AS shown, the Service provider 164,
`e.g. the printer 130 shown in FIG. 3, may broadcast a request
`on the local network for any lookup Services to identify
`themselves.
`Once the service provider 164 has located the lookup
`service 160, the service provider 164 may register its service
`with the lookup service 160 by using a “join' protocol. FIG.
`5 illustrates the join process. The service provider 164 may
`create a Service object which clients can use to invoke the
`service. As illustrated in FIG. 5, the service object for the
`provided Services may then be loaded into the lookup
`service