(19) United States
`(12) Patent Application Publication (10) Pub. No.: US 2006/0129972 A1
`Tyburski et al.
`(43) Pub. Date:
`Jun. 15, 2006
`
`US 2006O129972A1
`
`(54) APPLICATION DEVELOPER AND METHOD
`FOR GENERATING PLATFORM
`INDEPENDENT CODE
`(76) Inventors: John Christopher Tyburski,
`Jonesboro, GA (US); Miguel A.
`Mendez, Roswell, GA (US); John
`Andrew Yeager, Atlanta, GA (US)
`ger,
`s
`Correspondence Address:
`THOMAS, KAYDEN, HORSTEMEYER &
`RISLEY, LLP
`100 GALLERIA PARKWAY, NW
`STE 1750
`ATLANTA, GA 30339-5948 (US)
`(21) Appl. No.:
`11/000,574
`
`(22) Filed:
`
`Nov. 30, 2004
`
`Publication Classification
`
`(51) Int. Cl.
`G06F 9/44
`
`(2006.01)
`
`(52) U.S. Cl. .............................................................. 717/106
`
`(57)
`
`ABSTRACT
`
`A method for developing platform independent applications
`comprises integrating an interface into a software develop
`ment platform, receiving an input indicative of a desired
`mobile-device type designated to receive an application
`responsive to the platform independent code, enabling a user
`to develop an instruction set via the interface, generating a
`set of platform independent files responsive to the mobile
`device type and the instruction set, forwarding the set of
`platform independent files to a device translator, and gen
`erating a device-specific application responsive to the
`mobile-device type and the platform independent files. A
`computing device exposes the functions of a software devel
`opment platform, generates a representation of a set of
`instructions designated for execution on a mobile device,
`and transforms the representation. The mobile device
`receives a device independent representation of an applica
`tion program designated for operation on the mobile device
`along with an application program.
`
`330 -
`
`
`
`SOFTWARE-
`DEVELOPMENT
`PLATFORM
`
`
`
`332
`
`
`
`
`
`FILE
`TRANSLATOR
`
`
`
`PLATFORM- 170
`NDEPENDENT
`FIES
`CODE FILE(S) 172
`RSP FILE
`174
`RPP FILE
`176
`REF. FILE
`1.78
`
`PALM DEV.
`TRANS.
`PALM
`LAUNCHER
`
`410
`
`415
`
`POCKET PC
`DEV. TRANS.
`POCKET PC
`LAUNCHER
`
`SYMBAN
`DEV. TRANS.
`
`LAUNCHER
`
`PACKAGER
`MODULE
`PALM OS COMP?
`DECOMP 432
`POCKETPC 434
`COMPIDECOMP
`
`SYMBIAN OS 438
`COMP/DECOMP
`
`DEVICE-SPECIFIC 180
`APPLICATION
`
`PLATFORM-IND. 190
`REPRESENTATION
`
`Page 1 of 15
`
`GOOGLE EXHIBIT 1011
`
`

`

`Patent Application Publication Jun. 15, 2006 Sheet 1 of 6
`
`US 2006/0129.972 A1
`
`
`
`
`
`ÕOŽ BOIAEC ETI@HOW
`
`
`
`
`
`Page 2 of 15
`
`

`

`Patent Application Publication Jun. 15, 2006 Sheet 2 of 6
`
`US 2006/0129.972 A1
`
`
`
`WITHICIEN
`
`@@@
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`?JOSSE OO}}d
`
`
`
`
`
`ÕG? BOV-IXJELNI TVOOT
`
`Page 3 of 15
`
`

`

`Patent Application Publication Jun. 15, 2006 Sheet 3 of 6
`
`US 2006/0129.972 A1
`
`
`
`|
`
`-,
`
`
`
`
`
`@55 EHOLS ETIH
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`Page 4 of 15
`
`

`

`Patent Application Publication Jun. 15, 2006 Sheet 4 of 6
`
`US 2006/0129.972 A1
`
`09 #7
`
`
`
`
`
`
`
`
`
`
`
`
`
`Page 5 of 15
`
`

`

