(12) United States Patent
`Abdolbaghian et al.
`
`(10) Patent No.:
`(45) Date of Patent:
`
`US 6,981,048 B1
`Dec. 27, 2005
`
`USOO6981048B1
`
`(54) KEEP-ALIVE MESSAGING WHEN TWO
`APPLICATIONS ARE RUNNING
`
`(75) Inventors: Soheila Abdolbaghian, Irvine, CA
`S. Tuan Nguyen, Laguna Hills, CA
`
`(73) Assignee: Toshiba America Information
`Systems, Inc., Irvine, CA (US)
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 563 days.
`
`(*) Notice:
`
`(21) Appl. No.: 09/721,498
`(22) Filed:
`Nov. 22, 2000
`(Under 7 CFR 1.47)
`(51) Int. Cl." ............................................... G06F 15/16
`(52) U.S. Cl. ...................... 709,228.709,203. 709/223;
`709/227
`(58) Field of Search ................................ 704200 203,
`704/223-228, 231-232; 714/51, 55, 4
`s
`s
`s a as
`References Cited
`
`(56)
`
`U.S. PATENT DOCUMENTS
`6,006.259 A * 12/1999 Adelman et al. ........... 709/223
`
`2- -
`
`CCKCI C al. ........
`
`- - -
`
`8/2000 Dien ........................... 714/51
`6,112,320 A
`6,134,588 A * 10/2000 Guenthner et al. ......... 709/226
`6,434.612 B1* 8/2002 Hughes et al. .............. 709/223
`E. R. 12: E. al. .....
`- - - 22.
`6,567.852 B2 * 5/2003 Besaw et al. ............... 709/228
`* cited by examiner
`Primary Examiner-Bharat Barot
`(74) Attorney, Agent, or Firm-Pillsbury Winthrop Shaw
`Pittman LLP
`(57)
`
`ABSTRACT
`
`The present invention is generally directed to a System and
`method in which a second application (the "keep-alive
`function”) sends a ping, message or other signal to a first
`application to prevent the first application from being timed
`out (hereinafter, "keep-alive input"). In an embodiment of
`the invention, the first application is queried as to the
`appropriate content and format of a timeout period restart
`message. The keep-alive function may be automatically
`executed upon the occurrence of a triggering event. The
`keep-alive function may, periodically or based on a timeout
`clock related to the first application, check the Status of the
`first application and/or Send a keep-alive input.
`
`27 Claims, 4 Drawing Sheets
`
`
`
`Execute first
`Software
`application
`
`
`
`Second
`software
`application
`begun?
`
`Initiate
`keep-alive
`process
`
`201
`
`
`
`
`
`
`
`204
`
`Collect first
`application
`timeout function
`information
`
`
`
`
`
`Near first
`application
`timeout?
`
`
`
`
`
`Send keep-alive
`input
`
`Set/reset function
`timeout clock
`
`Application
`timeout
`clock reset?
`
`
`
`YeS
`
`N20s
`
`Page 1 of 10
`
`GOOGLE EXHIBIT 1007
`
`

`

`U.S. Patent
`
`Dec. 27, 2005
`
`Sheet 1 of 4
`
`US 6,981,048 B1
`
`
`
`:
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`:
`
`
`
`:
`
`3c
`
`Communication
`Network
`
`FIGURE 1
`
`Page 2 of 10
`
`

`

`U.S. Patent
`
`Dec. 27, 2005
`
`Sheet 2 of 4
`
`US 6,981,048 B1
`
`101
`
`102
`
`103
`
`Begin
`Software
`application
`
`
`
`Set/Reset
`Timeout
`Clock
`
`
`
`Continue
`Executing
`Application
`
`
`
`
`
`
`
`Keep-alive
`input
`received?
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`Timeout
`Clock >
`Timeout
`Period?
`
`
`
`
`
`105
`
`YeS
`
`
`
`Terminate
`application
`
`FIGURE 2
`
`Page 3 of 10
`
`

