JP2002524788A - System and method for exchanging information about a target customer application - Google Patents

Abstract

(57) [Abstract] A method of exchanging information about one or more target customer applications between a computer platform having an operating system on which the target customer applications run and a remote server. Disposing at least one of the passed message, the function called between the target customer application and the operating system, and the second processing for further processing from the target customer processing. And asynchronously announcing the selected action in a message, and in response to the announcing, transferring information regarding the target customer application to or from the second process.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

TECHNICAL FIELD OF THE INVENTION

 The present invention relates to monitoring and expanding computer programs.

[0002]

[Prior art]

In the past, computer programs usually did not change. That is, once the user learns the computer program, the use of the program is followed by a command / response, command / response pattern, and the program will probably do what it expects the user to do. I did things, but nothing more. More recently, there has been a need to make computer programs more dynamic, more usable and more fun.

Various mechanisms are known for monitoring and enhancing computer programs. U.S. Pat. No. 5,432,940, incorporated herein by reference, describes a computer-based training (CBT) system that allows interaction between a user and a target application. The system monitors various events of the desired target application. Messages from these events will be represented as CBT messages by the Message Engine
) Is entered and reported. This message engine sends messages quickly according to a handler described by a script engine that operates under the control of the script. A CBT script is structured as a sequence of scenes, each scene describing an action that occurs at a specific point in a lesson. For example, the scene instructs the CBT system to display a window containing some text when a particular menu item is selected in the target application. As the lesson script progresses, new scenes are created. This process is performed when the user
Choose to leave the system or continue until the lesson is over.

[0004] International Patent Application WO 97/07656, also incorporated herein by reference, discloses that advertisements and other information from a computer network database are selected based on user-defined preferences, and that the selected advertisements are selected. Transmit in the background mode on the communication link between the computer network and the terminal computer, with minimal disruption by other processes communicating on the communication link, and place the selected advertisement on the user's computer. A display system is described. The system monitors user interaction with the advertisement and produces raw data of how many times a particular advertisement has been accessed, as well as the user's response to the advertisement. Relevant information is stored and sent back to a network server made available to the advertiser. Other types of information content can also be transmitted, such as news, weather, stock quotes, sports results, software updates, travel booking information, and the like.

[0005]

[Problems to be solved by the invention]

However, these systems are, in fact, intrusive and have a significant effect on system performance.

[0006]

[Means for Solving the Problems]

The present invention broadly provides a transparent software monitoring / advisory mechanism that can intelligently interact with the software user. A software agent installed on the user's machine creates a hook to be embedded in the target customer application. The message for the user to pick a feature is hooked into the target customer application,
It is sent to the hook monitoring process including the multiple threads including the receiving thread (thread) and the first thread. The receiving thread receives the hooked messages and "reflects the asynchronous message" to these messages to the first thread. The first thread catalogs the message and updates the feature usage count based on the message for future upload to the server. The first thread also determines whether a particular message has an associated report, such as an advertisement or survey. If so, the first thread calls a helper process to distribute the report. Software agents communicate with remote servers at intervals using "virtual connections", ie, Internet connections that are transparent to the user. In the downlink direction, the server sends an agent command file that regulates agent behavior. The agent recovers from the server resources required to execute the instructions, such as advertisements, surveys, and software updates, contained in the instructions file. In the uplink direction, selected information, such as usage count information, is uploaded to the server according to the command file. “
The "virtual" Internet connection may be a LAN connection or a dial-up connection.
Be careful not to inadvertently cause dial-out for dial-up connections. The forwarding mechanism minimizes the resource utilization and impact of the first contact using the connection.

[0007]

BEST MODE FOR CARRYING OUT THE INVENTION

 The invention will be better understood from the following description, taken in conjunction with the accompanying drawings. FIG. 1 is a general block diagram of the present invention. FIG. 2 is a diagram of a screen display of agent activation. FIG. 3 is a more detailed block diagram of the agent of FIG.

Referring now to FIG. 1, the general architecture of the present invention will be described. It includes the runtime environment provided by the operating system, web browser, and the like, and shall run one or more computer programs. Computer programs are software applications, system software, and embedded computer programs. System-specific exchange of software can be achieved by providing a permanent customer's user machine or an agent that communicates with the server in two-way communication. This agent is installed at the same time as the application, is pre-loaded on the user machine, and is installed separately from a disk or by downloading. The connection between the agent and the server is a virtual connection, that is, a connection that performs a time division between the physical communication channel and the target communication. In one example of the embodiment,
A virtual connection uses the extra bandwidth of an intermittent Internet connection to communicate with the server. Agents can, and usually do, interact with the application, rather than having a simultaneous Internet connection.

