(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-1001 / Page 1 of 15
`Apple v. Uniloc
`
`

`

`U.S. Patent
`
`Apr. 10, 2001
`
`Sheet 1of7
`
`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
`
`11.Q Network
`
`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-1001 / Page 2 of 15
`
`

`

`lo-"
`~
`~
`(It
`lo-"
`-..O'I
`lo-"
`'N
`O'I
`rJ'J.
`
`e
`
`-..J
`0 ......,
`N
`~ .....
`'Jl =(cid:173)~
`
`'"""'
`N c c
`'"""' ~=
`"Cl :;
`>
`
`~ = ......
`~ ......
`~
`•
`\JJ.
`d •
`
`FIG. 2
`
`Computer Service
`250 Network Based
`
`"R .. 0 I/
`
`eg1strat1on rrotoco
`
`'---Registration Protocol /
`
`200 Control Device
`
`252 Service Device Communications Program
`
`268 Application
`
`ZQfi Service Middleware Protocol Manager
`264 Service A~~lication Control Protocol Mana~er
`
`Objects
`Service
`
`222 EmailServiceObject
`
`m SlidePresentationServiceObject
`
`222 FaxServiceObject
`222 PrintServiceObject
`
`260 Service Control Application
`
`Zfil Service Device Operating System
`
`zuz Network Communications Program
`
`218 Middleware
`
`216 Middleware Protocol Manager
`214 Application Control Protocol Manager
`
`I 212 GUI
`I
`210 Control Application
`
`220 Directory of Services
`
`2Q1 Control Device Operating System
`
`Software Download~
`
`~Nice Discove~ rrotocol~
`
`Control Commands
`
`APPL-1001 / Page 3 of 15
`
`

`

`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~
`/i Cootrol Soflwilre Dll'Mlload~
`
`APPL-1001 / Page 4 of 15
`
`

`

`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-1001 / Page 5 of 15
`
`

`

`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-1001 / Page 6 of 15
`
`

`

`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
`Email
`Service
`
`I Object Instance
`
`I
`
`Object Class
`
`FIG. 6
`
`APPL-1001 / Page 7 of 15
`
`

`

`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
`Service
`
`PowerPoint
`
`I
`Speech Recognition
`Service
`I
`
`I
`Via Voice
`
`I
`Naturally
`Speaking
`
`I
`Groupware
`Service
`I
`
`I
`Alta Vista
`Forum
`
`I
`Lotus
`Notes
`
`Email
`Service
`
`I
`Microsoft
`Mail
`
`Eudora
`Mail
`
`Netscape
`Mail
`
`I Object Instance
`I
`
`Object Class
`
`I
`I
`
`FIG. 7
`
`APPL-1001 / Page 8 of 15
`
`

`

`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-1001 / Page 9 of 15
`
`

`

`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-1001 / Page 10 of 15
`
`

`

`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-1001 / Page 11 of 15
`
`

`

`US 6,216,158 Bl
`
`7
`As explained in the software flow section, there are
`multiple ways to implement the application control protocol
`manager 214, the following illustrates one approach. The
`protocol takes the following form:
`
`Control Type
`
`Application
`
`File Name
`
`Control Function
`
`8
`
`Property/Method Name
`
`Type
`
`Description
`
`5
`
`PowerPoint
`
`Presentations
`
`Collection List of open presentations
`Presentation
`
`10
`
`15
`
`20
`
`25
`
`Slides
`Location
`
`View
`
`Title
`AddComments
`
`AddScribble
`
`Host
`
`FileName
`
`Collection Array of slides in presentation
`Storage
`Location where presentation loaded
`from
`Projector where presentation is
`viewed
`Slide
`
`Projector
`
`String
`Method
`
`Method
`
`Title for the slide
`Add given comments to slide at
`given coordinates
`Add given graphics to slide at
`given coordinates
`Storage
`
`String
`
`String
`
`LDAP Server host where the
`presentation stored
`File name and other details for
`presentation
`Projector
`
`Host
`ShowSlide
`
`String
`Method
`
`Projector host where slides shown
`Show slide image on projector
`
`LDAP Database Control
`
`The LDAP database control provides file system services
`to store and retrieve presentations. This control gets com(cid:173)
`mands from the PowerPoint control through the LDAP
`35 protocol, to search for presentations and return presenta-
`tions.
`
`An object class hierarchy for CLdapDB could include
`40 CLdapDb having to a specific storage system reference.
`
`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, .... }
`When the user clicks any button or draws something on
`the GUI, the application control protocol manager 214
`generates the corresponding field in the protocol and sends
`a command to the network based computer service 250 via
`a TCP/IP channel.
`H. Service Control Application Design
`FIG. 4 illustrates a detailed software architecture for the
`service control application of FIG. 3. The architecture
`includes three main elements: a CPU service 410
`(corresponding to the application service 130), a storage
`service 420 (corresponding to the storage service 150) and 30
`a projector service 430 (corresponding to the display service
`140). Each of the elements include middleware protocol
`layer management modules. Each module has a correspond(cid:173)
`ing service application control module (e.g., PowerPoint
`Control Protocol Manager). To control specific network
`services, instances of those services are instantiated and are
`used by the corresponding control protocol manager. The
`following describes examples of such classes that can be
`instantiated for specific network services.
`PowerPoint Control
`The PowerPoint control, through OLE automation,
`instantiates and controls an instance of PowerPoint applica(cid:173)
`tion. The PowerPoint control also communicates with the
`storage service 420 to store/retrieve presentations and the
`projector service 430 to view slides.
`The PowerPoint control has the ability to have many
`presentations open at the same time and is capable of
`switching between presentations. A presentation has a col- 50
`lection of slides in it. Once open, the PowerPoint control
`allows easy traversal of the slides either by commands like
`previous, next slide or by direct access (e.g. slide number or
`slide title). When any change in slide position occurs, the 55
`PowerPoint application automatically generates the image
`that needs to be shown by the projector control and invokes
`the method on the projector control to show the changed
`slide.
`Once a presentation is open, the PowerPoint control can 60
`have facilities such as Add Comments and Add Scribbled
`Graphics to the current slide. Additionally, it can allow the
`adding of new slides to the presentation.
`FIG. 5 illustrates an example object class hierarchy for the 65
`PowerPoint control class. The following describes the ele(cid:173)
`ments of FIG. 5 in more detail.
`
`45 Property/Method Name
`
`Storage
`
`Type
`
`Description
`
`FileFilter
`FileList
`
`String
`Collection
`
`File filter used to get file list
`List of files found on
`storage
`
`Projector Control
`
`The projector control provides image viewing services
`and has a simple image viewer that shows the image on a
`projection screen, monitor, display device or canvas. The
`control gets commands from the PowerPoint control.
`Specifically, to display images, the projector control could
`cause frames generated by the PowerPoint control to be
`displayed at the device controlled by the projector control.
`Other embodiments use more sophisticated techniques for
`displaying the PowerPoint information (