`

`U.S. Patent
`
`Dec. 27, 2005
`
`Sheet 3 of 4
`
`US 6,981,048 B1
`
`
`
`
`
`
`
`
`
`Execute first
`Software
`application
`
`201
`
`Second
`Software
`application
`begun?
`
`YeS
`
`
`
`Initiate
`k
`li
`eep-alive
`proceSS
`
`203
`
`
`
`202
`
`204
`
`Collect first
`application
`timeout function
`information
`
`
`
`206
`
`
`
`Near first
`NO application
`timeout?
`
`
`
`207
`
`
`
`
`
`
`
`
`
`Send keep-alive
`input
`
`205
`
`Set/reset function
`timeout clock
`
`Application
`timeout
`clock reset?
`
`YeS
`
`N20s
`
`FIGURE 3
`
`Page 4 of 10
`
`

`

`U.S. Patent
`
`Dec. 27, 2005
`
`Sheet 4 of 4
`
`US 6,981,048 B1
`
`Execute first
`software
`application
`
`
`
`
`
`301
`
`306
`
`
`
`
`
`
`
`Near first
`No application
`timeout?
`
`307
`
`
`
`YeS
`
`Second
`software
`application
`begun?
`
`YeS
`
`
`
`Initiate
`keep-alive
`proceSS
`
`303
`
`
`
`3O2
`
`304
`
`305
`
`
`
`Collect first
`application
`timeout function
`information
`
`Set/reset function
`timeout clock
`
`Check status of
`application
`
`
`
`Inform user
`of status
`
`Is application still
`alive?
`
`No
`
`309
`
`FIGURE 4
`
`Page 5 of 10
`
`

