Software application programs (herein, programs or applications) may call other application programs to perform a specific functionality. For example, the program Microsoft® Word may call a spreadsheet program to operate on a set of data in a table. When a first program calls a second program, the first program must comply with the application program interface (API) of the second program. As used herein, an API for a program specifies the format of calls to that program and parameters that may be passed to the program. Different application programs, and different versions of the same program, usually have different application program interfaces, even if the programs perform the same functionality. This is particularly true where the applications are from different third-party vendors. Differences in and changes to a program's API may cause conflicts and/or make software upgrades and additions time-consuming and costly because each affected calling application must be reconfigured. As an example, different applications that may be available to a user (e.g., SAP BW 2.0™ and MySAP ERP 1.0™) may be written to call different versions of the Microsoft Excel® spreadsheet (e.g., Excel 2003® and Excel 97®), in which case there may be a conflict between the usages of the Excel® spreadsheet.
To avoid these problems, there is a need in the art for a stable and consistent system having the ability to efficiently and cost-effectively upgrade existing software application programs and add new application programs.
The present invention provides a software application program interface system and method. In some embodiments, a first software application that is to call another type of application may forward the call to an integration module, and the integration module may call an application of that type (if available) after translating the call to a format recognized by the called application. It may be understood that the examples discussed below are for illustration purposes only and are not intended to limit the configuration to that shown.
Calling application 150 and application programs 300 may be any types of application programs, such as word processor programs, spreadsheet programs, calendar programs, database programs, finance programs, etc. As shown in
Integration module 200 may provide a method and system for integrating with applications 300 that allows a calling application to make calls that are independent of the data formats and APIs used by the application ultimately called. In some embodiments, integration module 200 may be used as an abstraction layer for integration with different applications 300. Upon receiving a call for an application type from a calling application, integration module 200 translates the call and any call parameters into those that are recognized by the called application of that type.
Data can be exported from the calling application via integration module 200 to applications 300.
It is to be understood that, in some embodiments, calling application 150, integration module 200 and application programs 300 may reside on the same or different computers in a network.
Integrator 250-1 provides an application specific call message in a format recognized by a particular available application programs of the specified type. For example, integrator 250-1 may translate the calling application's call and convert data into a .doc file that Microsoft® Word 97 recognizes. An example of the translated call is “Call Word 97 (.doc file).” Integrator 250-1 calls the API of Microsoft® Word 97 with the translated call and passes the converted data to application 300-1. Application 300-1 then processes the converted data.
In one embodiment, integration module 200 may use a routine in JavaScript™ from Sun Microsystems® to integrate the calling application with the called applications. In some embodiments integration module 200 may use a routine using Active X® technology from Microsoft Corp. to integrate the calling application with Microsoft Office® applications. Alternatively, in some embodiments, integration module 200 may use Java™ applet technology from Sun Microsystems® to integrate the calling application with Microsoft Open Office® applications.
It is to be understood that the set of available applications may include different versions of the same application. In this case, integration module 200 determines which version of the applications to handle the call from calling application 150. Typically, only one version is resident on a system because earlier versions are likely deleted when the system is upgraded to a newer version.
It is also to be understood that calling application 150 need not pass data to integration module 200 for processing by available application 300-1. Instead, calling application 150 may only make a call. As a result, application 300-1 on initiation may display a blank document or no data. The user may then input data to the blank document.
If an application program of the specified type is available for execution on the computer system, an application specific call message may be provided in a format recognized by a particular available application program of the specified type (325). For example, integration module 200 may provide a call (convert call parameters) into a format compatible with the particular available application that is to be called. Integration module 200 may perform the conversion using resident conversion code. Alternatively, integration module 200 may call a separate routine having conversion code. The particular available application program may then be called using the application specific call message (330). For example, integration module 200 may call the API of the called application with the translated call and pass the converted call parameters to the application. The called application may then execute the specific called application and may process the call parameters' data.
When one of applications 300 is upgraded or a new application added, the developer may simply add a plug-in or otherwise modify integration module 200 to include respective upgraded or new integrators 250. The code for generating new or upgraded integrators may be provided by the vendors of the new or upgraded application software. The developer need not modify the applications themselves, thereby advantageously saving the developer time and costs. The computer system may be affected by the modifications, but the applications that use the integration module 200 may be unchanged.
The above is a detailed discussion of the certain embodiments. It may be understood that the examples discussed are for illustration purposes only and are not intended to limit the configuration to that shown. It is of course intended that the scope of the claims may cover other embodiments than those described above and their equivalents.
This application claims the benefit for purposes of priority to U.S. app. Ser. No. 60/586,279, filed Jul. 9, 2004.
Number | Name | Date | Kind |
---|---|---|---|
5491800 | Goldsmith et al. | Feb 1996 | A |
5659767 | Nguyen et al. | Aug 1997 | A |
5963205 | Sotomayor | Oct 1999 | A |
6052779 | Jackson et al. | Apr 2000 | A |
6405225 | Apfel et al. | Jun 2002 | B1 |
6405366 | Lorenz et al. | Jun 2002 | B1 |
6662186 | Esquibel et al. | Dec 2003 | B1 |
7036072 | Sulistio et al. | Apr 2006 | B1 |
7143167 | Kampe et al. | Nov 2006 | B2 |
20010054046 | Mikhailov et al. | Dec 2001 | A1 |
20020188638 | Hamscher et al. | Dec 2002 | A1 |
20040010791 | Jain et al. | Jan 2004 | A1 |
20040010796 | Paul et al. | Jan 2004 | A1 |
20040017583 | Kageyama et al. | Jan 2004 | A1 |
20040193596 | Defelice et al. | Sep 2004 | A1 |
20040199922 | Krutsch et al. | Oct 2004 | A1 |
20050010458 | Holloway et al. | Jan 2005 | A1 |
20050097462 | Lumera et al. | May 2005 | A1 |
20050160414 | Parnanen et al. | Jul 2005 | A1 |
20060004699 | Lehikoinen et al. | Jan 2006 | A1 |
Number | Date | Country |
---|---|---|
2000039991 | Feb 2000 | JP |
Number | Date | Country | |
---|---|---|---|
20060010452 A1 | Jan 2006 | US |
Number | Date | Country | |
---|---|---|---|
60586279 | Jul 2004 | US |