`
`
`
`11111111111111011111101011111111)111,110111111111171I1111111111111111111111111110111111
`
`(19) United States
`(12) Patent Application Publication (10) Pub. No.: US 2006/0200749 Al
`Sep. 7, 2006
`Shenfield
`(43) Pub. Date:
`
`(54) SYSTEM AND METHOD FOR CONVERSION
`OF GENERIC SERVICES' APPLICATIONS
`INTO COMPONENT BASED APPLICATIONS
`FOR DEVICES
`
`(76)
`
`Inventor: Michael Shenfield, Milton (CA)
`
`Correspondence Address:
`Gowling Lafleur Henderson LLP
`Suite 4900
`Commerce Court West
`Toronto, ON M5L 1J3 (CA)
`
`(21) Appl. No.:
`
`11/069,971
`
`(22) Filed:
`
`Mar. 3, 2005
`
`Publication Classification
`
`(51) Int. Cl.
`G06F 17/00
`G06F 15/00
`(52) U.S. Cl.
`
`(2006.01)
`(2006.01)
`
`(57)
`
`ABSTRACT
`
` 715/501.1
`
`A system and method for converting a page-based applica-
`tion to a component based application configured for execu-
`
`tion on a device, the device configured for communication
`over a network with a schema-defined service of a data
`source, the page-based application expressed as a series of
`presentation pages having embedded data and messaging
`elements for interaction with a user interface. The system
`and method comprise an analyzer module for assembling a
`set of page metadata representing at least a portion of a
`selected page from the series of pages of the page-based
`application, the page metadata expressed in a first structured
`definition language. Also included is a data conversion
`module for converting the embedded data elements into a
`data component, the data component containing data
`descriptors expressed in a selected structured definition
`language of the component based application. Also included
`is a message conversion module for converting the embed-
`ded messaging elements into a message component, the
`message component containing message descriptors
`expressed in the selected structured definition language of
`the component based application, the message component
`operatively coupled to the data component. Also included is
`a dependency module for generating a dependency link
`associated with an event corresponding to the embedded
`elements, the dependency link for describing a workflow of
`the components in respect to operation of the component
`based application when executed on a user interface of the
`device.
`
`select
`application
`
`704
`
`702
`
`assemble
`metadata 706
`
`scale page
`metadata 708
`
`translate
`metadata 710
`
`store
`definitions
`716
`
`create links
`714
`
`V
`
`generate
`Components
`712
`
`optimize
`components
`718
`
`generate
`workflow 720
`
`assemble
`components
`722
`
`request
`application
`726
`
`I
`
`send
`application
`724
`
`Exhibit 1007
`Page 01 of 27
`
`

`

`Patent Application Publication Sep. 7, 2006 Sheet 1 of 10
`
`US 2006/0200749 Al
`
`14
`
`coraral process
`
`tr:11
`
`126
`
`/12
`
`13
`
`100
`
`124
`
`Trrrrnrinn
`
`Web Application Converter
`
`ry
`
`retiese
`
`Component Analyzer
`
`store
`
`tie components
`
`120
`
`Workflow Builder
`
`download
`
`build application
`
`102
`
`XML Depot
`
`Bastion Builder
`
`105
`
`Admin User
`
`16
`
`e011V
`
`HTML Convener
`
`JSP Convener
`
`ASP Converter
`
`Page Analyzer
`
`retneve
`
`110
`
`128
`
`107
`
`Wcb Sever
`106
`
`deploy
`
`Publish 105
`C- 7 —)
`Application 112
`Repository
`
`
`105
`
`
`
`obil c Gatcvra
`
`WAN
`
`104
`
`106
`
`106
`
`122'
`
`114
`
`700
`
`Figure 1
`
`Exhibit 1007
`Page 02 of 27
`
`

`

`Patent Application Publication Sep. 7, 2006 Sheet 2 of 10
`
`US 2006/0200749 Al
`
`To wireless
`network
`102
`
`200 --
`
`Network
`Connection
`Interface
`
`202 —
`
`User
`Interface
`
`/ 222
`
`208
`
`210
`
`
`
` vovv
`
`212
`
`device infrastructure
`A
`
`220
`
`214
`
`302
`
`304
`
`/16
`component framework
`
`218
`
`204
`
`206
`
`300
`
`Figure 2
`
`Exhibit 1007
`Page 03 of 27
`
`