`

`US 6,981,048 B1
`
`1
`KEEP-ALIVE MESSAGING WHEN TWO
`APPLICATIONS ARE RUNNING
`
`BACKGROUND
`
`2
`the invention, the first application is queried as to the
`appropriate content and format of a timeout period restart
`message. The keep-alive function may be automatically
`executed upon the occurrence of a triggering event. The
`keep-alive function may, periodically or based on a timeout
`clock related to the first application, check the Status of the
`first application and/or Send a keep-alive input.
`FIG. 1 depicts an embodiment of the System according to
`the present invention. User terminals 1a–1c (collectively,
`“user terminal 1') used by users 2a-2c (collectively, “user
`2) may be connected to a communication network 4 So that
`the user terminal 1 may send Signals, data, messages and the
`like to the connected computers 3a–3c (collectively, “con
`nected computer 3’) and receive the same from the con
`nected computer 3. Other terminals may also be connected
`to the communication network 4. The user terminal 1 may
`have an operating System(s) which can be used to execute
`Software applications. The user 2 may cause the user termi
`nal 1 to execute various Software applications, including for
`example, Web browser, word processor, spreadsheet, data
`base, hardware driver, electronic mail, compiler, Video or
`audio data player, customized Software, network resource
`management, or other applications. The operating System for
`the user terminal 1 may be different from the operating
`system for the connected computer 3. Note that although the
`phrase “terminal” is used to describe the user terminal 1, the
`user terminal 1 may include a computer processor that is
`independent of the connected computer 3, allowing local
`execution of applications or portions thereof. The user
`terminal 1 may run applications either as desktop, fore
`ground or background processes. In particular embodiments
`of the invention, the user terminal 1 may be connected to
`other terminals or computers in a local area network (LAN)
`and may be connected to the communication network 4
`through a gateway or firewall.
`The communication network 4 may be a local area
`network (LAN), metropolitan area network (MAN), wide
`area network (WAN), the Internet or any other type of
`computer network and may use any network implementa
`tion, including, for example, the Ethernet, ARCnet, Token
`Ring implementations. Information communicated over the
`communication network 4 may conform to any data com
`munications protocol, including TCP/IP, IPX/SPX, NetBios
`and AppleTalk. The communication network 4 may include
`wire line (Such as twisted-pair telephone wire, coaxial cable,
`electric power line, optical fiber wire, leased line or the like)
`or wireless (Such as Satellite, cellular, radio frequency or the
`like) connections.
`In an embodiment of the invention, the user 2 may cause
`the connected computer 3 to execute a first Software appli
`cation using the user terminal 1 and may Subsequently cause
`the connected computer 3 to execute a Second Software
`application. One or Several copies of the Software applica
`tions may reside on the connected computer 3. Alternatively,
`a Software application may consist of discrete parts which
`are distributed between the connected computer 3 and the
`user terminal 1. Multiple copies of a particular Software
`application, portions thereof, or shared or dedicated
`resources used by the application may be in use by different
`users Simultaneously. The first Software application may
`include a function (the “timeout function”) whereby the
`application is terminated if the user 2 does not take Some
`action or the user terminal 1 does not transmit a Signal or
`message recognizable by the first application within a speci
`fied time period (the “timeout period”). This is a particularly
`useful feature when an application requires the use of shared
`memory, processor, data Source or other resources.
`
`In general, a computer executing an application may
`terminate the application unless the computer Senses a
`timeout period restart event, Such as a keystroke, a mouse
`button click, pointer motion, touch Screen activation, mes
`Sage receipt, ping Signal receipt, or a like input. Reasons for
`terminating applications based on the absence of a timeout
`period restart event include conservation of RAM cache and
`memory, power and other computer resources,
`In a communications network with a client/connected
`computer architecture, communication between a client and
`a connected computer occurs in Sessions, each of which is
`generally given a unique Session identifier (SID). Each
`Session may be associated with a unique client identifier or
`address (e.g., an Internet protocol address). During a Ses
`Sion, the connected computer may receive from the client
`multiple Service requests, each of which may relate to a
`number of applications. Applications, particularly those that
`utilize a large amount of connected computer or network
`resources (e.g., those that are memory-intensive), may have
`a timeout feature that terminates the application in a Session
`if an application event is not Sensed or a response to an
`information request is not received within a specified period
`of time.
`Where a Session includes multiple applications, a user
`operating on a client terminal may not respond to an
`information request or cause an application event because
`the application has been moved to the background of the
`client terminal and the user is actively working with a
`Second application in the client terminal foreground. It is
`often undesirable to have the first application timeout in
`Such situations.
`Moreover, Some applications prompt the user for a speci
`fied input prior to timing out the application. For example,
`applications that bill the user based on usage time often
`cause the client terminal to display a window asking the user
`if the user wants to maintain the application connection. The
`window may include an icon that may be activated to cause
`the terminal to Send the application a message Sufficient to
`avoid application timeout. Otherwise, application timeout
`proceeds as Scheduled.
`
`15
`
`25
`
`35
`
`40
`
`45
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`FIG. 1 depicts an embodiment of a communication net
`work according to the present invention;
`FIG. 2 is a flowchart illustrating the logical process that
`may be executed by a timeout function according to an
`embodiment of the present invention; and
`FIG. 3 is a flowchart illustrating the logical process that
`may be executed by a keep-alive proceSS according to an
`embodiment of the present invention.
`FIG. 4 is a flowchart illustrating the logical process that
`may be executed by a keep-alive process according to
`another embodiment of the present invention.
`
`DETAILED DESCRIPTION
`
`The present invention is generally directed to a System
`and method in which a second application (the “keep-alive
`function”) sends a ping, message or other signal to a first
`application to prevent the first application from being timed
`out (hereinafter, “keep-alive input'). In an embodiment of
`
`50
`
`55
`
`60
`
`65
`
`Page 6 of 10
`
`

`

`US 6,981,048 B1
`
`15
`
`25
`
`35
`
`40
`
`3
`In a particular embodiment of the invention, the con
`nected computer 3 may be a Server and the user terminal 1
`may establish a client-Server Session with the connected
`computer 3 by transmitting a Session request to the con
`nected computer 3. The connected computer 3 may establish
`a Session and return to the user terminal 1 a Session identifier.
`A first application, e.g., the downloading of content associ
`ated with a particular Web page from a specified Web site,
`may be executed by the connected computer 3 within this
`session. While the first session is still active, the user 2 may
`decide to open a Second application. The Second application
`may also reside on the connected computer 3, may be local
`to the user terminal 1 (e.g., a desktop application), or may be
`shared between the two. For example, the Second application
`may be the downloading of content associated with a Second
`Web page from a different specified Web site. The user
`terminal 1 may detect when the user 2 requests that the
`Second application be launched, for example, by detecting
`when the user activates a link embedded in a Web page,
`activates a Screen icon, enters an application execution
`command, accesses an executable computer file, or the like.
`In another example, the Second application may be a desktop
`application Such as a word processing, spreadsheet, or
`printer driver application. In an embodiment of the inven
`tion, the Second application may reside on a Second con
`nected computer that may communicate with the user ter
`minal 1 over the communication network 4.
`A timeout function associated with the first application
`may include performing the Steps shown in the flowchart in
`FIG. 2. Block 101 shows execution of the application being
`Started. This step may be performed by the application host,
`i.e., either the user terminal 1, the connected computer 3 or,
`for example, in the case of a distributed application, a
`combination of the two. At block 102, a timeout clock
`associated with the application may be set (where execution
`of the application is just beginning) or reset to an initial State
`to begin counting time. The timeout clock may count up, i.e.,
`Starting from an initial State of Zero and periodically incre
`menting until the timeout period value is reached, or count
`down, i.e., Starting from an initial State of the countdown
`period value and periodically decrementing until Zero is
`reached. As shown in block 103, the application proceeds
`with normal execution of the application. This may include
`receiving input by, for example, causing the host to poll an
`input device or devices associated with the host. Alterna
`tively, an input device or devices may create and transmit an
`interrupt signal when input is received. In an embodiment in
`which the application host is simultaneously executing mul
`tiple applications, the input may include a header identifying
`with which application the input is meant to be used.
`In block 104, the application determines whether the input
`it has received is of a type meant to prevent timeout of the
`application, i.e., a “keep-alive input'. The type of input
`necessary to keep the application alive may vary according
`to the application or may be selected by the user 2 or a
`System or network administrator. Possible keep-alive input
`may include Simple periodic pings or be limited to specific
`input data messages. If a keep-alive input is received, the
`application returns to block 102 and resets the timeout clock
`to its initial State.
`If a keep-alive input is not received, the application
`checks whether the timeout clock has exceeded a Specified
`timeout period. The timeout period may be set by default or
`Specified by the user 2, or a System or network administrator.
`If the timeout clock does not exceed the timeout period, the
`application returns to block 103 and continues to execute the
`application. However, if the timeout clock exceeds the
`
`45
`
`50
`
`55
`
`60
`
`65
`
`4
`timeout period value, the application terminates, as shown in
`block 106. In particular embodiments, termination block 106
`may include Steps for Sending the user 2 a warning message
`that the application is about to be timed out. In these
`embodiments, the user 2 may be allowed to Send a signal to
`the application requesting that the application not be timed
`out. In effect, in Such an embodiment, block 106 may
`include Sub-blocks similar to blocks 103, 104, and 105.
`FIG. 3 depicts a flowchart describing the operation of an
`embodiment of the present invention in which a keep-alive
`input may be sent to prevent timeout of the first application.
`According to this embodiment, there may be an applica
`tion (the "keep-alive function”) residing on a user terminal
`1 or a connected computer 3 which is initiated (as shown in
`block 203) if the user has caused a first application to be
`launched (as shown in block 201) and Subsequently, prior to
`termination of the first application, causes a Second appli
`cation to be launched (as shown in block 202). The keep
`alive function need not reside on the same user terminal 1 or
`connected computer 3 as either the first or Second applica
`tion. In an embodiment of the invention, the user 2 may be
`asked whether the keep-alive process should be initiated and
`the keep-alive may be initiated only if the user 2 responds
`affirmatively to this inquiry.
`In an embodiment of the invention, upon initiation, the
`keep-alive process may collect information about the tim
`eout function associated with the first Software application in
`block 204. This may be done by transmitting a request for
`Such information to the application host for the first appli
`cation, i.e., the connected computer 3. In a client-server
`Session-based embodiment of the invention, the request may
`include the session identifier. In embodiments of the inven
`tion, the user terminal may access information identifying
`particular environment variables or parameters associated
`with the timeout function (“timeout parameters”) for the first
`application and may include in the request the identity of the
`timeout parameters in the request. Alternatively, the request
`may be general and may be answered with information
`related to all environment variables and parameters. In Such
`an embodiment, the keep-alive function may Sort through
`the environment variable/parameter information to identify
`timeout parameters (if precisely known) or likely timeout
`parameters. Likely timeout parameters may include all
`parameters with the term “timeout' or some variation
`thereof in the parameter name. Likely timeout parameters
`may also be limited by the value type associated with the
`parameter.
`For example, in an embodiment of the invention, the
`parameter for the duration of the timeout clock may be
`Sought. However the precise name of the parameter associ
`ated with the duration of the timeout clock for the first
`application may not be known. The request transmitted to
`the connected computer 3 may yield a general response
`including all environment variables and/or parameters. From
`the returned environment variable/parameter information,
`the keep-alive function may identify only parameters with
`values that are numerical values as likely timeout param
`eters, Since the value of the parameter associated with the
`duration of the timeout clock is likely to be a numerical
`value (such as an integer number equivalent to the number
`of Seconds the timeout clock is Supposed to count). Where
`multiple likely timeout parameters are identified, the keep
`alive function may choose one or more parameters from the
`identified likely timeout parameters based on the values of
`the likely timeout parameters. For example, the first appli
`cation may have Separate environment variables/parameters
`asSociated with the application timeout clock, a message
`
`Page 7 of 10
`
`

`

`S
`acknowledgement receipt timeout clock, etc., all of which
`have the term “timeout' in their names and all of which have
`numerical values. In such a situation, the keep-alive function
`may conservatively select the likely timeout parameter hav
`ing the smallest value as the value to use in estimating when
`the first application will expire.
`In alternative embodiments, the user terminal 1 may
`access information precisely identifying the timeout param
`eter needed. In such a case, the request may specifically
`identify the timeout parameter Sought. Timeout parameter
`identification information may include lists of names for
`timeout parameters used by functions that the user terminal
`1 is capable of launching, timeout parameters commonly
`used in applications, and the like.
`Timeout function information sought by the keep-alive
`function may include the default, user-specified and/or Sys
`tem or network administrator-specified timeout period for
`the first application, a current application timeout clock
`value, and the type of keep-alive input that would cause the
`application timeout clock to be reset (for example, a speci
`fied input format or content). Based on this information, the
`keep-alive function may set its own function timeout clock
`(the “process clock”) to an initial state, as shown in block
`205. The function timeout clock may be synchronized with
`the application timeout clock. The value of the function
`timeout clock may be set so that the function timeout clock
`will expire before the application timeout clock expires. AS
`with the application timeout clock, the function timeout
`clock may be set to an initial State of Zero and be incre
`mented or the process clock may be set to an initial State
`equal to the timeout period value and be decremented.
`Alternatively, the keep-alive function may rely solely on the
`application timeout clock. However, this type of embodi
`ment may suffer from communication delays in Systems
`involving distributed applications and/or a long-distance or
`shared communication network 4.
`In some embodiments of the invention, the keep-alive
`process may not gather first application timeout function
`information. The keep-alive process may be prevented from
`collecting such information due to Security measures imple
`mented by the connected computer 3 or the amount or type
`of available information may be difficult to collect or pro
`cess. In these embodiments of the invention, the keep-alive
`function may set a function timeout clock to a duration
`known or believed to be shorter than the timeout process
`clock.
`In an embodiment of the invention, the keep-alive process
`may use collected timeout information related to keep-alive
`input type to create a customized or application-specific,
`keep-alive input. For example, if the first application is an
`application for downloading Web page content, the keep
`alive input may contain instructions to “refresh' the content.
`As shown by block 206 and 207, when the process clock
`nears the timeout period value if the clock is being incre
`mented or zero if the clock is being decremented, the
`keep-alive process transmits a keep-alive input to the first
`application. The keep-alive process may create the keep
`alive input based upon the application timeout information
`collected in the step shown in block 204. The process clock
`value at which a keep-alive input will be transmitted may be
`set by the process so as to compensate for Synchronization
`errors between the process clock and the application timeout
`clock.
`In embodiments of the invention in which the keep-alive
`process maintains an independent function timeout clock,
`the function timeout clock may be reset each time a keep
`alive input is transmitted to the application or, as shown in
`
`6
`block 208, only after it has been verified that the application
`timeout clock has been reset. In other words, Some embodi
`ments of the invention may omit block 208 and automati
`cally reset the function timeout clock upon transmission of
`the keep-alive input. In order to verify that the application
`timeout clock has been reset, the keep-alive function may
`send a request for timeout parameter information to the
`connected computer 3 as part of the keep-alive input or in a
`Separate transmission.
`FIG. 4 is a flowchart depicting the process that may be
`followed by an alternative embodiment of the invention.
`Unlike the embodiment depicted in FIG. 3, in this embodi
`ment of the invention, the keep-alive function does not cause
`a keep-alive input to be sent to the first application host.
`Instead, the keep-alive function checks the status of the first
`application, as shown in block 307, and informs the user of
`the status of the first application, as shown in block 308. The
`keep-alive function may check the status of the first appli
`cation by sending a status query message to the first appli
`cation host. In a client-server embodiment of the invention,
`the status query message may include a Session and/or
`application identifier. In block 309, the keep-alive function
`may then decide whether to reset the function timeout clock
`based on whether the first application is still alive. The
`frequency at which status query messages are sent to the first
`application host may be set So as to be shorter than the
`duration of the timeout clock for most applications or for all
`applications that the user terminal 1 may be capable of
`causing to launch. Status query messages may be transmit
`ted when the keep-alive function timeout clock has reached
`a specified state (e.g., a particular time value remaining).
`The keep-alive function timeout clock may be independent
`from a first application timeout clock that may be main
`tained by the first application host. In block 309, the keep
`alive function may decide whether to reset the keep-alive
`function timeout clock based upon the status of the appli
`cation, e.g., if the application is still alive. In alternative
`embodiments of the invention, if the application is found to
`have been terminated, the keep-alive function may terminate
`itself. In an embodiment of the invention, the status query
`message may include a request for first application timeout
`function information.
`While the description above refers to particular embodi
`ments of the present invention, it should be readily apparent
`to people of ordinary skill in the art that a number of
`modifications may be made without departing from the Spirit
`thereof. The accompanying claims are intended to cover
`such modifications as would fall within the true Spirit and
`scope of the invention. The presently disclosed embodi
`ments are, therefore, to be considered in all respects as
`illustrative and not restrictive, the Scope of the invention
`being indicated by the appended claims rather than the
`foregoing description. All changes that come within the
`meaning of and range of equivalency of the claims are
`intended to be embraced therein.
`
`What is claimed is:
`1. An application management System comprising:
`a first computer configured to host an application;
`a user terminal;
`a communication network, said first computer coupled to
`said user terminal through said communication net
`work;
`an computer-executable first application, wherein at least
`a portion of said first application is executed by Said
`first computer and at last a second portion of the first
`application being executed at said user terminal;
`
`US 6,981,048 B1
`
`15
`
`25
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`Page 8 of 10
`
`

`

`7
`a computer-executable Second application, wherein Said
`Second application is executed at Said user terminal;
`and
`a computer-executable keep-alive function, to collect first
`application timeout information related to Said first
`application to formulate a keep-alive input based on the
`collected first application timeout information; and to
`transmit said keep-alive input to Said first computer.
`2. The application management System according to claim
`1, wherein Said first computer is a Server, and Said user
`terminal establishes communication with Said Server by
`Sending Said Server a Session initiation request.
`3. The application management System according to claim
`1, wherein
`Said keep-alive input has a content and a format, and
`at least one of Said content and Said format is based on
`Said timeout information collected by Said keep-alive
`function.
`4. The application management System according to claim
`1, wherein Said first application timeout information
`includes information related to a timeout period.
`5. The application management System according to claim
`1, wherein:
`Said first computer maintains an application timeout
`clock, a timeout function terminating Said application
`when Said timeout clock reaches a specified State and
`Said application timeout clock being reset when Said
`first computer receives the keep-alive input, and
`Said timeout information includes information related to a
`current State of Said timeout clock.
`6. The application management System according to claim
`1, wherein Said keep-alive function maintains a keep-alive
`function timeout clock and Said keep-alive input is trans
`mitted to Said first computer when Said keep-alive function
`timeout clock reaches a Specified State.
`7. The application management System according to claim
`6, wherein:
`Said first computer maintains an application timeout
`clock, a timeout function terminating Said first appli
`cation when Said timeout clock reaches a Specified State
`and Said application timeout clock being reset when
`Said first computer receives the keep-alive input,
`Said timeout information includes information related to a
`current State of Said application timeout clock, and
`Said keep-alive function timeout clock is Set based on Said
`timeout information.
`8. An application management System according to claim
`7, wherein Said keep-alive function timeout clock is reset
`when the application timeout clock has been reset.
`9. An application management System according to claim
`7, wherein Said keep-alive function timeout clock is reset
`when the user performs an action to keep Said application
`alive.
`10. The application management System according to
`claim 1, wherein Said keep-alive function causes a query to
`be sent to a user Seeking authorization from Said user to
`transmit said keep-alive input to Said first computer.
`11. The application management System of claim 1,
`wherein the keep-alive function is housed on a computing
`device that is not the first computer or the user terminal.
`12. The application management System of claim 1,
`wherein the keep-alive function is housed on the user
`terminal.
`13. The application management System of claim 1,
`wherein at least a portion of the Second application is
`executed by Said first computer.
`
`15
`
`25
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`US 6,981,048 B1
`
`8
`14. The application management System of claim 1,
`wherein the keep-alive function transmits a keep-alive infor
`mation request to the first computer in order to collect the
`first application timeout information.
`15. The application management System of claim 1,
`wherein the first application is a downloading web page
`application and the keep-alive input transmitted to the first
`computer includes instructions to refresh the content of a
`Web page.
`16. The application management System of claim 1,
`wherein the keep-alive function transmits a keep-alive infor
`mation request to the user terminal in order to collect the first
`application timeout information.
`17. A method of managing a plurality of applications, Said
`method comprising:
`executing a first application, at least a portion of the first
`application being executed by a first computer and at
`least a Second portion of the first application being
`executed at a user terminal, the first computer and the
`user terminal being coupled via a network;
`executing a Second application at the user terminal;
`collecting, by a keep-alive function, first application tim
`eout information related to Said first application;
`formulating a keep-alive input based on the collected
`timeout information; and
`transmitting Said keep-alive input from Said user terminal
`to Said first computer.
`18. The method of managing an application according to
`claim 17, wherein said application timeout information
`includes information related to an application timeout clock
`maintained by Said first computer and related to Said first
`application.
`19. The method of managing an application according to
`claim 18, wherein Said keep-alive input is transmitted based
`on a State of Said application timeout clock.
`20. The method claim 18, further including, by said
`keep-alive function, maintaining a keep-alive function tim
`eout clock related to Said first application timeout clock, and
`wherein Said keep-alive input is transmitted based on a State
`of Said keep-alive function timeout clock.
`21. The method of claim 17, wherein said application
`timeout includes information related to a required content or
`a required format for Said keep-alive input, and Said keep
`alive input is formulated based on Said application timeout
`information.
`22. The method of claim 17, wherein said application
`timeout information includes information related to a
`required format for Said keep-alive input, and Said keep
`alive input is formulated base