`Patent Application Publication Jun. 15, 2006 Sheet 5 of 6
`
`US 2006/0129.972 A1
`
`START
`
`5OO
`//
`
`INTEGRATE AN INTERFACE INTO A SOFTWARE
`DEVELOPMENT PLATFORM
`
`
`
`504
`
`
`
`
`
`
`
`RECEIVE AN INPUT INDICATIVE OF
`A DEVELOPER DESRED MOBILE
`DEVICE TYPE DESIGNATED TO
`RECEIVE AN APPLICATION
`RESPONSIVE TO A PLATFORM
`INDEPENDENT CODE
`
`ENABLE AUSER OF THE SOFTWARE DEVELOPMENT
`PLATFORM TO DEVELOPAN INSTRUCTION SET VA
`THE INTERFACE
`
`
`
`GENERATE A SET OF PLATFORMINDEPENDENT
`FILES RESPONSIVE TO THE OFPERATOR INTERFACE
`AND THE INSTRUCTION SET
`
`506
`
`508
`
`FORWARD THE PLATFORMINDEPENDENT
`FILES TO A DEVICE-SPECIFIC TRANSLATOR
`CONFIGURED TO DENTIFY CONFIG.
`OPTIONS 8. NATIVE CODE
`
`FORWARD THE PLATFORMINDEPENDENT
`FILES, NATIVE CODE, DEVICE TYPE, AND
`CONFIG. OPTIONS TO APACKAGER
`CONFIGURED TO GENERATE A DEVICE
`SPECIFIC APPLICATION
`
`512
`
`51O
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`F.G. 5
`
`Page 6 of 15
`
`

`

`Patent Application Publication Jun. 15, 2006 Sheet 6 of 6
`
`US 2006/0129.972 A1
`
`START
`
`600
`//
`
`ADD A PLUG-IN THAT EXPOSES A SOFTWARE
`DEVELOPMENT PLATFORM TO A DEVELOPER
`
`604
`
`
`
`
`
`RECEIVE INDICARESPONSIVE TO
`A TARGET MOBILE DEVICE;
`OPERATING SYSTEM OPERATOR
`INTERFACE; MODE
`
`ENABLE AUSER OF THE SOFTWARE DEVELOPMENT
`PLATFORM TO DEVELOPAN INSTRUCTION SET VIA
`THE PLUG-N
`
`GENERATE A SET OF PLATFORMINDEPENDENT
`FILES RESPONSIVE TO THE INSTRUCTION SET, THE
`FILES INCLUDING ARESOURCE STRING FILE, A
`RESOURCE PROPERTYPOOL FILE, A REFERENCE
`FILE, AND A CODE FILE
`
`FORWARD THE PLATFORM
`INDEPENDENT FILES TO A
`DEVICE-SPECIFIC TRANSLATOR
`
`ASSOCIATE DATA RESPONSIVE TO THE PLATFORM
`INDEPENDENT FILES WITH A MOBILE-DEVICE
`SPECIFIC EXECUTABLE
`
`GENERATE A DEVICE-SPECIFIC APPLICATION
`RESPONSIVE TO THE MOBILE-DEVICE TYPE AND THE
`DATA RESPONSIVE TO THE PLATFORM
`INDEPENDENT FILES
`
`610
`
`
`
`
`
`
`
`
`
`606
`
`608
`
`612
`
`614
`
`
`
`616
`IDENTIFY ANOTHERMOBILE-DEVICE TYPE; FORWARD THE DATA
`RESPONSIVE TO THE PLATFORMINDEPENDENT FILES TO A
`SECOND DEVICE-SPECIFIC TRANSLATOR; USE THE SECOND
`DEVICE-SPECIFIC TRANSLATOR AND THE PACKAGER TO GENERATE
`A SECOND DEVICE-SPECIFIC APPLICATION
`
`CFD FIG. 6
`
`Page 7 of 15
`
`

`