`

`Patent Application Publication Sep. 7, 2006 Sheet 3 of 10
`
`US 2006/0200749 Al
`
`204
`----16
`
`Device Infrastructure
`
`300
`1
`application container
`
`304
`1
`framework services
`
`302
`1
`component
`application
`
`I
`
`communication
`service
`
`screen service
`
`persistence
`service
`
`access service
`
`provisioning
`service
`
`utility service
`
`306
`
`308
`
`310
`
`312
`
`314
`
`316
`
`component framework
`
`Figure 3
`
`i
`206
`
`Exhibit 1007
`Page 04 of 27
`
`

`

`Patent Application Publication Sep. 7, 2006 Sheet 4 of 10
`
`US 2006/0200749 Al
`
`302
`
`206
`
`Data
`
`400
`
`214
`
`406
`
`Workflow
`
`404 AZ
`
`I
`
`,k
`
`Message
`
`402
`
`Presentation
`
`Figure 4
`
`Exhibit 1007
`Page 05 of 27
`
`

`

`Patent Application Publication Sep. 7, 2006 Sheet 5 of 10
`
`US 2006/0200749 Al
`
`02
`
`Script
`Interpreter
`
`interpre
`
`#3
`
`302
`
`00
`
`404
`
`Metadata
`
`402
`
`load
`#1
`
`2
`
`Client Runtime
`Environment
`
`406
`
`Script
`
`edirect
`
`#4
`
`/04
`
`Redirector
`
`Fill templates
`
`/ 500
`
`#5
`
`invoke
`
`invoke
`
`—506
`
`Native
`Runtime
`Engine
`
`Figure 4a
`
`Exhibit 1007
`Page 06 of 27
`
`

`

`Patent Application Publication Sep. 7, 2006 Sheet 6 of 10
`
`US 2006/0200749 Al
`
`700
`
`Metadata
`Repository
`403
`
`400
`
`404
`
`Int7M
`
`40
`
`e
`
`sr
`
`403b
`
`100
`
`105
`
`105
`
`105
`
`105
`
`E
`
`I
`
`I I
`
`403c
`
`Figure 4b
`
`Exhibit 1007
`Page 07 of 27
`
`

`

`Patent Application Publication Sep. 7, 2006 Sheet 7 of 10
`
`US 2006/0200749 Al
`
`To
`network
`104
`
`500 -
`
`Network
`Connection
`Interface
`______Ik
`
`502 —
`
`User
`Interface
`
`It
`/ 522
`
`518 --,,
`
`508
`
`510
`
`504
`
`i
`
`
`
` ....
`......._.21) ,.....„
`512
`
`device infrastructure
`
`
`
`520
`
`tool runtime environment 506
`
`1
`14
`
`Figure 5
`
`Exhibit 1007
`Page 08 of 27
`
`

`

`Patent Application Publication Sep. 7, 2006 Sheet 8 of 10
`
`US 2006/0200749 Al
`
`/
`
`tools 12
`
`converter tool
`
`126
`
`component
`storage
`114
`
`10
`
`--►
`
`workflow
`
`tool 124
`
`600
`
`606
`
`602
`
`604
`
`builder
`
`tool
`
`122
`
`Figure 6
`
`Exhibit 1007
`Page 09 of 27
`
`

`

`Patent Application Publication Sep. 7, 2006 Sheet 9 of 10
`
`US 2006/0200749 Al
`
`select
`application
`
`704
`
`assemble
`metadata 706
`
`store
`definitions
`716
`
`V
`optimize
`components
`718
`
` 0.1
`
`scale page
`metadata 708
`
`create links
`714
`
`702
`
`translate
`metadata 710
`
`V
`generate
`Components
`712
`
`generate
`workflow 720
`
`assemble
`components
`722
`
`request
`application
`726
`
`send
`application
`724
`
`Figure 7
`
`Exhibit 1007
`Page 10 of 27
`
`

`

`Patent Application Publication Sep. 7, 2006 Sheet 10 of 10
`
`US 2006/0200749 Al
`
`802
`
`202
`
`804
`
`800
`
`800
`
`800
`
`210
`
`Figure 8
`
`Exhibit 1007
`Page 11 of 27
`
`

`

