`
`U.S. UTILITY PATENT APPLICATION
`
`FILED WITH: D DISK (CRF)' D FICHE
`
`(Attached In pocket on right inside flap)
`
`z i 0
`! I ti' en
`Ii ~ ~ Iii
`
`'
`
`'
`
`'
`
`('\
`'
`
`I
`i '.I
`
`j:::
`~
`u:
`iii en
`5
`0
`
`::i
`en
`!!l
`
`::!
`
`. l
`
`i: S • TOR
`
`t
`
`CLASS 10
`
`I
`i I ..
`i
`I
`I
`
`PREPARED AND APPROVED FOR ISSUE
`
`t
`
`ISSUING CLASSIFICATION
`' ' .....ii+-~-~~~~~---.--..,--~-~~---'-------------------1
`· I
`· ORIGINAL
`CROSS REFERENCE(S)
`1 ··1!-i-++..,.e ... u_··.._s_s __ +-_su_e_c_L_A_s_s_+_,, .. c,,...LA_s_s_-111---s,u_ec_L_A_s_s_co.,.N_E_s_u_e_c_LATs_s_P_E_R_e_Lo.-c_K_>_---...-----1
`.ws
`9./1
`,J.17
`31]
`J'Z-?
`
`1·f41Jo"""i"-l-+----'--1-----t---:----tl-----+-c'7"""--l----+----1l---+-----t
`1· :~1-fl--1--1--1------'-r--....,.--1-------11--:::....:.~----+----+---l-----+-----I
`
`' r .~i-U..j__j.._j.. ___ t_, ___ -"l------it===~==::;O;;;;tc:o:n:tln:u:ed:o!n:ls:su:e:S:lip:tln:sid:e:F:ile:J:aCck=e::t _ _J
`
`DRAWINGS
`
`CLAIMS ALLOWED
`
`Print Fig.
`
`Total Claims
`
`Print Claim for 0.G.
`
`I
`
`NOTICE OF ALLOWANCE MAILED
`
`//-)/-Od
`
`Amount Due
`
`ISSUE BATCH NUMBER
`
`l/37
`
`,·.
`
`..,
`
`' i
`
`' ' l
`i
`'
`
`T~RMINAL
`DISCLAIMER
`
`dJ b) The term of !his patent shall
`
`'. extend beyond the expiration date.
`oi
`.S Patent. No . - - - - -
`
`I
`
`!
`DJc) The terminal _months of
`!hid patent have been disclaimed.
`
`Sheets Drwg.
`7
`
`Figs. Drwg.
`7
`
`-
`
`.,;;-
`
`......-::
`
`(Assistant Emminer)
`
`I -
`
`(Date)
`
`VIETD.W
`___,pu.R...,IM"'"A'="l=W-'-'-"E'f'X'"'AM=l""'N""ER"'-- 1/-J.o_tJ'fJ
`
`(Primary Examiner)
`
`(Date)
`
`///M.AIJ
`(Date)
`
`'
`'
`'
`'
`·.,
`' ' W~RNING:
`. Th8f1ntormatlon disclosed. herein may be restricted. Unauthorized disclosure may l;>e prohibited by the United States Code Title 35, Sections 122, 181 and 368.
`', Pos~sslon outside the U.S. Patent & Trademark Office Is restrtcted to authorized employees and contractors only.
`
`APPL-1002 / Page 1 of 176
`Apple v. Uniloc
`
`
`
`! I ., .
`_; P-ATENf . APPtiCJ(flON'
`\ \\\\\\ 1111\ 111111111111111 ~Ill\\\\\ Ill\\\\\\ Ill\
`•
`09237609
`
`·
`. .-
`
`L
`
`J
`
`~ ----· ......
`
`CONTENTS
`Oate rece.,ed
`{Incl. c. of M.)
`or
`Date Mailed
`
`42.
`
`43.
`
`44.
`
`45.
`
`.46.
`
`47.
`
`48.
`
`49 .
`
`'].. -1 tJ-'JfJ
`f}J
`·'
`t,l-{}--_
`4~,1;-~~
`~ -
`~ .
`
`50.
`
`4-£.l. :{ii)_
`.·
`O/J-1~4
`2~-aO
`1~qtf0
`11~---t-0
`- ~
`. nna1~{2sllta) 98l[:
`. 0
`
`51.
`
`52.
`
`53.
`
`54.
`
`55.
`
`56 .
`
`57.
`
`8 ..
`~9.
`~o.
`~1.
`~2.
`23.
`
`24.
`
`~5.
`
`26.
`
`27.
`
`a8.
`
`a9.
`
`30.
`
`31.
`
`32.
`
`33.
`
`34.
`
`35.
`
`36.
`
`37.
`
`$8.
`39 •••.
`
`40.
`
`41.
`
`•
`
`58.
`
`59.
`
`60.
`
`61.
`
`62.
`
`63.
`
`64.
`
`65.
`
`66.
`
`67.
`
`68.
`
`69.
`
`70.
`
`71.
`
`72.
`
`73 •
`
`74.
`
`75.
`
`76.
`
`77.
`
`78.
`
`79.
`
`80.
`
`81.
`
`82.
`
`~LEFT OUTSIDE)
`
`INITIALS __
`
`Date received
`(Incl. C. of M.)
`or
`Date M11lled
`
`?
`
`'
`
`"' .. '
`
`APPL-1002 / Page 2 of 176
`
`
`
`• ISSUE SLIP STAPLE ARHA (for additional crQss refe:Ces1"'
`
`POSmON
`
`~I E DETERMINATION
`0 l.P.E. CLASSIFIER
`~ AMAUTY REVIEW
`l .
`. i·
`
`I
`
`'
`I
`i
`
`................................. Rejected
`t1
`= ................................. Allowed
`-
`(Through numeral) ... Canceled
`................................. Restricted
`•
`.,
`
`N ................................. Non-elected
`I ................................. Interference
`A ................................. Appeal
`0 ................ : ................ Objected'
`
`· · Clal
`
`~·
`
`Date
`
`Claim.
`
`Date.
`
`Claim
`
`Date
`
`~.
`
`'I'
`. ll 1
`
`·'
`
`. ' 1
`1
`
`-
`
`M ii
`
`.,
`
`1:
`
`<
`
`"'
`
`,_J.!
`2
`2
`28
`2
`a
`31
`32
`33
`~
`3•
`36
`37
`311
`39
`40
`41
`42
`43
`44
`45
`46
`47
`48
`49
`)'; 50
`
`~ l
`
`8
`101
`10:
`100
`104
`105
`06
`107
`106
`Oil
`1
`111
`112
`11
`11
`115
`11
`117
`11
`11
`20,
`121
`22
`1Z
`12•
`125
`~26
`127
`128
`29
`30
`31
`~a:
`
`·~ 1~
`13
`
`'" 3
`
`38
`3
`h4C
`141
`14
`14
`144
`4
`4
`4
`141
`141
`""
`
`I
`
`.
`
`'•
`
`~ g
`~
`51
`52
`53
`54
`55
`
`. 58
`
`. 57'
`58
`59
`. 60
`81
`82
`63
`64
`85
`86
`67
`8e
`89
`70
`71
`72
`73
`74
`75
`76
`77
`78
`79
`eo
`81
`82
`63
`e4
`85
`e6
`e7
`88
`89
`90
`91
`92
`93
`94
`95
`96
`97
`98
`99
`'"' .
`
`If more than 150 claims or 1 O actions
`staple additional sheet here
`
`(i;.EFT INSltlE)
`
`.
`
`.
`
`APPL-1002 / Page 3 of 176
`
`
`
`'
`
`. ,
`
`I
`I
`i
`
`Class
`7o1
`
`I
`
`\ I
`
`~I-
`_}A}J -• ;;JA L>
`~1>
`;;>]
`(iiJJ
`~
`~)o
`(!])
`3/Cf,
`~ I
`
`36U'i.1
`
`,._.,. ...... •
`
`-t'Jff7
`
`7-/ 1/-<>o
`
`/)V.
`
`' '
`,/v,
`
`.
`
`'
`
`7-lf-tli)
`
`/D-( I - tJi>
`
`,J.1
`
`/ /
`
`/
`
`/
`
`SEARCHED
`
`.
`
`Sub.
`
`Date
`
`Exmr.
`
`SEARCH NOTES
`(INCLUDiNG SEARCH STRATEGY)
`
`Date
`
`Exmr.
`
`..f-6 -otl
`
`t/v ,
`
`4,6-tJo
`
`i/v.
`
`·wr
`
`Yf ~ N/
`vrd ,;;/.e,(, alt
`
`7 D"'J
`
`/
`
`INTERFERENCE SEARCHED
`Sub.
`Class
`Date
`Exmr .
`2'7
`J,l'j
`~l
`>is
`1i-c;
`
`l1-2vtJo.
`
`./ i/,
`
`I/ v
`
`I/
`
`Ill /
`
`I ;
`
`,
`
`{RIGHT Ot:Jts1ot:)
`
`-------..
`
`APPL-1002 / Page 4 of 176
`
`
`
`(12) United States Patent
`Luo et al.
`
`I lllll llllllll Ill lllll lllll lllll lllll lllll 111111111111111111111111111111111
`US006216158Bl
`US 6,216,158 Bl
`Apr. 10, 2001
`
`(10) Patent No.:
`(45) Date of Patent:
`
`(54) SYSTEM AND METHOD USING A PALM
`SIZED COMPUTER TO CONTROL
`NETWORK DEVICES
`
`(75)
`
`Inventors: Wenjun Luo, Fremont; Elaine P.
`Lusher, Pleasanton, both of CA (US)
`
`(73)
`
`Assignee: 3COM Corporation, Santa Clara, CA
`(US)
`
`( *)
`
`Notice:
`
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 0 days.
`
`(21) Appl. No.: 09/237,609
`
`(22) Filed:
`
`Jan.25, 1999
`
`Int. Cl.7 ...................................................... G06F 13/00
`(51)
`(52) U.S. Cl. .......................... 709/217; 709/219; 709/225;
`709/313; 709/329
`(58) Field of Search ..................................... 709/202, 203,
`709/217, 219, 223, 225, 230, 250, 313,
`319, 328, 329
`
`(56)
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`5,564,070 * 10/1996 Want et al.
`.......................... 455/507
`5,790,977 * 8/1998 Ezekiel ................................. 702/122
`5,832,506 * 11/1998 Kuzma ................................. 707/200
`5,909,545 * 6/1999 Frese II et al. ...................... 709/208
`
`5,923,885 * 7/1999 Johnson et al. ...................... 395/712
`5,964,836 * 10/1999 Rowe et al.
`......................... 709/221
`5,973,696 * 10/1999 Agranat et al. ...................... 345/357
`
`OTHER PUBLICATIONS
`
`M.G. Lamming, Institute for Personalized Information
`Environment 1994 "Towards Future Personalised Informa(cid:173)
`tion Environments" Technical Report EPC-1994-104,
`Dec. 21, 1993.
`McCandless, Michael, "The PalmPiolt and the Handhled
`Revolution", IEEE Expert, Nov./Dec. 1997, pp. 6-8.
`* cited by examiner
`Primary Examiner-Viet D. Vu
`(74) Attorney, Agent, or Firm-Mark A. Haynes; Haynes &
`Beffel LLP
`
`(57)
`
`ABSTRACT
`
`Controlling network services using palm sized computers is
`described. A program on the palm sized computer is used to
`access a registry of network services that may be available.
`The registry includes descriptions for various services. Each
`description includes at least a reference to program code that
`can be downloaded to the palm sized computer. Executing
`this program causes the palm sized computer to issue
`commands directly to the specific network services needed.
`In some cases, these network services include application
`services for running desktop applications that the palm sized
`computer could not execute.
`
`20 Claims, 7 Drawing Sheets
`
`4. Control
`~
`
`120
`Lookup Service
`
`130
`
`Application Service
`
`D
`
`(
`(
`(
`(
`(
`c
`(
`(
`~(((((((
`
`•
`
`I
`
`I
`
`I
`
`I
`
`150
`Storage
`Service
`
`My Slide
`Show
`
`e8,'c c'c'c'c'c
`140 Display Service
`
`APPL-1002 / Page 5 of 176
`
`
`
`U.S. Patent
`
`Apr. 10, 2001
`
`Sheet 1 of 7
`
`US 6,216,158 Bl
`
`4. Control
`~
`
`120
`Lookup Service
`
`130
`
`Application Service
`
`D
`
`•
`
`(
`c
`(
`c c c c c
`c::::::Jc < c c c c c
`
`I
`
`I
`
`I
`
`I
`
`150
`Storage
`Service
`
`My Slide
`Show
`
`( c < ( c
`c c
`•i=::::Jc c
`c c c c
`c
`
`140 Display Service
`
`FIG. 1
`
`APPL-1002 / Page 6 of 176
`
`
`
`"""" 9'- ,....
`tJ
`Q"\
`rJ'J.
`L:
`
`""""
`cc
`QO
`tll
`
`~ .....
`N
`~ .....
`==(cid:173)~
`rJJ.
`
`...;i
`
`""""
`0
`0
`N
`"""" s~
`~
`>
`
`~ = ......
`~ = ......
`r:.11 •
`•
`t'.:j
`
`FIG. 2
`
`Computer Service
`250 Network Based
`
`"R .. D '/
`
`eg1strauon rrotoco
`
`/
`
`"'Registration
`
`200 Control Device
`
`25Z Service Device Communications Program
`
`202 Network Communications
`
`268 Application
`
`ZQQ Service Middleware Protocol Manager
`~ Service A~~lication Control Protocol Manager
`
`Objects
`Service
`
`2so Service Control Application
`
`251 Service Device Operating System
`
`222 EmailServiceObject
`
`m SlidePresentationServiceObject
`
`222. FaxServiceObject
`222 PrintServiceObject
`
`220 Directory of Services
`
`218 ~Airlrllr11ul'lrt
`
`21Q Middleware Protocol Manager
`ill. Application Control Protocol Manager
`
`~~~~_...::..~~~---,
`
`~Mee rnsoove~Prulocol~
`
`Software Download
`
`Control Commands
`
`APPL-1002 / Page 7 of 176
`
`
`
`lo-"
`~
`~
`(It
`lo-"
`-..O'I
`lo-"
`'N
`O'I
`rJ'J.
`
`e
`
`-..J
`0 .....,
`~
`
`~ .....
`'Jl =(cid:173)~
`
`'"""'
`N c c
`'"""' ~=
`"Cl :;
`>
`
`~ = ......
`~ ......
`~
`•
`\JJ.
`d •
`
`I ~50 Network Based
`
`Computer Service
`
`ill Service Device Communications Program
`
`FIG. 3
`
`'Jini Oiscove~ Protocol/
`
`100 Palm Sized Computer 'Jini Oiscove~ Protocol/
`
`-------"----------.
`
`ZQZ Network Communications Program
`
`318 Java Virtual Machine
`
`216 Middleware Protocol Manager
`314 PowerPoint Control Protocol Manager
`
`I 212 GUI
`I
`210 Control Application
`301 Palm Operating System
`
`368 PowerPoint
`
`ZQQ Service Middleware Protocol Manager
`~ PowerPoint Control Protocol Manager
`
`Objects
`Service
`
`260 Service Control Application
`
`ID Service Device Operating System
`
`222 EmailServiceObject
`
`221 SlidePresentationServiceObject
`
`222 FaxServiceObject
`222 PrintServiceObject
`
`220 Directory of Services
`
`PowerPoint Control Commands
`
`-----
`
`~Jini Lookup Protocol~
`/iC-Ontrol Software VilMiload ~
`
`APPL-1002 / Page 8 of 176
`
`
`
`U.S. Patent
`
`Apr. 10, 2001
`
`Sheet 4 of 7
`
`US 6,216,158 Bl
`
`210 Control Application
`
`410 CPU Service
`
`Middleware Protocol Layer
`
`PowerPoint Control Protocol Manager
`
`PowerPoint Control
`CPowerPoint
`
`420 Storage Service
`
`Middleware Protocol Layer
`
`430 Projector Service
`
`Middleware Protocol Layer
`
`LDAP front end
`
`Projector control front end
`
`Backend LDAP Database
`CLdapDb
`
`Projector Control
`CProjector
`
`FIG. 4
`
`APPL-1002 / Page 9 of 176
`
`
`
`U.S. Patent
`
`Apr. 10, 2001
`
`Sheet 5 of 7
`
`US 6,216,158 Bl
`
`Object Class Hierarchy
`
`CPowerPoint
`
`Presentation
`
`Slide
`
`Projector
`
`FIG. 5
`
`APPL-1002 / Page 10 of 176
`
`
`
`U.S. Patent
`
`Apr. 10, 2001
`
`Sheet 6 of 7
`
`US 6,216,158 Bl
`
`Object Class Hierarchy for Network Services
`
`I
`
`Service
`
`I Network Service
`
`I
`Application
`Service
`I
`I
`Slide Presentation
`Service
`
`I
`Operating System
`Service
`
`I
`Projection
`Service
`
`I
`Service Location
`Service
`
`Storage
`Service
`
`I
`Speech Recognition
`Service
`
`I
`Groupware
`Service
`
`I
`Service
`
`I Object Instance
`
`I
`
`Object Class
`
`FIG. 6
`
`APPL-1002 / Page 11 of 176
`
`
`
`U.S. Patent
`
`Apr. 10, 2001
`
`Sheet 7 of 7
`
`US 6,216,158 Bl
`
`Object Class Hierarchy for Application Services
`
`Application
`Service
`
`Slide Presentation
`Se Nice
`
`PowerPoint
`
`I
`Speech Recognition
`Service
`I
`
`I
`Via Voice
`
`I
`Naturally
`Speaking
`
`Groupware
`Service
`
`Service
`
`I
`Alta Vista
`Forum
`
`I
`Lotus
`Notes
`
`I
`Microsoft
`
`Eudora
`
`Netscape
`
`I Object Instance
`I
`
`Object Class
`
`I
`I
`
`FIG. 7
`
`APPL-1002 / Page 12 of 176
`
`
`
`US 6,216,158 Bl
`
`1
`SYSTEM AND METHOD USING A PALM
`SIZED COMPUTER TO CONTROL
`NETWORK DEVICES
`
`BACKGROUND OF THE INVENTION
`
`1. Field of the Invention
`This invention relates to the field of networked computer.
`In particular, the invention relates to a system and method to
`control network devices using a palm sized, or otherwise
`reduced functionality, computer.
`2. Description of the Related Art
`Palm sized computers, also referred to as Personal Digital
`Assistants (PDAs), are portable devices which perform an
`array of personal management tasks such as calendar man(cid:173)
`agement and address book storage. The adoption of palm
`sized computers has been rapid. Some palm sized computers
`are able to interface with conventional computing devices,
`such as PCs, on an as-needed basis. For example, palm sized
`computers such as 3Com's Palm Platform™ computers can
`upload personal appointments to a PC-based calendar.
`Palm sized computers generally have the following char(cid:173)
`acteristics. Relative to desktop and laptop computers, palm
`sized computers have limited processing, display and input
`capabilities. As a result of these limitations, palm sized
`computers do not run the same applications as desktop or
`laptop computers. Other limitations of palm sized computers
`include limited battery life and lower bandwidth communi(cid:173)
`cations with other devices.
`One big advantage of palm sized computers is their
`portability. Therefore, it is desirable to be able to access
`desktop functionality from palm sized computers.
`
`SUMMARY OF THE INVENTION
`
`2
`FIG. 7 illustrates an example class hierarchy for applica(cid:173)
`tion services that can be provided in the system of FIG. 1.
`
`DETAILED DESCRIPTION
`5 A System Overview
`A palm sized computer can serve as a network portal to
`usher in a new generation of mobile computing. Palm sized
`computers are the ideal next generation computing device in
`that they are inherently mobile and have the lightweight
`10 form factor necessary for mobile computing. The fundamen(cid:173)
`tal obstacle to palm sized computers as the next generation
`computing device can be removed by viewing the network
`as an extension of the palm sized computer's resources.
`Functions can be downloaded into the device as needed, and
`15 overlaid after they have been used. This allows the palm
`sized computer to adapt to a changing environment (as the
`mobile user's location changes) and to access exactly the set
`of services it needs. These services are stored on the network
`and can be used at will. Many of these services may never
`20 reside on the device and are more suitable for execution by
`a conventional computer. However, they are accessible and
`can be controlled via a lightweight computing device, such
`as a palm sized computer.
`B. Building Blocks of Network-Enabled Palm Sized Com-
`25 puters
`The building blocks for lightweight mobile computing
`include a palm sized computer, a compute/memory/storage(cid:173)
`intensive device(s), and a network.
`Middleware allows palm sized computers to discover
`30 network-based computing resources. Once discovered, this
`middleware provides a mechanism for the palm sized com(cid:173)
`puter to use these resources. This middleware typically
`includes a directory of resources (or services), a protocol for
`storing and retrieving from the directory, and mechanisms to
`35 transfer software from the directory to a palm sized com(cid:173)
`puter.
`Control applications reside on a lightweight computing
`device, such as a palm sized computer, but manipulate
`computing services on the network. Control applications
`40 assume the use of middleware, such as Sun Microsystems
`Jini, for access to network-based resources. (Note in some
`embodiments, the control application is distributed between
`the palm sized computer and a control proxy server.)
`Example Registry and Control Infrastructure: Jini
`Jini™ is a technology developed by Sun Microsystems
`which addresses the problem of computing and network
`complexity. It eases the burden of accessing services by
`providing seamless access and automatic registration of
`network resources. Jini accomplishes this by adopting a
`50 model in which devices announce their presence and capa(cid:173)
`bilities to the network, and access the same type of infor(cid:173)
`mation in order to locate services they wish to use.
`The Jini approach relies on Java and a Jini "registry" (i.e.
`database of services) as the underlying infrastructure. Each
`55 device is expected to run a Java Virtual Machine (JVM), or
`rely on a Jini proxy which runs a JVM on the device's
`behalf. Key to Java is the idea that software (as well as data)
`can be dynamically downloaded to a device. The Java model
`assumes a distributed, network-centric model in which the
`60 behavior of a device can be dynamically altered to accom(cid:173)
`modate changing conditions.
`Jini eases network connectivity problems. Jini acts as
`middleware to access network resources, as it lets devices
`locate services and download software for those services.
`65 Other middleware could be substituted for Jini if it provides
`discovery and software download for network-based ser-
`vices.
`
`Controlling network services using palm sized computers
`is described. A program on the palm sized computer is used
`to access a registry of network services that may be avail(cid:173)
`able. The registry includes descriptions for various services.
`Each description includes at least a reference to program
`code that can be downloaded to the palm sized computer.
`Executing this program causes the palm sized computer to
`issue commands directly to the specific network services
`needed. In some cases, these network services include
`application services for running desktop applications that the 45
`palm sized computer could not execute.
`In some embodiments, the device executing the network
`services and the palm sized computer are executing middle(cid:173)
`ware applications for communicating with the registry. In
`some embodiments, this middleware includes Jini technol(cid:173)
`ogy from Sun Microsystems. Additionally, the programs
`downloaded can include Java program code.
`
`BRIEF DESCRIPTION OF THE FIGURES
`
`FIG. 1 illustrates a system having a palm sized computer
`controlling operations of various network devices.
`FIG. 2 illustrates a software architecture for use in the
`system of FIG. 1.
`FIG. 3 illustrates an example architecture for controlling
`a PowerPoint presentation.
`FIG. 4 illustrates a detailed software architecture for the
`example of FIG. 3.
`FIG. 5 illustrates a class hierarchy that can be used in the
`example of FIG. 3.
`FIG. 6 illustrates an example class hierarchy for network
`services that can be provided in the system of FIG. 1.
`
`APPL-1002 / Page 13 of 176
`
`
`
`US 6,216,158 Bl
`
`3
`
`25
`
`30
`
`C. Definitions
`A control device is a device which runs Jini (or some other
`discovery and software download technology) and is
`capable of accessing a wide range of network-centric
`services, including services which are incapable of running 5
`on the control device. The control device is the access device
`for a wide class of computing services otherwise inacces(cid:173)
`sible to devices with restricted computing power. 3Com's
`palm sized computer, the Palm Computing platform, is an
`example of such a control device. Windows CE compatible 10
`devices may also be used.
`A control application is as an application that relies on
`resources located off of the control device (e.g. on a
`network), but uses a control device to initiate and control the
`application. The resources are accessed and controlled, but 15
`not resident, on the control device. Examples of such
`compute/memory-intensive services include PowerPoint
`slide presentations and speech recognition systems. These
`services can be both invoked and controlled via a control
`device.
`Network-based services can be used by any control
`device. Services offer a discrete task to the control device.
`This contrasts with a traditional model in which devices,
`such as a PC, house the entirety of resources a control device
`might utilize. Services are fine-grained and represent a
`distributed set of capabilities residing on a network. Services
`may or may not be co-located with other services on the
`same physical device. Services are offered (via a network
`and a Directory of Services, such as the Jini Lookup) in as
`small a unit as is justifiable given the application tasks users
`will typically want to accomplish. Fine-grained services can
`be used by a variety of consumers who need precisely that
`function. The model that emerges is a network-based model
`that offers a wide range of narrowly-defined computing
`services of interest to a wide range of applications. Services
`will be physically distributed across devices but accessible
`via a central repository (e.g. database) of services. This
`model of distributed computing is inherently scalable in that
`the set of services offered via the network grows seamlessly
`as devices "plug in" and announce their capabilities.
`D. An Example of the Control Application
`To help illustrate the use of a control device and a control
`application, a PowerPoint slide presentation control is
`described herein. (FIG. 1 illustrates a generalized view of
`such an example.) In this example, a palm sized computer 45
`100 accesses network 110 resources (via a Directory of
`Services, such as the lookup service 120) to locate the
`elements it requires to remotely control a presentation
`located on the network. The palm sized computer 100 uses
`three services to function as a control device to display a 50
`PowerPoint presentation:
`an application service 130 (to run PowerPoint)
`a persistent storage service 150 (to store the presentation)
`a display service 140 (to display the presentation images)
`Each of these services will have registered with the
`lookup service 100. A service in this example, is tied to
`different hardware devices. However, this is not required.
`Storage, processing, and/or display could be supported by
`one or more computer systems.
`None of these services are resident on the palm sized 60
`computer 100. Once the palm sized computer 100 has
`located the necessary services, it downloads the code
`required to control those services (using the lookup and
`download protocols). Middleware, such as Sun's Java/Jini
`technology, is used to move the code.
`The palm sized computer 100 is then capable of directly
`controlling the services it requires.
`
`4
`In this example, all the devices can communicate on the
`network 110, however, they need not all be connected to the
`network in the same way.
`Functionally, the devices play the following roles:
`palm sized computer 100: the remote control device
`application services: a set of resources and services, such
`as compute power and applications
`network 110: the physical medium which connects
`devices and services
`lookup service 120: a database of network services
`E. Architecture
`As noted above, the palm sized computer 100 functions as
`the remote control device for the Power Point presentation. It
`is a multi-function control device in that it can control a host
`of resources accessible via the network. The palm sized
`computer 100 accomplishes this via middleware (e.g. Jini)
`and a generic control protocol capable of issuing control
`commands to an offboard resource. The palm sized com-
`20 puter 100 implements this control via the software compo(cid:173)
`nents depicted in FIG. 2. These software components rep(cid:173)
`resent a generic architecture for control of any network(cid:173)
`based resource using a reduced functionality computer such
`as a palm sized computer. The software architecture,
`middleware, and control protocol implement a new model
`for lightweight mobile computing. This model of light(cid:173)
`weight mobile computing is particularly well-served by
`devices such as a palm sized computer, as they possess the
`requisite size and portability.
`In FIG. 2, the control device 200 is able to control services
`on the network 110, such as the network based service 250.
`The directory of services 220 provides the registry functions
`used to enable the system.
`The control device 200 includes a control device operat-
`35 ing system 201 which supports a network communications
`program 202 and a control application 210. The network
`communications program 202 allows the control device 200
`to communicate with other devices on the network. The
`control application 210 includes the following elements:
`a GUI 212 to display the available network-based services
`and accept user input
`an application control protocol manager 214 which inter-
`faces between the control device 200 and the network
`based computer service 250 by requesting tasks from
`that service (e.g. slide manipulation). This module is
`responsible for generating the application control pro-
`tocol to command the selected service,
`a middleware protocol manager 216 to transfer data
`between the control device 200 and the directory of
`services 220 (e.g. communication between Palm plat(cid:173)
`form and the Jini Lookup). This module is responsible
`for generating the syntax necessary to communicate
`based on the type of middleware being used.
`The service device operating system 251 includes a
`55 service device communications program 252 and a service
`control application 260. The service device communications
`program 252 is responsible for communicating with the
`network 110. The service control application 260 includes
`the following components:
`a service application control protocol manager 262 that
`interfaces between the network based computer service
`250 and the control device 200 and accepts control
`tasks (e.g. slide manipulation) issued from the control
`device 200. This module is capable of sending back a
`response (e.g. status) to the control device 200,
`a middleware protocol manager 266 to transfer data
`between the network based computer service 250 and
`
`40
`
`65
`
`APPL-1002 / Page 14 of 176
`
`
`
`US 6,216,158 Bl
`
`5
`
`5
`the directory service (e.g. communication between the
`application service 130 and the Jini Lookup). This
`module is responsible for generating the syntax used to
`communicate based on the type of middleware being
`used.
`an application 268 to perform functions on the network.
`The application 268 can be a desktop application that
`would not execute on a palm sized computer.
`Returning to the specific example of the PowerPoint
`presentation, FIG. 3 illustrates the architecture that could be 10
`used to implement such a system. In FIG. 3, the control
`device 200 has been replaced with a palm sized computer
`100 executing the Palm OS 301. The GUI 212 is specifically
`for PowerPoint control (see FIG. 1 for an example of such
`a GUI). The Java Virtual Machine 318 is executing on the
`palm sized computer 100 and replaces the middleware 218. 15
`The middleware protocol manager 216 supports Jini
`discovery, lookup and download protocols. PowerPoint con(cid:173)
`trol commands are issued to the network based computer
`service 250. The PowerPoint control protocol manager 364
`provides the interface for these commands and controls the 20
`PowerPoint application 368.
`F. Control Flow
`The process for accessing and controlling network-based
`services is described below. The specific implementation
`control of a PowerPoint Service via a 3Com Palm Comput- 25
`ing platform is used as an example. Refer to FIG. 1.
`1. Configure a computer hosting the directory of services
`220 and connect it to the network 110. For instance, a Jini
`lookup service is configured to listen at a preset TCP, or
`UDP, port for service registration or service lookup 30
`requests.
`2. Establish a network connection from the network based
`computer service 250 to the network 110.
`3. Register the computing service with a directory of ser(cid:173)
`vices 220. For example, in the Jini model, the computing 35
`service initially sends out a multicast packet announcing
`its presence on the network. Once the directory service
`220 receives the packet, it sends a unicast packet back to
`the announcer. The packet includes an interface (e.g. Java
`code) for uploading code back to the directory service 220 40
`as well as for searching and downloading code from the
`directory service 220.
`4. Upload service description to the directory service 220. If
`Jini is adopted as the middleware, the application service
`130 receives the response from the directory service 220 45
`and uses the included interface to upload its service
`interface to the directory service 220. When the service
`interface is called, it contacts the directory service 220
`which in turn creates an entry (represented by an object)
`for this new service and sets the proper fields such as 50
`service name, attributes and optionally the corresponding
`service interface. Other middleware may choose to use
`protocol-based approaches such as FTP or TFTP for the
`uploading process.
`5. Register the storage service 150 and display service 140 55
`via the same process.
`6. Establish a network connection from the control device
`200 to the network 110. For Palm computers, there are
`multiple options for network connectivity. Possible solu(cid:173)
`tions include using the infrared (IR) port to talk to a 60
`IR-LAN bridge or router, using the serial port to talk to a
`serial-to-LAN bridge or router, using either the IR or the
`serial port to talk to a digital cell phone and dial up a
`modem server, and/or using wireless data communica(cid:173)
`tions.
`7. Launch the service control graphical user interface (GUI)
`212 on the control device 200.
`
`6
`8. Via the service control GUI 212, accept user input, such
`as the selection of an application (for example, a Power(cid:173)
`Point application) to be controlled.
`9. Optionally register the control device 200 with the direc(cid:173)
`tory service via a registration protocol, such as the Jini
`Discovery Protocol. This step is the same as the above one
`for the other services. It is executed only if the control
`device 200 has resources to offer.
`10. Search the directory service 220 and download the
`desired service descriptor. In the case of Jini, after the
`control device 200 receives the response from the direc(cid:173)
`tory service 220, it uses the included interface to search
`the directory service 220 for an application service using
`the object type representing the service (such as an object
`type of PowerPoint presentation service) and the desired
`service attributes (such as the name and the physical
`location of the service). Once the directory service 220
`finds such a service entry, the control device 200 is
`notified, which in turn uses the downloading interface to
`download the application service descriptor. One example
`of these services is the GUI code for controlling a
`PowerPoint presentation.
`11. Send requests from the control device 200 to the network
`based computer service 250 to control the desired appli(cid:173)
`cation. For example, a "next slide" request could be sent
`from a palm sized computer 100 to an application service
`130 running PowerPoint. The communication can be
`based on a protocol such as the following one:
`
`Control Type
`
`Application
`
`File Name
`
`Control Function
`
`Where:
`Control Type={Request, Reply}
`Application={PowerPoint, FAX, Print, Email,
`Phonebook, ... }
`File Name={ 3ComPalm VII Specification}
`Control function={File Load, Slide Forward, Slide
`Backward, File Close, ... }
`Alternatively, techniques such as Java's Remote Method
`Invocation (RMI) can be used to achieve the same goal. In
`this case, the control device makes a local function call such
`as doForwardSlide( ). The RMI mechanism will transfer the
`call to a remote machine which implements and carries out
`the function call. The PowerPoint presentation service may
`in turn use other services such as the storage service 150 and
`the display service 140. The procedure to employ these
`services is similar to steps 10-11 above.
`12. Accept any response to requests sent from the control
`device 200 to the network based computer server 250 and
`process any errors.
`G. Control Device GUI
`An important element of the control application 210 is a
`GUI front-end which accepts user input for controlling the
`Power Point presentation (or other application) and a control
`protocol manager backend which takes user input and trans-
`lates it into commands to the CPU service. An example GUI
`is depicted in FIG. 1. The example GUI allows the user to
`click on "forward", "backward", "go-to-first-page" or "go(cid:173)
`to-last-page" buttons to control the slide show. The user can
`also click a "get-list" button to get a full list of the slide titles
`in the current presentation and choose to go to a particular
`slide. By clicking the "scribble" button, the window
`switches to graphics mode. In this mode, the user can draw
`65 at random on the panel, and the result of the drawing will be
`sent to the CPU service and eventually displayed on the
`projection service.
`
`APPL-1002 / Page 15 of 176
`
`
`
`US 6,216,158 Bl
`
`7
`As explained in the software flow section, there are
`multiple ways to