[0009] Communication between the agent and the server is optional. In one example of an embodiment, when an agent is first launched for a particular application,
A screen as shown in FIG. 2 is displayed to the user. In the example of FIG. 2, the screen display is a screen of “preferred customer enrollment”. By clicking on the appropriate button, the user can accept or decline the customer's desired program. If the customer receives, the customer enters into the resulting relationship with the software vendor and maintains personal information about the composition and use of the application to provide individual services. Agree to software vendor.

[0010] Communication between the agent and the server is also two-way. In the uplink direction, agents convey control, configuration and usage information, survey information, and the like. In the downlink direction, the server communicates non-executable content, executable content, or both, including control information, agent contacts, and the like. Non-executable content may include tips, offers, advertisements, surveys, and the like. Nevertheless, it should be noted that non-executable content can be active, that is, include an HTTP link that allows the user to "click through" to the relevant website. . Executable content may relate to an application and / or an agent. The executable computer associated with the application may include communications, bug fixes, additional code modules, and the like. The executable content associated with the agent allows the agent to transparently update new capabilities in the field, avoiding the potential problem of agent degradation.

Referring to FIG. 3, a detailed block diagram of the agent is shown.

In one embodiment, the agent follows a plug-in architecture. Thus, the agents include resident agents and various plug-ins that interface with the resident agents through a plug-in API. In an example of the embodiment, the plug-ins include an instruction processor plug-in, a message plug-in, a survey plug-in, an Inet plug-in that handles a virtual connection to the Internet, and a hook plug-in. Message plug-ins, survey plug-ins, and possibly other plug-ins can take action and take action within the customer interface (UI) of the customer application. Other plugins can be included in the agent or added to the agent by download. If a plug-in needs the help of another plug-in, the agent will pass the parameters transparently to the target agent. Permanent storage is provided to the plug-in, as well as the resident agent, for example, in a registered file system.

The modularity obtained from the architecture of the plug-in of the agent is:
This is important in terms of allowing the user to operate transparently. The core agents and plugins are all small modules (typically less than about 12 Kbytes) that can be easily downloaded. The time required to download a module is typically only a few seconds.

The core tasks of the agent include: 1. Manages communication between plugins and interplugins. 2. Download the content (instruction file) and determine the appropriate instruction interpreter to handle the instruction file. Restore the command interpreter plug-in from the server and call it in the download command file. 3. Maintain state (eg, current instruction file) so that the system does not fail or restart. Operating system registration can be used to permanently store status information, including configuration of plug-ins and events, and registered customer applications. 4. Monitor the system's Internet connection and schedule uploads and downloads. 5. Track the target application and determine its use. From this information and the instruction file data, the schedule action is performed as taken in the target user interface (UI) space through the plug-in interface. 6. Change the level and type of activity, including becoming inactive in response to the server.

An agent can interact with a software application from any point of view without modifying the application itself. In particular, a small hook (eg, a DLL) is inserted into the parent task of the display screen displayed on the user machine. Information identifying the target customer application is stored in a permanent storage location (e.g., operating system registration) that can access the hook. Each hook determines the executable name of the module and whether it is embedded in the target customer application by using an agent-maintained customer look-up table stored in the registration. . If embedded in the target customer application, the hook remains intact. If not, the hook requests that it be removed.

The hook determines if any relevant "feature selection" actions are taking place in the monitored application and, if so, passes this information to the hook's plug-in. In particular, the hook passes the message through the POST (POST) into the hook's plug-in message queue. The hook plug-in
It is designed not to degrade the performance of the user's system or the performance of the application. More specifically, in one example of an embodiment, the agent loads a plug-in of a hook that, when first started, initiates the execution of a separate receiving thread, Trx. This receiving thread is designed to be highly available for interacting with hooks in customer applications.
The use of a separate thread ensures that the processing of messages in the customer application is not significantly slowed down.

The agent only places one hook per running UI thread in the customer application and makes sure that only one hook is placed (but if multiple running threads are Note that a single customer application can have multiple hooks if it is among the customers). The placed hooks cannot call each other, and thus no functional method can occur.

[0018] The receiving thread receives the hooked messages and "reflects the asynchronous message" on these messages to the first thread Tpri. The first thread is
Inventory messages and update feature usage based on messages for future upload to server. The first thread also determines whether a particular message has a report associated with it, such as an advertisement or survey. if,
If so, the first thread calls a helper process (such as an advertising plugin or a survey plugin) to distribute the report.