`US 2006/0129.972 A1
`
`Jun. 15, 2006
`
`APPLICATION DEVELOPER AND METHOD FOR
`GENERATING PLATFORMINDEPENDENT CODE
`
`FIELD OF THE INVENTION
`0001. The present invention relates generally to an appli
`cation development tool. In particular, an application devel
`opment tool that can be integrated with a commercially
`available software development application that enables
`Software engineers to create mobile-device independent
`Software solutions.
`
`BACKGROUND
`0002 The need for mobile computing and network con
`nectivity is among the main driving forces behind the
`evolution of computing devices today. The desktop personal
`computer (PC) has been transformed into the portable note
`book computer. More recently, a variety of mobile handheld
`consumer electronic devices, including personal digital
`assistants (PDAs), cellular phones and intelligent pagers
`have acquired relatively significant computing ability. In
`addition, other types of mobile consumer devices, such as
`digital television set-top boxes, also have evolved greater
`computing capabilities. Network connectivity is quickly
`becoming an integral part of these consumer devices as they
`begin communicating with each other and traditional server
`computers via various data communication networks, such
`as a wired or wireless local area network (LAN), cellular,
`Bluetooth, 802.11b (Wi-Fi) wireless, and general packet
`radio service (GPRS) mobile telephone networks, etc.
`0003. The evolution of mobile computing devices has
`had a significant impact on the way people share information
`and is changing both personal and work environments.
`0004 Traditionally, since a PC was fixed on a desk and
`not readily movable, it was possible to work or process data
`only at places where a PC with appropriately configured
`software was found. Presently, the users of mobile comput
`ing devices can capitalize on the mobility of these devices to
`access and share information from remote locations at their
`convenience. A highly anticipated and powerful method for
`sharing information across a network of computers and
`mobile devices is via an interface for displaying dynamically
`generated content.
`0005. However, mobile devices pose several challenges
`for application developers.
`0006 For example, mobile devices typically have more
`limited hardware resources than conventional computers. In
`addition, mobile devices tend to have widely varying hard
`ware configurations, including differences in computation
`power, memory size, display capability, means for inputting
`data, etc. Mobile communication networks also experience
`limited network bandwidth and network availability. Con
`sequently, mobile devices may be intermittently connected
`or disconnected from a network.
`0007. Therefore, the first generation mobile devices typi
`cally were request-only devices or devices that could merely
`request services and information from more intelligent and
`resource rich server computers. The servers used standard
`Software architectures, such as the Java 2 enterprise edition
`(J2EE) platform. The server platforms could define and
`Support a programming model that allows thin-client appli
`cations to invoke logic instructions that execute on the
`SWCS.
`
`0008 Today, with the advent of more powerful comput
`ing platforms aimed at mobile computing devices, such as
`Pocket PC(R) and Java 2 platform, micro edition (J2ME),
`mobile devices have gained the ability to host and process
`information and to participate in more complex interactive
`transactions. Pocket PC(R) is the registered trademark of
`Thaddeus Computing, Inc., Fairfield, Iowa, U.S.A. Pocket
`PC is also a product name used by the Microsoft Corporation
`of Redmond, Wash., U.S.A. to describe mobile devices.
`However, today's more powerful computing platforms do
`not address problems for developing mobile-device appli
`cation Software caused by the widely varying operating
`systems, application interfaces, user input interfaces, data
`display types and sizes, memory sizes, etc. across many
`different mobile-device types.
`0009. Therefore, in the area of mobile application envi
`ronments for mobile devices there continues to be a need for
`a more robust application development environment that
`offers improved services to Support mobile application
`development.
`
`SUMMARY
`0010. An embodiment of a computing device includes a
`processor and a memory. The memory includes logic con
`figured to expose the functions of a software development
`platform to a user of the computing device responsive to an
`intermediate language source and configuration options
`associated with a mobile device remote from the computing
`device, generate a virtual machine instruction format repre
`sentation of a set of instructions designated for execution on
`the mobile device, transform the configuration options and
`virtual machine instruction format representation into a data
`portion and identify native code responsive to a mobile
`device type, and package the data portion and the native
`code to generate a mobile-device specific application.
`0011. An embodiment of a method for developing plat
`form independent code comprises integrating an interface
`into a Software development platform, receiving an input
`indicative of a first developer desired mobile-device type
`designated to receive an application responsive to the plat
`form independent code, the mobile-device type identifying
`an operator interface on the mobile device, enabling a user
`to develop an instruction set via the interface and the
`Software development platform, generating a set of platform
`independent files responsive to the mobile-device type and
`the instruction set, forwarding the set of platform indepen
`dent files to a device translator configured to identify con
`figuration options and native code responsive to the mobile
`device type to a first device-specific packager, and using the
`first device-specific packager to generate a device-specific
`application responsive to the mobile-device type and the
`platform independent files.
`BRIEF DESCRIPTION OF THE DRAWINGS
`0012 Embodiments of a computing device and methods
`for developing platform independent code are illustrated by
`way of example and not limited by the implementations
`depicted in the following drawings. The components in the
`drawings are not necessarily to Scale. Emphasis instead is
`placed upon clearly illustrating the principles of the present
`computing device and associated methods for developing
`platform independent code. Moreover, in the drawings, like
`reference numerals designate corresponding parts through
`out the several views.
`
`Page 8 of 15
`
`