`US 2006/0200749 Al
`
`Sep. 7, 2006
`
`1
`
`SYSTEM AND METHOD FOR CONVERSION OF
`GENERIC SERVICES' APPLICATIONS INTO
`COMPONENT BASED APPLICATIONS FOR
`DEVICES
`
`BACKGROUND
`
`[0001] This application relates generally to transformation
`of applications for communication of services over a net-
`work to a device.
`
`[0002] There is a continually increasing number of devices
`in use today, such as two-way devices, mobile telephones,
`PDAs with wireless communication capabilities, self service
`kiosks and two-way pagers. Software applications which run
`on these devices increase their utility. For example, a mobile
`phone may include an application which retrieves the
`weather for a range of cities, or a PDA may include an
`application that allows a user to shop for groceries. These
`software applications take advantage of the connectivity to
`a network in order to provide timely and useful services to
`users. However, due to the restricted resources of some
`devices, and the complexity of delivering large amounts of
`data to the devices, developing software applications for a
`variety of devices remains a difficult and time-consuming
`task.
`
`[0003] Currently, devices are configured to communicate
`with Web Services through Internet based Browsers and/or
`native applications. Browsers have the advantage of being
`adaptable to operate on a cross-platform basis for a variety
`of different devices, but have a disadvantage of requesting
`pages (screen definitions in HTML) from the Web Service,
`which hinders the persistence of data contained in the
`screens. A further disadvantage of Browsers is that the
`screens are rendered at runtime, which can be resource
`intensive. Native applications have the advantage of being
`developed specifically for the type of device platform,
`thereby providing a relatively optimized application pro-
`gram for each runtime environment. However, native appli-
`cations have disadvantages of not being platform indepen-
`dent,
`thereby necessitating the development multiple
`versions of the same application, as well as being relatively
`large in size, thereby taxing the memory resources of the
`device. Further, application developers need experience with
`programming languages such as Java and C++ to construct
`these hard coded native applications. There is a need for
`application programs, other than page-based applications,
`that can be run on client devices having a wide variety of
`runtime environments, as well as having a reduced con-
`sumption of device resources.
`
`[0004] The systems and methods disclosed herein provide
`a conversion capability to transform page-based applications
`to component based applications to obviate or mitigate at
`least some of the above presented disadvantages.
`
`SUMMARY
`
`[0005] Currently, devices are configured to communicate
`with Web Services and other data sources through Internet
`based Browsers and/or native applications. Browsers have
`the advantage of being adaptable to operate on a cross-
`platform basis for a variety of different devices, but have a
`disadvantage of requesting pages (screen definitions in
`HTML) from the Web Service, which hinders the persis-
`tence of data contained in the screens. A further disadvan-
`
`tage of Browsers is that the screens are rendered at runtime,
`which can be resource intensive. Native applications have
`the advantage of being developed specifically for the type of
`device platform, thereby providing a relatively optimized
`application program for each runtime environment. How-
`ever, native applications have disadvantages of not being
`platform independent, thereby necessitating the develop-
`ment multiple versions of the same application, as well as
`being relatively large in size, thereby taxing the memory
`resources of the device. There is a need for application
`programs, other than page-based applications, that can be
`run on client devices having a wide variety of runtime
`environments, as well as having a reduced consumption of
`device resources.
`
`[0006] Contrary to the current use of page-based applica-
`tions, there are disclosed systems and methods for providing
`a conversion capability to transform page-based applications
`to component based applications.
`
`[0007] Accordingly, a method is disclosed for converting
`a page-based application to a component based application
`configured for execution on a devices the device configured
`for communication over a network with a schema-defined
`service of a data source, the page-based application
`expressed as a series of presentation pages having embedded
`data and messaging elements for interaction with a user
`interface, the method comprising the steps of: assembling a
`set of page metadata representing at least a portion of a
`selected page from the series of pages of the page-based
`application, the page metadata expressed in a first structured
`definition language; converting the embedded data elements
`into a data component, the data component containing data
`descriptors expressed in a selected structured definition
`language of the component based application; converting the
`embedded messaging elements into a message component,
`the message component containing message descriptors
`expressed in the selected structured definition language of
`the component based application, the message component
`operatively coupled to the data component; and generating
`a dependency link associated with an event corresponding to
`the embedded elements, the dependency link for describing
`a workflow of the components in respect to operation of the
`component based application when executed on a user
`interface of the device.
`
`[0008] Also disclosed is a system for converting a page-
`based application to a component based application config-
`ured for execution on a device, the device configured for
`communication over a network with a schema-defined ser-
`vice of a data source, the page-based application expressed
`as a series of presentation pages having embedded data and
`messaging elements for interaction with a user interface, the
`system comprising: an analyzer module for assembling a set
`of page metadata representing at least a portion of a selected
`page from the series of pages of the page-based application,
`the page metadata expressed in a first structured definition
`language; a data conversion module for converting the
`embedded data elements into a data component, the data
`component containing data descriptors expressed in a
`selected structured definition language of the component
`based application; a message conversion module for con-
`verting the embedded messaging elements into a message
`component, the message component containing message
`descriptors expressed in the selected structured definition
`language of the component based application, the message
`
`Exhibit 1007
`Page 12 of 27
`
`

`

`US 2006/0200749 Al
`
`Sep. 7, 2006
`
`2
`
`component operatively coupled to the data component; and
`a dependency module for generating a dependency link
`associated with an event corresponding to the embedded
`elements, the dependency link for describing a workflow of
`the components in respect to operation of the component
`based application when executed on a user interface of the
`device.
`
`[0009] Also disclosed is a computer program product for
`converting a page-based application to a component based
`application configured for execution on a device, the device
`configured for communication over a network with a
`schema-defined service of a data source, the page-based
`application expressed as a series of presentation pages
`having embedded data and messaging elements for interac-
`tion with a user interface, the computer program product
`comprising: a computer readable medium; an analyzer mod-
`ule Stored on the computer readable medium for assembling
`a set of page metadata representing at least a portion of a
`selected page from the series of pages of the page-based
`application, the page metadata expressed in a first structured
`definition language; a data conversion module coupled to the
`analyzer module for converting the embedded data elements
`into a data component, the data component containing data
`descriptors expressed in a selected structured definition
`language of the component based application; a message
`conversion module coupled to the analyzer module for
`converting the embedded messaging elements into a mes-
`sage component, the message component containing mes-
`sage descriptors expressed in the selected structured defini-
`tion language of the component based application, the
`message component operatively coupled to the data com-
`ponent; and a dependency module coupled to the analyzer
`module for generating a dependency link associated with an
`event corresponding to the embedded elements, the depen-
`dency link for describing a workflow of the components in
`respect to operation of the component based application
`when executed on a user interface of the device.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`[0010] These and other features will become more appar-
`ent in the following detailed description in which reference
`is made to the appended drawings wherein:
`
`[0011] FIG. 1 is a block diagram of a network system with
`conversion tools;
`
`[0012] FIG. 2 is a block diagram of a generic device of
`FIG. 1;
`
`[0013] FIG. 3 is a block diagram of a runtime environ-
`ment of the device of FIG. 2;
`
`[0014] FIG. 4 is a block diagram of a component appli-
`cation of FIG. 2;
`
`[0015] FIG. 4a shows a representative application pack-
`aging and hosting model for the system of FIG. 1;
`
`[0016] FIG. 4b is a model of a client runtime of the device
`of FIG. 1;
`
`[0017] FIG. 5 is a block diagram of a computer for
`implementing the conversion tools of FIG. 1;
`
`[0018] FIG. 6 is an alternative embodiment of the tool of
`FIG. 1;
`
`[0019] FIG. 7 is an example operation of the tools of FIG.
`1; and
`
`[0020] FIG. 8 is an example of screen-data mappings for
`the applications of FIG. 4.
`
`DESCRIPTION
`
`[0021] Referring to FIG. 1, a network system 10 com-
`prises a plurality of generic devices 100 for interacting with
`one or more generic schema defined services provided by
`one or more data sources 106 (and associated data servers)
`via a coupled Wide Area Network (WAN) 104 such as but
`not limited to the Internet. These generic devices 100 can be
`wireless devices such as but not limited to two-way devices,
`mobile phones, PDAs, self-service kiosks and the like. The
`generic services provided by the data source 106 can be Web
`Services and/or other services such as but not limited to SQL
`Databases, IDL-based CORBA and RMI/IIOP systems,
`Legacy Databases, J2EE, SAP RFCs, and COM/DCOM
`components. It is recognized that each data source 106 can
`have an associated pre-compiled (e.g. executable) applica-
`tion 107, for downloading/uploading to the device 100,
`configured for executing on a specific device platform. The
`compiled application 107 is executed on the device 100 so
`as to establish a client-server relationship between the
`device 100 and the data source 106 respectively. Further, the
`system 10 has a gateway server 112 coupled to a wireless
`network 102 for connecting the devices 100 to the WAN
`104. It is recognized that other devices and computers (not
`shown) could be connected to the data sources 106 via the
`WAN 104 and associated networks other than as shown in
`FIG. 1. Web services are selected as an example data source
`106 for the following description of the system 10, for the
`sake of simplicity. However, it is recognized that other
`generic schema defined services could be substituted for the
`web services 106, if desired. Further, the networks 102, 104,
`of the system 10 will hereafter be referred to as the network
`104, for the sake of simplicity.
`
`[0022] Referring again to FIG. 1, a series of conversion
`tools 12 are used to convert the code (e.g. source code) of a
`compiled web application 107 into a series of descriptors
`using a selected structured definition language (e.g. XML).
`The page content of the application 107 have embedded data
`elements, embedded message elements and embedded pre-
`sentation elements. The application 107 is converted into a
`component application 105, as further described below. The
`tools 12 can be used to convert commonly used web
`applications 107 into XML-defined component applications
`105, organized as groups of XML descriptors in the form of
`a plurality of interactive components 400, 402, 404, 406 (see
`FIG. 4 as further described below). The conversion process
`of the tools 12 is based on structural code analysis of the
`original application 107 (e.g. web pages) of the web service
`106, and then on application of mapping patterns and
`associated conversion logic to convert these application 107
`pages into the set of structured language (e.g. A) defined
`components 400, 402, 404 augmented by scripting/com-
`mand language (e.g. Java Script) defined workflow compo-
`nents 406. The selected structured definition language and
`the selected scripting/command language are chosen or
`otherwise predefined for use by the tools 12 in expressing
`the descriptors and workflow of components 400, 402, 404,
`406 (see FIG. 4) that comprise the converted component
`application 105. It is noted that the selected structured
`
`Exhibit 1007
`Page 13 of 27
`
`