The latency between detecting the user's activity and the advisory message being timed to follow the user immediately may convey the impression that the advisory content is indeed part of the application. To be minimized. In one example embodiment, the interaction can be loaded within about 50 milliseconds. This quick response is obtained by pre-loading the dialogue into the memory and by calling the operating system to display the selected dialogue when an appropriate event notification is received. .

An advisory dialog is “attached” to an already existing window by “laying down the window”. The advisory interaction is in a form such that the user's interest is removed from the customer's application until the user imposes some action on the interaction.

In addition to presenting the usage count and advisory messages maintained, the first thread can also track the user's actions as a function of time, for example, when the application starts and ends, How long the application has been interested in the user, or how long the user has actually been doing something. In one example of an embodiment, for the purpose of the latter measurement, if at least one event is received during a minute, the user is considered to have dynamically used the application during that time. .

The Inet plug-in is responsible for handling all Internet traffic. In one embodiment, registering an agent with a server, obtaining a user ID, restoring an instruction file using the user ID, uploading data to the server, and downloading resources from the server. Provides various types of internet processing, including: The data is, for example, HTT
It can be exchanged using POST and GET commands as in the P1.1 protocol. The Inet plug-in will fail properly if any process does not end via the Internet.

The instruction processor plug-in is responsible for translating the instruction file into actual operations. For example, the plug-in scans the instruction file, schedules the download of all resources required by the instruction file, expands macros, and creates new versions of the instruction file. Thereafter, the command file is processed and mixed with the existing command file, removing all completed events from the command file and scheduling all events and actions that the agent should take.
Finally, it marks the instruction file as running in permanent storage and uploads an instruction file status update that allows the server to track the execution of events in the customer application.

The agent's control panel applet allows the user's interaction with the agent to control the agent's future behavior, but typically the user has no opportunity to use the control panel. Would. As mentioned above,
The user may be given additional control beyond this initial decision. For example, the user can later choose to modify the extent of the interaction, the type or amount of information sent, or pull or abort all communication between the agent and the server. be able to. The user may wish to abort the downlink operation instead of continuing the uplink operation (e.g., an agent monitoring a traditional type of customer service). Alternatively, the user may wish to continue with a subset of uplink operations and limited downlink operations, eg, notification of an upgrade. Various other options are provided.

Instead of a control panel applet, a mechanism can be used that dynamically adds menu entries to the customer's menu bar, which mechanism allows the user to control agent functionality within the customer. be able to. Dynamically adding menu entries is accomplished in the following manner. 2. The agent knows that the customer adds a menu item to the customer menu bar. 2. When the user clicks on this menu, the agent will be notified of this event (through a hook) and the plug-in will be shown to control various agent features within the customer UI control.

In one example embodiment, the resident agent includes a scheduler / manager, a remote dial-up monitor, and a command file preprocessor. Resident agents also include customer maps, event maps, and plug-in maps. The resident agent is responsible for dynamically maintaining the configuration and state of running plug-ins, registered customer applications, and events running on the customer applications. The instruction queue contains the actual event information and is processed by the start of each agent. In one example of an embodiment, the agent is started by a machine start table in the operating system registry.

The scheduler / manager is responsible for establishing a periodic Internet connection with the server through the Inet plugin. If a connection becomes available, each customer object is given the bandwidth to service the customer's request. Next, all undetermined POST processes are processed. The scheduler / manager can be invoked either on a dial-up Internet access, in an event driven manner, or on a direct (or proxy) LAN-based Internet access, either at periodic intervals. For dial-up access, different dial-up access methods can be used depending on the software configuration of the user machine. The remote dial-up monitor determines which dial-up access method is used, and thus the establishment of an Internet connection is detected.

More specifically, in the case of a dial-up connection, the registration is read to identify the particular customer application used for dial-up. Thereafter, the agent hooks the application. By reading the registration, the hook determines that the purpose is to monitor dial-up, and thus only passes on messages about dial-up events. These messages are received by the remote dial-up monitor. When a normal dial-up event sequence is detected, the remote dial-up monitor starts counting. At the end of the counting period, if the dial-up application is still running, the remote dial-up monitor will schedule the connection.

