Application Integration
Pega Robotic Automation Studio lets you interrogate applications to expose the underlying objects and uniquely identify each object. You can then use these objects to build automations and monitor application events. To interrogate an application, you use Studio adapters. Interrogation results in the creation of controls corresponding to the interrogated application targets. Studio uses translators and factories to enable communication between application targets and their platforms. Definitions of the key concepts and terms follow.
Adapters
Studio lets developers integrate applications at the desktop through their user interfaces. To integrate an application, Studio uses adapters to inject code within the target application that directly interacts with the application’s objects. Studio does not require the target application to be recompiled or modified in any way. Pega Robotic Automation supports a number of platforms and application control types including ...
Windows common controls
Internet Explorer, Firefox, and Chrome HTML controls
Java controls
.NET controls
An adapter is a component that lets users integrate with an application built upon a specific platform (Windows, web, and so on) by interrogating the application to produce metadata describing the application. Adapters have accessible properties, methods, and events.
Controls
When an application object is interrogated in Studio, a representation of that object is created. That representation is known as a control. Studio organizes controls in a hierarchy. For example integrating the Calculator application and interrogating the Clear button, Equals button, and Results text box.
This hierarchy is also represented in the classes associated with the control. For example, a text box interrogated in a Windows application would be in the OpenSpan.Adapters.Controls.Textbox class. The Textbox control has all of the properties, methods, and events associated with the OpenSpan.Adapters.Controls.Control (base control) along with those specific to the function of the text box.
A control performs these functions:
Saves the rules that are necessary to correctly identify the object the next time the application is run.
Acts as a proxy for the object so that it can be used in automations even when the user object has not been created within the target application.
Provides a consistent interface for the object regardless of the underlying application technology.
Controls are displayed in Studio's Object Explorer. A control is considered created when it has been matched, and destroyed when it has been unmatched.
The properties, methods, and events for controls inherit from the OpenSpan.Adapter:
Targets
A target is a Studio object that corresponds directly with an application object. Whereas controls represent the virtual application object that does not change between runs of the application, targets represent the actual application object that exists within the application at any given moment. Targets are created and destroyed when application objects are created and destroyed. Targets are platform specific and encapsulate the necessary logic to automate and monitor application objects. Thus, the text box control can interact with any target that implements the text box interface, such as a Windows text box target, a Java text box target or an HTML text box target.
Translators
A translator is a unit of injected code that lets Studio automate and receive events from an application object. Targets communicate directly with translators using the IPC layer. Most of the time translators are objects, although in some cases translators can just be a single module or static class that interacts with all supported objects. Translators do not require any modifications or recompilation of the target application. Studio automatically injects translators into a target application and attaches them to the appropriate application object. Translators are typically written in the same language as the objects they are interacting with. Thus for example, translators for .NET controls are written in C# and translators for Java controls are written in Java. The most notable exception to this is ActiveX or COM controls, which due to their binary interface can be written in C++ regardless of whether they were originally written in Visual Basic or another language. Translator assemblies are included in Deployment packages.
The diagram below illustrates the relationship amongst controls, targets, translators, and application objects.
Factories
Factories are controls that let Studio talk to specific platforms. These factories interact with Brokers as injected at the platform level (.NET, Java, Active X and so on). Factories appear in Object Explorer and are automatically detected by Studio.
From a user perspective, the most important thing to know about factories is that their appearance in Object Explorer indicates that Studio is interacting successfully with the platform.