`

`US 2006/0200749 Al
`
`Sep. 7, 2006
`
`3
`
`definition language is hereafter referred to as XML for the
`sake of simplicity. Further, it is noted that the selected
`scripting/command language is hereafter referred to as Java
`Script for the sake of simplicity. However, it is recognized
`that other selected languages could be substituted for the
`XML and/or Java Script, if desired.
`
`Client-Server Interaction through Network Messaging
`[0023] Referring again to FIG. 1, the devices 100 transmit
`and receive requests/response messages, respectively, over
`the network 104 when in communication with the web
`services 106. The transmission and reception of the mes-
`sages is enabled through interaction with the component
`application 105 when first provisioned and then executed on
`the device 100. The devices 100 can operate as web clients
`of the web services 106 by using the requests/response
`messages are defined by the component application 105 in
`the form of message header information and associated data
`content, for example requesting and receiving product pric-
`ing and availability from an on-line merchant. It is recog-
`nized that the component application 105 is provided to the
`device 100 as a plurality of uncompiled components 400,
`402, 404, 406, each expressed in the selected XML and/or
`Java Script languages, for providing defined application data
`functions (i.e. data components 400), defined application
`message functions (i.e. message components 404), defined
`application presentation functions (i.e. presentation compo-
`nents 402) and defined application workflow functions (i.e.
`workflow components 406). The uncompiled component
`application 105 is received by the device 100 as the series of
`the interactively defined components 400, 402, 404, 406,
`which are subsequently provisioned in executable form on a
`device runtime 206 (see FIG. 2) to operate as the client
`application 105 for communication with the web service(s)
`through messaging, as further described below. The web
`service 106 is an example of a system with which compo-
`nent applications 105 interact via the network 104 in order
`to provide utility to users of the communication devices 100.
`The messages sent between the communication devices 100
`and the web service 106 could traverse a message-map
`service (not shown) of the server 112, which would convert
`the messages between any differing formats used by the
`devices 100 and the web services 106.
`
`[0024] For satisfying the appropriate requests/response
`messages, the web services 106 can communicate with the
`server 110 through various protocols (such as but not limited
`to HTTP and component API) for exposing relevant business
`logic (methods) of the web services 106 to the component
`application(s) 105 provisioned on the device 100. The
`provisioned component applications 105 can use the busi-
`ness logic of the web services 106 similarly to calling a
`method on an object (or a function). It is recognized that the
`component applications 105 can be downloaded/uploaded in
`relation to the server 112, through the messages via the
`network 104, directly to the devices 100. The web services
`106 provide information messages which are used by the
`component applications105 running on the devices 100.
`Alternatively, or in addition, the web services 106 may
`receive and use the information messages provided by the
`component applications 105, perform tasks on behalf of
`component applications 105, and/or enable asynchronous
`messaging for server 112 to device 100 notifications.
`[0025] The web service 106 can be defined as a software
`service, which can implement an interface such as expressed
`
`using Web Services Description Language (WSDL) regis-
`tered in a Universal Discovery Description and Integration
`(UDDI) services registry, and can communicate through
`messages with client devices 100 by being exposed over the
`network 104 through an appropriate protocol such as but not
`limited to the Simple Object Access Protocol (SOAP). In
`some implementations, SOAP is a specification that defines
`the XML format for the messages associated with the
`executing component application 105, including a well-
`formed XML fragment enclosed in SOAP elements. For
`example, the SOAP request message can contain a callable
`function, and the parameters to pass to the function, which
`is sent (according to the message and data format described
`in the components 400, 404 of the component application
`105) from the client device 100, and the service 106 then
`returns the response message (also according to the expected
`message and data format described in the components 400,
`404) with the results of the executed function. It is recog-
`nized that the messaging between the device 100 and web
`service 106 can include synchronous and/or asynchronous
`communication messages. Alternatively, the web service
`106 may use known communication protocols, message
`formats, and the interface may be expressed in web services
`languages other than described above.
`Device 100 and Runtime Environment 206
`[0026] Referring to FIG. 2, the devices 100 are devices
`such as but not limited to mobile telephones, PDAs, two-
`way pagers or dual-mode communication devices. The
`devices 100 include a network connection interface 200,
`such as a wireless transceiver or a wired network interface
`card or a modem, coupled via connection 218 to a device
`infrastructure 204. The connection interface 200 is connect-
`able during operation of the devices 100 to the network 104,
`such as to the wireless network 102 by wireless links (e.g.,
`RF, IR, etc.), which enables the devices 100 to communicate
`with each other and with external systems (such as the web
`service 106) via the network 104 and to coordinate the
`requests/response messages between the component appli-
`cations 105 and the service 106. The network 104 supports
`the transmission of data in the request/response messages
`between devices 100 and external systems (e.g. data sources
`106), which are connected to the network 104. The network
`104 may also support voice communication for telephone
`calls between the devices 100 and devices which are exter-
`nal to the network 104. A wireless data transmission protocol
`can be used by the wireless network 102, such as but not
`limited to DataTAC, GPRS or CDMA.
`[0027] Referring again to FIG. 2, the devices 100 also
`have a user interface 202, coupled to the device infrastruc-
`ture 204 by connection 222, to interact with a user (not
`shown). The user interface 202 includes one or more user
`input devices such as but not limited to a QWERTY key-
`board, a keypad, a trackwheel, a stylus, a mouse, a micro-
`phone and the user output device such as an LCD screen
`display and/or a speaker. If the screen is touch sensitive, then
`the display can also be used as the user input device as
`controlled by the device infrastructure 204. The user inter-
`face 202 is employed by the user of the device 100 to
`coordinate the requests/response message messages over the
`network 104 (see FIG. 1) as employed by component
`applications 105, further described below.
`[0028] Referring again to FIG. 2, operation of the device
`100 is enabled by the device infrastructure 204. The device
`
`Exhibit 1007
`Page 14 of 27
`
`

`

