Your ability to create efficient customer services processes are often constrained by the myriad of applications on your agent desktop – a typical customer service process may need to span multiple Windows and Web applications, none of which are integrated with each other, resulting in cumbersome process flows, rekeying of data and lack of integration - all of which adds up to lengthy call times, reduced accuracy (think customer call backs) and an overall increase in customer frustration. And reusing these applications in your SOA initiatives are even more problematic as they typically have no API, making accessing the data and functionality nearly impossible. The results are siloed applications on your desktop that do not work well together in an integrated and orchestrated manner.
Jacada Integration and Automation ("JIA") provides robust data integration and desktop automation capabilities on your existing Windows and Web applications. Desktop Automation provides process guidance, enhance your existing workflows, and eliminate redundant data entry while simplifying lengthy navigation sequences. Unlike many competing products, JIA steps beyond pure automation and provides integration capabilities allowing you to expose your existing closed application functionality as open standard web services for reuse in your SOA initiatives.
Even more importantly, all this is accomplished without modification of the applications, without access to their source code and without needing an API!
Whether it's a custom in-house developed application, or an off–the-shelf package, Jacada Integration and Automation is desktop automation solution and your path to rapid, risk free integration.
You need Desktop Automation if...
• Your agents struggle with complex or lengthy navigation sequences
• Your agents have to re-type data on multiple applications during a call
• The user experience could be improved through process guidance
• You want to reuse application functionality in new composite applications such as a unified desktop solution or as part of a broader SOA initiative.
How Does Desktop Automation Work?
Jacada Integration and Automation ("JIA") enables connectivity to Windows and Web applications without any code modification and without requiring access to the source code. If you can run the application, you can integrate to it!
Jacada Integration and Automation (JIA) is comprised of a development environment and a runtime environment. The development environment leverages the popular Microsoft Visual Studio IDE, allowing developers to create the solution in their favorite IDE. No more closed, proprietary solutions!
The runtime environment allows the solution to be deployed either in a "Desktop" mode in which the JIA scripts react to events occurring on the agent's desktop, or in a "Server" mode where the application functionality is surfaced as a web service API, ideal for SOA initatives.
• Desktop mode – The integration and automation of the application is done on the agent desktop, as if the agent were physically interacting with the application.
• Server mode – Applications are opened in multiple sessions (and optionally pooled) on a back-end server and exposed to the calling client via open standard web services.
In either deployment instance, JIA provides non-invasive access to the underlying applications, preserving all the existing business logic built into the user interface.
The Benefits of Desktop Automation for Your Business
By removing the underlying application constraints, your business can focus on delivering the optimal customer service experience.
Routine, complex or lengthy tasks can be automated, data can be automatically copied from one application to another and new business rules can be enforced, all without requiring modification to the applications, resulting in much faster implementation cycles with significantly reduced risk.
With Agents not needing to perform all these tasks manually, our clients typically reduce Average Handling Time (AHT) by 20% - 30%, increase First Call Resolution (FCR), increase sales revenue, and raise overall customer satisfaction.
The Benefits for IT
Your SOA initiatives are accelerated by rapidly exposing your legacy applications as reusable web services.
You can extend the life of your legacy desktop applications by reusing them in composite mash-up’s.
Using C#, your developers can continue to use industry standard tools and not be forced into adopting proprietary, limited languages.
JIA technology offers sophisticated workflow capabilities that allow it to do so much more than desktop automation. By leveraging the ability to monitor activity on the desktop, and interact with the underlying applications, users can be guided through complex processes with nonobstrusive UI overlays, providing Next Best Action guidance.
Solving Application Complexity
JIA solves the problem of application complexity. By automating complex navigation sequences, the user is spared the complex and time wasting steps of searching for information multiple screens deep, and from rekeying in data in multiple applications or screens within an application.
One of the most powerful JIA capabilities is its ability to surface you existing application functionality as open standard Web Services. These Web Services can be reused within a broader SOA initiative, meaning new life for your existing applications. And with orchestration technology, your new web services can be used to rapidly assemble new applications.
Desktop Automation Development Environment:
Uses Industry leading Visual Studio IDE
JIA leverages the power of the Visual Studio IDE by shipping as a Visual Studio "plug-in". After installation, the JIA development tools are conveniently located on the toolbar of the IDE. This allows developers to continue developing in the Visual Studio IDE without needing to move to a separate or proprietary development environment.
The development environment is comprised of two development options:
1. Graphical Designer – The graphical designer is a standalone tool and allows the JIA developer to interrogate and capture UI controls of the target application and store them in graphical repository. These controls can then be used in an automation process, called an Activity. Activities consist of the UI control and the actions to be performed on it, or an event to be monitored on that particular control. The different activities are connected together to represent the desired logic in the completed automation flow. Under the hood, the depicted graphical representation will result in auto generation of C# code that represents the automation piece. This C# sharp code can be extended by advanced developers.
2. Writing C# code – In addition to the graphical designer, advanced developers can opt to code C# directly inside the Visual Studio 2010 IDE. JIA installs as a Visual Studio plug-in which brings the graphical representation of the repository into a VS2010 window, and allows for a drag and drop of UI controls and routines directly into the code. This particularly powerful option allows the developer to leverage all of the strengths inherent to C# while writing code. Since this is an open environment, the developer can also incorporate other C# assemblies into his solution and as such extend the use to even more sophisticated levels.
Recording a transaction:
The basic steps to enable a developer to quickly capture a series of interactions and generate a Web service are:
• Navigate the Windows application
• Define the input and output fields
• Optionally add any additional logic to the script
• Deploy the service
A complete transaction can be recorded from start to finish using the JIA recorder; this option will include the capturing of the UI controls and adding them to the GUI repository. This will include recording the operations that were performed while the transaction was recorded. These operations will be translated to C# code where they can be optionally extended.
The types of operations that may be recorded on an application include:
• The fact that the Application was launched
• Any button that is clicked
• Any text that has been entered into an edit field
• Any selection on a ComboBox, RadioButton, CheckBox and further controls
• Any mouse or keyboard operation on the screen.
• ...and many more
After the operation has been recorded, JIA will offer the developer the option of generating a web-service for the recorded transaction and expose it automatically in such a way that it can be consumed by any web-service client. It is also possible to define various Input and Ouput parameters to the web-service, with support for both primitive types and objects. This type of transaction would greatly suit a backend service that is developed to run on a server.
The internal mechanisms that make all this possible are a result of Jacada's decades of experience in non-invasive integration. While the specific mechanism varies by application type, the concept is the same. By intelligently identifying controls on the user interface, JIA is able to intercept messages to these controls, modify values in the message and allow normal processing to continue. By working at this messaging layer, JIA is not sensitive to row/column or pixel level changes of UI controls on the screen, unlike other "screen scraping" solutions. JIA additionally supports playback of http streams to mimic request/response packets, in order to automate and integrate with certain web applications.
Desktop Automation Features
The JIA GUI Repository is a centralized repository of all the controls and UI object you wish to interact with in a Windows or Web application. The GUI repository is an embedded part of the VS2010 plugin and resides within the IDE. These controls can then be used to create automated processes, such as clicking a specific button or to interact with the application's user interface, to automate processing otherwise done manually by the agent. Using controls from the GUI repository is as simple as performing a "drag and drop" from the repository to the code. When dropping the control in the code window, the fully qualified path to the actual object will be generated in the code and all the relevant API/Events for that particular control type would then be exposed through VS2010 'intellisense'. The controls properties can be modified through the GUI repository's properties window. The JIA developer might elect to give different names to controls from what was originally generated in recording or s/he might want to change any of the other properties.
The GUI Objects include:
• GUI objects - Controls captured from Windows-based applications for which JIA provides out-of-the-box support, such as Web, Java or Powerbuilder applications
• Virtual GUI objects - User-defined objects that are based on the image representation of the control and can be created by the user. This virtual object can be also be defined to be tolerant to a certain degree of pixel difference to the original image, this feature is useful when changes to screen resolution, etc. are performed. Note that this is only used when native GUI objects are not available.
Support for Repeating Objects
Repeating objects are objects in an application that are displayed more than once, where their exact number cannot be determined in advance. During runtime, the number of these objects can vary and therefore, during development, capturing a fixed set of these objects is not possible. An example of repeating objects is a table of customer complaints for a specific day. JIA provides methods to handle these repeating objects.
Dynamic Table Support
JIA Dynamic Table Supports allows for the extraction of data out of tables in a manner that is not dependent on the size (row/column) of the table or on the content. The JIA developer can dynamically iterate through a table and extract data from it dynamically, thus being tolerant to changes in the actual web table.
When recording controls and events in the target application, it is possible to save snapshots for each GUI object added to the repository. A snapshot is saved for each application window or dialog in which the object is displayed. The snapshots enable you to relate a GUI object in the repository to the object that it represents in the Windows-based application, without the need for activating the application, allowing for quicker understanding, debugging and walkthrough of the application automation code.
Open Standard C# code generation
The code generated by JIA is open standard C# code. This code can then be extended or modified by developers familiar with C#, obviating the need to learn a proprietary language. Unlike other products that produce "scripts" in xml, JIA provides the full power of the .NET platform.
Easy to use Object Hierarchy
Because controls are captured in the GUI Repository, JIA makes it easy to access and manipulate these objects. For example, below we open the Windows Address Book, choose to add a New contact and set the first name of the new contact, all in three lines of code:
JIA can monitor events in an application, such as a control receiving focus, text being typed in an edit box and so forth. When the Windows-based application is running on the agent desktop, WinFuse 'listens' to the user's interaction with the application, and waits for a predefined event to occur. Once the event occurs, it can be used to trigger additional processing.
Developers can choose to register for a particular event, such as "TextChanged" or "OnClick". Custom business logic can be placed in the event handler.
Below is an example custom event handler to simulate clicking the "Ok" button when the text in the field changes:
As depicted above, as soon as the text is changed in the editbox the event handler will obtain the application instance from the sender in the event arguments and perform the click on the targeted application.
JIA is able to automate applications on the desktop in a "hidden" mode, meaning that the applications do not have to be visible to the agent, nor do they need to have active focus for automation to be enacted on them.
Unlike other non-invasive integrations tools, JIA uses open standard C# to automate and integrate with applications. You are not limited to manipulating XML or, worse, a proprietary script based language. With the full power of C# and the .NET framework available to you, you can easily extend the power of your automation transactions.
Windows applications may have different internal messaging mechanisms depending on the language they were originally developed in. Likewise, Web applications today may be straightforward request/response based while some may utilize significant client side coding (think AJAX) to provide a rich user interface and asynchronous request/response packets. All of these applications have varying ways of integrating to them. JIA supports multiple protocols so that for any specific application, the most optimal integration technique can be used.
JIA is a flexible solution and was designed to allow us to support diverse environments. Please contact Jacada with your unique requirements. Previously supported clients include: Oracle Forms, .NET, Visual Basic/ActiveX, PowerBuilder, MFC, Delphi, Java, Citrix and most Web applications.
Async– multi app automation
JIA is built from the ground up to support full multi-threading. Multiple applications can be automated at the same time and events can be monitored on multiple applications at the same time. Web applications can run completely minimized or hidden as no focus is required to automate the application.
Transaction based automation (also in desktop interaction mode) allows the synchronization of different sets of automation pieces and the results returned (if any) from that particular transaction. JIA transactions can be efficiently managed with support for Parallel, Nested and Continues modes within a transaction.
Performance and scalability
JIA supports a decentralized deployment, allowing processing of events to be pushed to the agent desktop resulting in less server scalability requirements.