`

`US 2006/0129.972 A1
`
`Jun. 15, 2006
`
`0013 FIG. 1 is a schematic diagram illustrating an
`embodiment of a software development environment.
`0014 FIG. 2 is a schematic diagram illustrating an
`embodiment of the mobile device of FIG. 1.
`0.015
`FIG. 3 is a functional block diagram illustrating an
`embodiment of the computing device of FIG. 1.
`0016 FIG. 4 is a functional block diagram illustrating an
`embodiment of Software components operable on the com
`puting device of FIG. 2.
`0017 FIG. 5 is a flow diagram illustrating an embodi
`ment of a method for developing platform independent code.
`0018 FIG. 6 is a flow diagram illustrating an alternative
`embodiment of a method for developing platform indepen
`dent code.
`
`DETAILED DESCRIPTION
`0019. The proliferation of mobile consumer electronic
`devices, including personal digital assistants (PDAs), cellu
`lar phones, media players, intelligent pagers, and the like,
`have created a need for specialized computing skills to
`produce device specific applications to operate and extend
`the usefulness of the devices. Mobile electronic devices
`employ a wide variety of operating systems, application
`interfaces, user-input interfaces, data display types and
`sizes, memory sizes, etc. The variety in device architectures,
`functions, and data transfer methods coupled with limited
`application storage capacity has created an ever-increasing
`number of device specific applications across many different
`mobile-device types.
`0020. The present computing device and methods for
`developing platform independent code leverage the capa
`bilities of a commercially-available software development
`platform and the skills of software developers familiar with
`its use to produce a device independent representation of an
`application targeted for operation on mobile-device plat
`forms. A computing device configured with plug-in, file
`translator, device translator, and packaging modules gener
`ates mobile-device specific application programs. The plug
`in cooperates with the software development platform to
`expose the various functions and features of the software
`development platform to Software engineers.
`0021. A software engineer uses the combination of the
`Software development platform and the plug-in to generate
`an instruction set (i.e., a program) that the engineer desires
`to execute on one or more mobile devices. The mobile
`devices may employ vastly different operating systems, user
`interfaces, and memory management techniques. The plug
`in receives configuration options specific to the user inter
`face of a select mobile device from a device translator
`module configured for the select mobile device. The plug-in,
`in combination with the software development platform
`presents the various configuration options to the engineer.
`The Software engineer enters a series of instructions corre
`sponding to the desired application to be executed on the
`mobile device. Once the instruction set has been completed,
`the software engineer directs the combination of the soft
`ware development platform and the plug-in to forward the
`instruction set to the file translator. The file translator
`converts the instruction set into an intermediate representa
`tion of the instruction set that comprises a set of platform
`
`independent files. The platform independent files include
`resource string pool, resource property pool, reference, and
`code files.
`0022. The platform independent files are controllably
`directed to one or more device translators. The device
`translators work with a packager module to produce a
`combination including a device-specific application and
`platform independent data.
`0023. Each device translator is configured to verify the
`platform independent files as they are received and forward
`the configuration options used in developing the instruction
`set to the packager module. The device translator also
`forwards a link to a mobile-device specific launcher (i.e.,
`stub code) to the packager module. The mobile device
`specific launcher is native code configured to make the
`device-specific application look like an application to the
`mobile device. The launcher is configured with the platform
`independent data and works with a pre-installed client on a
`mobile device. When executed on the mobile device, the
`launcher instructs the device how to execute the application
`code packaged in the platform independent files.
`0024. Each device translator includes a link to or a copy
`of a native language launcher.
`0025 For example, if the instruction set is designated for
`an application on a Palms brand device, the platform inde
`pendent files are forwarded to a device translator configured
`to generate Palms applications. The Palms device translator
`includes a link to a Palms) launcher. The launcher is
`programmed to find a proprietary run time environment
`configured to execute the code in the code file within the set
`of platform independent files.
`0026. An embodiment of a mobile device includes one or
`more mechanisms for receiving device specific application
`programs from the computing device. The mobile-device
`application transfer mechanism can include a wired or
`wireless communication link. Any of a number of commu
`nication protocols can be used to communicatively couple a
`particular mobile device with the computing device or
`network coupled communication devices. In some imple
`mentations, the mobile-device specific application is stored
`in a data store coupled to a wide area network that can be
`accessed, downloaded and installed by operators of the
`target mobile device. In other embodiments, the mobile
`device receives application programs and perhaps other data
`from portable media introduced to a media interface (e.g., a
`reader) coupled to the mobile device.
`0027. Once the package including the launcher, device
`specific application, and the platform independent data rep
`resentation are installed on a particular mobile device, the
`launcher can be executed. The launcher finds and loads a
`previously installed application client on the mobile device.
`The launcher then turns over the platform independent
`representation to the previously installed client. The client is
`a platform and run time that includes a virtual machine,
`components, libraries, etc. The client executes the applica
`tion in accordance with virtual machine code from the one
`or more code files produced by the file translator.
`0028 Reference will now be made in detail to the
`description of example embodiments of the systems and
`methods for generating platform independent code as illus
`trated in the drawings. FIG. 1 is a schematic diagram
`
`Page 9 of 15
`
`

`

`US 2006/0129.972 A1
`
`Jun. 15, 2006
`
`illustrating an embodiment of a software development envi
`ronment 100. In the example, computing device 110 is a
`desktop computer or personal computer. Computing device
`110 is associated with monitor 115, keyboard 112 and mouse
`113.
`0029. As illustrated in FIG. 1, computing device 110
`operates in accordance with inputs 150 entered by a software
`developer (not shown). Inputs 150 include one or more
`indicators that identify a mobile-device type 152, operating
`system 154, operator interface 158, and mode 153. Mobile
`device types define multi-mode multi-function PDAs, cel
`lular phones, pagers, media players, and other remote
`devices. Operating systems include those systems that direct
`the operation of one or more functions on mobile devices
`such as but not limited to Palm OSR), Pocket PCR, Sym
`bian(R) OS, etc. Palm OSR) is a registered trademark of Palm
`Computing, Inc. of Mountain View, Calif., U.S.A. Sym
`bian(R) is a U.S. registered trademark of Symbian Ltd., of
`London, United Kingdom. An operator interface is defined
`by the combination of elements that receive user inputs and
`provide information to a user of a particular mobile device.
`Note that in some cases identification of a mobile-device
`type may include an identification of an associated operator
`interface and operating system that are implemented on the
`mobile device.
`0030. At least two modes are envisioned. A software
`developer selects a mode via mode input 153. In a first
`mode, a Software developer enters instructions directed to
`perform a common data handling process Such as generating
`a mathematical combination of two or more numbers rep
`resented in storage registers. Under this first mode, the
`software developer instructs the software development plat
`form how to perform the associated function. In a second
`operating mode, a software developer enters instructions
`that generically describe an input/output operation as
`reflected on a display device. For example, the software
`developer may wish to describe one or more pushbuttons or
`touch sensitive portions of an entry display that correspond
`to respective alphanumeric characters, mathematical opera
`tors, or other designated functions. A Software developer
`working in this second operational mode will be generating
`instructions in accordance with the input/output interfaces
`available on a designated mobile device.
`0031. Instruction set 155 is a first abstraction of an
`application program that is intended to be executed on a
`designated mobile device 200. A software developer using
`keyboard 112 and mouse 113, and perhaps other input
`devices (not shown) associated with computing device 110.
`enters the individual instructions that comprise the instruc
`tion set 155. A representation of the entered instructions
`forming the instruction set 155, the instruction set 155, or
`both may be rendered and displayed to provide real-time
`feedback to the developer. Once the software developer is
`satisfied with the entered instruction set 155, the developer
`directs computing device 110 to generate a device-specific
`application 180 and a platform independent representation
`of the instruction set 190. As illustrated in FIG. 1, comput
`ing device 110 generates an intermediate abstraction of the
`instruction set in platform independent files 170. Platform
`independent files 170 include one or more code files 172, a
`resource string pool (RSP) file 174, a resource property pool
`(RPP) file 176, and a reference file 178.
`
`0032) RSP file 174 includes each of the label strings
`associated with various elements on a mobile-device inter
`face. RPP file 176 includes a description of various func
`tional elements such as a pushbutton or a portion of a touch
`sensitive interface. Descriptors include size, color, shape,
`operation(s), etc. associated with each functional element
`described by the developer. Reference file 178 includes any
`desired functional modules that are not part of a standard
`mobile-device run time environment. For example, a func
`tional module that interprets a bar code is generally not part
`of the standard run time environment on a mobile device.
`Such a module resident on computing device 110 can be
`identified by reference file 178. Code files 172 include
`instructions for directing a virtual machine on mobile device
`200. As described above, a target mobile device will be
`configured with an independent application (i.e., a client)
`that includes a virtual machine and a runtime.
`0033 Computing device 110 uses the intermediate
`abstraction of the instruction set 155 in the platform inde
`pendent files 170 and generates device-specific application
`180 and platform independent representation 190. Device
`specific application 180 is communicated to a respective
`mobile device 200 for subsequent execution on the device.
`Platform independent representation 190 is a data file that
`includes information extracted from the platform indepen
`dent files 170. Platform independent representation 190,
`which may be stored separate from device-specific applica
`tion 180 can be used by the combination of a device specific
`translator and a packager module (not shown) within com
`puting device 110 to generate a second device-specific
`application intended for a different mobile device without
`generating an additional instruction set 155.
`0034 FIG. 2 is a schematic diagram illustrating an
`embodiment of the mobile device 200 of FIG. 1. Mobile
`device 200 includes a processor 210, memory 220, user
`input/output interface(s) 260, communication interface 270,
`and media interface 280 that are communicatively coupled
`via local interface 250. Local interface 250 can be, for
`example but not limited to, one or more buses or other wired
`or wireless connections, known or later developed. Local
`interface 250 may have additional elements, which are
`omitted for simplicity. Such as controllers, buffers (caches),
`drivers, repeaters, and receivers, to enable communications.
`Further, local interface 250 may include address, control,
`and/or data connections to enable appropriate communica
`tions among the aforementioned components of mobile
`device 200.
`0035) In the embodiment of FIG. 2, the processor 210 is
`a hardware device for executing software stored in memory
`220. Processor 210 can be any custom-made or commer
`cially available processor, a central-processing unit (CPU)
`or an auxiliary processor among several processors associ
`ated with mobile device 200, and a semiconductor-based
`microprocessor (in the form of a microchip). In other
`embodiments, processor 210 can be an application specific
`integrated circuit (ASIC) or a field programmable gate array
`(FPGA) configured to execute various logic in accordance
`with one or more operator inputs entered via user input/
`output interfaces 260 and data within memory 220.
`0036 Memory 220 can include any one or a combination
`of volatile memory elements (e.g., random-access memory
`(RAM), such as dynamic-RAM or DRAM, static-RAM or
`
`Page 10 of 15
`
`