`US 2006/0200749 Al
`
`Sep. 7, 2006
`
`4
`
`infrastructure 204 includes the computer processor 208 and
`the associated memory module 210. The computer processor
`208 manipulates the operation of the network interface 200,
`the user interface 202 and the runtime environment 206 of
`the communication device 100 by executing related instruc-
`tions, which are provided by an operating system and
`component applications 105 located in the memory module
`210. Further, it is recognized that the device infrastructure
`204 can include a computer readable storage medium 212
`coupled to the processor 208 for providing instructions to
`the processor and/or to load/update client application pro-
`grams 302 in the memory module 210. The computer
`readable medium 212 can include hardware and/or software
`such as, by way of example only, magnetic disks, magnetic
`tape, optically readable medium such as CD/DVD ROMS,
`and memory cards. In each case, the computer readable
`medium 212 may take the form of a small disk, floppy
`diskette, cassette, hard disk drive, solid state memory cad, or
`RAM provided in the memory module 210. It should be
`noted that the above listed example computer readable
`mediums 212 can be used either alone or in combination.
`
`[0029] Referring again to FIG. 2, the component applica-
`tions 302 are transmitted via the network 104 and loaded
`into the memory module 210 of a device infrastructure 204
`of the device 100. Alternatively, the component applications
`105 may be loaded via a serial connection, a USB connec-
`tion, or a short-range wireless communication system such
`as IR, 802.11(x) BluetoothTM (not shown). Once loaded onto
`the device 100, the component applications 105 can be
`executed by a runtime environment 206 of the device 100,
`which provisions the component applications 105 into an
`executable form, which is then executed by the processor
`208 in the device infrastructure 204. For example, the
`component applications 105 may be executed as native code
`or interpreted by another software module or operating
`system on the device 100, as her described below with
`reference to FIG. 4b. In any event, the component applica-
`tions 105 are run in the terminal runtime environment 206
`provided by the device 100.
`
`[0030] Referring again to FIG. 1, the client runtime envi-
`ronment can be configured to make the devices 100 operate
`as web clients of the web services or any other generic
`schema-defined services supplied by the data sources 106.
`The client runtime environment 206 is preferably capable of
`generating, hosting and executing the component applica-
`tions 105 on the device 100. Therefore, the native runtime
`environment 206 is an interface to the device 100 function-
`ality of the processor 208 and associated operating system of
`the device infrastructure 204. Further, specific functions of
`the runtime environment 206 can include such as but not
`limited to support for language, coordinating memory allo-
`cation, networking, management of data during I/O opera-
`tions, coordinating graphics on an output device of the
`devices 100 and providing access to core object oriented
`classes and supporting files/libraries.
`
`[0031] The terminal runtime environment 206 can be
`referred to as a smart host container for the component
`application 105, and can be responsible for analyzing mes-
`sage meta-data (of the messages) and for updating the
`representation of the meta-data in the memory module 210.
`The terminal runtime environment 206 preferably supports
`
`the following basic functions for the resident executable
`versions of the component applications 105, functions such
`as but not limited to:
`
`[0032] provide a communications capability to send mes-
`sages to the Web Services 106 or messages to any other
`generic schema defined services connected via the network
`104 to the devices 100;
`
`[0033] provide data input capabilities by the user on an
`input device of the devices 100 to supply data parts for Web
`Services' 106 outgoing messages;
`
`[0034] provide data presentation or output capabilities for
`Web Services' 106 response messages (incoming messages)
`or uncorrelated notifications of the web service 106 on the
`output device;
`
`[0035] provide data storage services to maintain local
`client data in the memory module 210 (see FIG. 2) of the
`device 100; and
`
`[0036] provide an execution environment for the scripting
`language for coordinating operation of the application com-
`ponents 400, 402, 404, 406 (see FIG. 4) of the component
`applications 105.
`
`[0037] Referring to FIGS. 2, 4 and 4a, the client runtime
`environment 206 loads the raw metadata contained in the
`component 400, 402, 404, 406 definitions and the builds the
`executable version of the application program 302 on the
`device 100. For example, there can be two operational
`models/modes for client runtime: a template-based native
`execution mode and a metadata-based execution mode. With
`the template-based native execution model the runtime hosts
`data, message, and screen templates 500 pre-built on the
`device 100 using the native code. When the component
`application 105 definitions are loaded, the runtime environ-
`ment 206 fills the templates 500 with metadata-defined
`parameters from the components 400, 402, 404 and builds
`the executable component application 105 in the native
`format. The workflow script (for example Java Script) of the
`workflow component 406 could be either converted to native
`code or executed using an appropriate script interpreter 502
`to a native code redirector 504, where the redirector 504
`interprets calls to the scripting language into operations on
`native components through a native runtime engine 506.
`With the metadata-based execution, the runtime environ-
`ment 206 either keeps component 400, 402, 404, 406
`definitions in XML (for example), whi