In some examples, a remote dial-up monitor may trick and “think” that a connection is present when it is not. For example, dial-up may have been canceled and started. Because the agent relies on periodically examining the server, something similar to an existing connection is sufficient to cause the agent to make a connection. To avoid the possibility of accidentally starting a connection where nothing is present (disrupting the user's transparency), the system will switch dial-up access mode to LAN access mode for a while and the TCP stack will- The percentage if not initialized is small-initialized and the system is returned to dial access mode.

In one example, an Inet access attempt is scheduled to expire, and if dial-up protection is not implemented, dial-up interaction will occur. This is the case when the user stops dialing up and there is no dialup manager. If the user is in the dial-up program before the time expires, no Inet access will be attempted. A mechanism for dial-up protection is necessary for the following reasons. If the system is in dial-up (RAS) mode, requests for Inet access are serviced in any manner. For example, the Windows operating system (NT
As a result of the multi-point tunneling protocol used by
A connection is made across the AN, while a dial-up connection is also established.
The first successful connection is routed to the customer who originally made the request. When the system is in LAN mode without LAN connection and an Inet access request is issued,
The TCP stack is initialized, resulting in a timeout. Even if the system had a modem, it would not be used. Thus, dial-up is avoided by switching to LAN mode before attempting all connections.

In both LAN and dial-up connections, agent communications are scheduled through lower priorities with respect to other communications, ensuring that there is no perceptible user impact on performance. Another way to achieve a "attentive" connection is to use TCP / I
Lower as long as it involves monitoring the P-stack, which requires loading the supporting DLL, thus increasing the memory footprint.

The customer map, the event map, and the plug-in map together define a “customer channel” through which interactions between the customer and the server occur. The customer map includes one or more customer objects. At a minimum, add customers to it, remove agents from the customer map, add agents,
There are privileged customer objects that can remove agents from the plugin map. All other customer channels are only used to schedule events and direct agents to download content from the server. The customer object in the customer map has an event object corresponding to the event and an event object corresponding to the plug-in map. The event map combined with the customer map causes interaction within the customer application UI space.

Preferred assistance for copying an application already in the field is
Note that the new application module name can be added by simply instructing the agent to add it to the customer lookup table. Subsequently, the agent checks in for the new customer and receives the order information.

The agent checks into the server when the check-in interval for the application elapses. The agent receives back from the server in the command file, which the agent subsequently interprets. Interpreting the instruction file may cause the agent to fetch resources from the server and / or put information back on it. The agent can also be instructed to check in other instruction files. Privileged customers can also be considered applications by agents. Therefore, the agent
Check in to the appropriate server at a check-in interval different from the check-in interval of other applications. Also, the application's instruction file can be checked in by privileged customers and vice versa.

As soon as the agent receives the resources and instructions from the server to actually do something, it will either display the appropriate message to the user or (typically) execute the target application, Can be instructed to wait until it works in the context of. The agent translates the system event data into explicit action events attached to the plug-in only while the application is running in the application's screen window, with a message appearing to the user as coming from the vendor. As a result of these,
It means the connection and trust between the customer and the vendor. A typical sequence of events is as follows.

1. Hooks determine whether a new application has begun or is of interest to the user. 2. The agent examines the customer object to see if the application is a customer. If not a customer, the agent remains on hold. 3. The correct customer with user input causes the agent to have the hook start monitoring the application closely and forward the selected application through the hook's plug-in. 4. The hook plugin reflects messages asynchronously to the agent, which catalogs events under the current username. 5. The agent examines the customer event map to find what to go. 6. If there is a match, the event is fired, which can include calling a plug-in that takes on the actions in the UI space within the application. If visible content is shown in the UI space of the application, the customer application is temporarily unavailable and may not be of interest to the user. 7. If any uploadable content is created within this event, it is passed to the Inet plugin, which sends or schedules the next round of bandwidth to be available and sent. . 8. After the event, the user's interest is sent back to the customer application. 9. The agent returns to step 4 above until the customer's application loses interest. When the customer's application loses interest, the agent transfers any customer application related data to a permanent storage location, where the agent returns to step 1 above.

Now that the structure and function of the agent have been described, the server will be briefly described.

The essential task of the server is to distribute the appropriate instruction file to the particular agent. The instruction file in the agent determines what action the agent is going to take-at any time to execute it for various types of actions, such as for user processing. The server keeps a record of each user of the application. When an agent running for one of the users connects to the server, the server, if any, has a table of rules that determines which of the potential instruction files the application has for the agent is appropriate for the agent. Find out for reference. Those rules are attributes based on all data in the database for that user.

An example of a rule is “If you installed this application 60 days or earlier, send command file A”, which causes the agent to take some action and “and if If installation is more recent than 60 days ago, send command file B ", which causes another action. The two behaviors will depend on the particular user's experience with the program. For example, when an update becomes available, the publisher sends one update message to experienced users suitable for the experience level or another update message to less experienced users suitable for the experience level. That you can choose. The experience level can be determined, for example, based on the time elapsed since the introduction.

The server may, for a particular agent examining the server at a particular point in time, enter into a table that progressively determines which of those rules, if any, are correct. Apply the rules made. One or more of those rules have "ignited", ie, discovering that it is correct, and the corresponding one or more instruction files are downloaded to the agent. Thus, the publisher receives ultra-fine control over the agent's behavior based on the agent's attributes. The result of a very sharp target is that any particular information is sent to a particular agent based on its characteristics and history.

It will be apparent to those skilled in the art that the present invention may be embodied in other specific forms without departing from its spirit or essential characteristics. Thus, the presently disclosed embodiments are illustrated in all respects, but are not to be construed as limiting. The scope of the invention is indicated by the appended claims rather than by the foregoing, and all changes within the meaning and range of equivalents are to be embraced therein.

[Brief description of the drawings]

FIG. 1 is a general block diagram of the present invention.

FIG. 2 is a diagram of a screen display of agent activation.

FIG. 3 is a more detailed block diagram of the agent of FIG.

──────────────────────────────────────────────────続 き Continued on the front page (72) Inventor Ron Van Oss, USA 94086 Sunnyvale Timberpine Avenue 715 (72) Inventor Jeffrey Bath United States California 94305 Stamford French Man's Road 745

Claims (20)

[Claims] 1. A method for exchanging information about one or more target customer applications between a computer platform having an operating system on which the target customer applications run and a remote server, The method comprises the steps of interfering with at least one of the passed message, a function called between the target customer application and the operating system, and from the target customer processing to a second processing for further processing. And annunciating the selected action asynchronously as a message, and in response to the annunciating, transferring information about the target customer application to or from the second process. And how. 2. The method of claim 1, further comprising the step of performing an action that the user knows is involved in the customer process without inserting a message into the message queue of the target customer application. Method. 3. The method of claim 2, wherein exchanging information about the target customer application includes scheduling an exchange of information between the computer platform and the remote server. 4. The method of claim 1, further comprising: establishing a virtual connection to the remote server; and transmitting information about the target customer application to the remote server, wherein exchanging information about the target customer application comprises substantially: 4. The method of claim 3 wherein the target customer application user is unknown. 5. The step of establishing the virtual connection includes the steps of detecting that the process has started a connection, starting the transfer process, and setting the priority of the transfer process to be lower than the process of starting the connection. Setting the priority to a low priority. 6. The method according to claim 5, wherein said second processing is an agent processing, and said transfer processing transfers an increasing small amount of data aggregated by the agent processing. . 7. The method of claim 2, wherein exchanging information about the target customer application comprises displaying the information in a user interface space of the target customer application. 8. The method of claim 7, further comprising adding a menu entry to a target customer application. 9. The method of claim 8, wherein the menu entry controls at least one aspect of the exchange of information. 10. The method of claim 7, further comprising removing the user's interest from the target customer application during the displaying of the information. 11. The method of claim 10, wherein displaying information and removing user interest comprises applying a formal interaction to a window of a target customer application. 12. Establishing a virtual connection to a remote server prior to displaying information in a user interface section of the target customer application, and providing information about the target customer application to the computer platform causing the display of the information. Transmitting the information, wherein the transmitting of the information is substantially transparent to a target customer application user. 13. The step of establishing a virtual connection includes the steps of: detecting that the process has started a connection; scheduling a transfer process; 13. The method of claim 12, further comprising: setting a low priority. 14. The method according to claim 13, wherein said second processing is an agent processing, and said transferring processing transfers an increasing small amount of data aggregated by the agent processing. . 15. A process for detecting a process on a computer platform, identifying the process, wherein the process is performed at a target customer application where information is to be exchanged between the computer platform and a remote server. Determining if there is any. 16. A method for exchanging information about a target customer application between a computer platform having an operating system and running the target customer application and a remote server, the method comprising: Interfering with the message passed between the application and the operating system; scheduling a transfer to exchange information about the target customer application derived from the message; and lowering the priority of the transfer. Setting the priorities. 17. The method according to claim 16, wherein said transferring process transfers a small amount of data summed up by an agent process. 18. The method according to claim 16, further comprising: establishing a LAN-type Internet connection; and performing a transfer process, wherein the execution of the transfer process is substantially unknown to a user. The described method. 19. A step of detecting that a connection may have been started, a step of starting a transfer process, and a step of setting a priority of the transfer process to a lower priority than a process of starting the connection. 17. The method of claim 16, further comprising: 20. The method of claim 19, further comprising the step of disabling dial-up before performing the transfer process, and enabling dial-up after the transfer process has begun. 20. The method of claim 19, wherein the information is unknown to a user.