`

`US 2006/0129.972 A1
`
`Jun. 15, 2006
`
`SRAM, etc.) and nonvolatile-memory elements (e.g., read
`only memory (ROM), erasable programmable read-only
`memory (EPROM), electrically erasable programmable
`read-only memory (EEPROM), etc.). Moreover, memory
`220 may incorporate electronic, magnetic, optical, and/or
`other types of storage media now known or later developed.
`Note that the memory 220 can have a distributed architec
`ture, where various components are situated remote from
`one another, but accessible by processor 210.
`0037. The software in memory 220 may include one or
`more separate programs, each of which comprises an
`ordered listing of executable instructions for implementing
`logical functions. In the example of FIG. 2, memory 220
`includes an application store 224 and a data store 226.
`Application store 224 stores application programs Suited for
`execution on mobile device 200. Application store 224
`includes device-specific application 180 generated by the
`above described application developer and a separate client
`application 230. Device-specific application 180 includes
`launcher 225. Launcher 225, as described above, is native
`code to the operating system 222 on mobile device 200.
`Client application 230 is located and accessed by launcher
`225. Client application 230 includes a virtual machine and
`run time operable on mobile device 200. Launcher 225
`forwards the instruction codes and platform-independent
`representation 190 that direct client 230 how to execute the
`device-specific application on mobile device 200. Applica
`tion store 224 may further include one or more commer
`cially available applications as well as proprietary applica
`tions (not shown). Data store 226 includes a platform
`independent data representation 190 that reflects an instruc
`tion set entered by an operator of the computing device 110
`(FIG. 1) and the platform independent files 170 generated
`by the computing device 110. In an alternative embodiment,
`platform independent data representation 190 may be pack
`aged with the device-specific application in the application
`store 224.
`0038 Memory 220 further includes operating system
`222. Operating system 222 controls the execution of appli
`cations, such as device-specific application 180 and provides
`scheduling, input-output control, memory management, and
`communication control and related services.
`0039. User input/output interface(s) 260 enable an opera
`tor of the mobile device to enable one or more functions,
`input data, and receive results in accordance with the spe
`cifics of the device interfaces and the underlying applica
`tions including device-specific application 180. User input/
`output interfaces 260 include, but are not limited to, a
`touch-sensitive screen, one or more graphical displays Such
`as a liquid crystal display (LCD), a plasma display, or other
`display types now known or later developed.
`0040. A graphical interface, when implemented with the
`mobile device, operates in association with multi-function
`pushbuttons, one or more Switches associated with specified
`device functions, other interactive-pointing devices, voice
`activated interfaces, or other operator-machine interfaces
`(omitted for simplicity of illustration) now known or later
`developed. Note that each mobile-device type may not
`include each of the aforementioned interfaces.
`0041 Communication interface 270 can include an infra
`red (IR) sensitive transceiver, a radio-frequency (RF) trans
`ceiver, a serial port, a parallel port, etc. for communicatively
`
`coupling mobile device 200 to external devices. Communi
`cation interface 270 can be selectively in communication
`with processor 210 and/or memory 220 via local interface
`250. A variety of wireless communications interfaces and
`data transfer protocols support the communication of infor
`mation both to and from mobile devices such as PDAs,
`pagers, cellular phones, etc. to an appropriately configured
`Source or destination device, respectively. For example,
`infrared data association protocol (IrDA), wireless fidelity
`(IEEE 802.11b wireless networking) or Wi-Fi, Bluetooth R),
`etc. each support wireless data transfers. BluetoothR) is the
`registered trademark of Bluetooth SIG, Inc.
`0042 Media interface 280 is also selectively in commu
`nication with processor 210 and memory 220 to receive both
`data and one or more application programs including device
`specific application 180. As illustrated in FIG. 2, media
`interface 280 is configured to receive one or more portable
`data storage media such as medium 285. It should be
`understood that various I/O device(s) in addition to those
`described above may also be integrated via local interface
`250 and/or other interfaces (not shown).
`0043. When the mobile device 200 is in operation, pro
`cessor 210 is configured to execute software stored within
`the memory 220, to communicate data to and from the
`memory 220, and to generally control operation of the
`mobile device 200 pursuant to the software. The operating
`system 222 and applications, in whole or in part, but
`typically the latter, are read by the processor 210, perhaps
`buffered within the processor 210, and then executed.
`0044 FIG. 3 is a functional block diagram illustrating an
`embodiment of the computing device 110 of FIG. 1. Com
`puting device 110 includes a processor 310, memory 320,
`user input/output interface(s) 360, communication interface
`370, and media interface 380 that are communicatively
`coupled via local interface 350. Local interface 350 can be,
`for example but not limited to, one or more buses or other
`wired or wireless connections, known or later developed.
`Local interface 350 may have additional elements, which are
`omitted for simplicity. Such as controllers, buffers (caches),
`drivers, repeaters, and receivers, to enable communications.
`Further, local interface 350 may include address, control,
`and/or data connections to enable appropriate communica
`tions among the aforementioned components of computing
`device 110.
`0045. In the embodiment of FIG. 3, the processor 310 is
`a hardware device for executing software stored in memory
`320. Processor 310 can be any custom-made or commer
`cially available processor, a central-processing unit (CPU)
`or an auxiliary processor among several processors associ
`ated with computing device 110, and a semiconductor-based
`microprocessor (in the form of a microchip).
`0046) The memory 320 can include any one or combi
`nation of volatile memory elements (e.g., RAM, DRAM,
`SRAM, etc.) and nonvolatile-memory elements (e.g., ROM,
`EPROM, EEPROM, etc.). Moreover, the memory 320 may
`incorporate other types of storage media now known or later
`developed Such as floppy-disk drives, hard-disk drives,
`portable media drives, a redundant array of inexpensive
`disks (RAID) device, etc. Note that the memory 320 can
`have a distributed architecture, where various components
`are situated remote from one another, but accessible by
`processor 310.
`
`Page 11 of 15
`
`

`

`US 2006/0129.972 A1
`
`Jun. 15, 2006
`
`00