In Rich UI, the call statement
is used to invoke a service asynchronously:
call serviceName.operationName(argumentList)
returning to myCallbackFunction onException myExceptionHandler
{timeout = milliseconds};
- serviceName
- The name of a variable that is based on an Interface part
- operationName
- The name of the Interface part function prototype
- argumentList
- A list of arguments, each of which is separated from the next
by a comma
For
restrictions on arguments, see “Restrictions in the prototypes
used for service access.”
- myCallbackFunction
- The name of a callback function or delegate that is available
to the call statement. In most cases, the function or delegate is
in the same Rich UI handler or in a library. The callback function
is described later in this topic.
- myExceptionHandler
- Optional. The name of an exception handler or a delegate that
is available to the call statement. In
most cases, the exception handler or delegate is in the same Rich
UI handler or in a library. The exception handler is described later
in this topic.
If you do not have your own exception handler, you
can specify the following delegate:
serviceLib.serviceExceptionHandler.
Here are the implications:
- By default, specifying that delegate automatically invokes a system
function that writes the content of the exception message field
to the standard output. In the product, the standard output is the
console view. In an external browser, the standard output is the bottom
of the web page.
- Alternatively, the delegate might cause the invocation of a custom
exception handler. You can even use this alternative to make custom
error handling be consistent throughout a set of applications.
For
example, you might do as follows:
- Create a library named myLibrary and include
both a custom exception handler named myExceptionHandler and
a setup function.
- In the setup function, include the following statement:
serviceLib.serviceExceptionHandler = myLibrary.myExceptionHandler;
- Invoke the setup function in each of your Rich UI applications,
in the on-construction function.
For every service that is invoked by a call statement
(if the statement includes serviceLib.serviceExceptionHandler),
the EGL runtime code responds to a runtime exception by running the
customized exception handler; in this case, by running myLibrary.myExceptionHandler.
- milliseconds
- The maximum valid number of milliseconds that elapse between when
the EGL Rich UI proxy (on the application server) invokes a web service
and when the proxy receives a response. If more time elapses, the
EGL runtime code throws a ServiceInvocationException.
However, no timeout is enforced during access of a dedicated service.
To
set a timeout:
- Consider various factors, such as local network traffic, internet
traffic, and server response time. Those factors mean that two invocations
of the same service are likely to take a different amount of time
under different conditions.
- Consider the nature of your application. If your code is waiting
for a credit approval, you might set a high timeout value to avoid
charging the user twice. If your code is making a bid in an online
auction, you might set a low timeout value so that the user can make
another bid quickly.
- Use timeout values that vary from one another by one or more seconds.
You can set a default value for milliseconds in
the defaultServiceTimeout build descriptor
option. The defaultServiceTimeout build
descriptor option has no default value set. If you do not specify
a value for either defaultServiceTimeout or
for milliseconds, the service call will
not time out. For more information, see “defaultServiceTimeout.”
Keystroke assistance for the call statement
The
following kinds of keystroke assistance are available:
- After you type the returning to or onException keyword
in the call statement, you can request content
assist by pressing Ctrl+Space. A list of functions is displayed, and
you can select one.
- If you type the call statement with
the ending semicolon and include a reference to a callback or an onException
function that does not exist, you can request that the workbench create
the missing logic:
- Press Ctrl+1.
- Alternatively, right click after the semicolon and select Create
Callback Functions.
Callback function
The callback function
receives the values, if any, that are in the response sent by the
service. The callback itself has no return value.
If the callback function
is invoked from a third-party REST service, the function can have
zero or one parameter. If a parameter is specified, its type must
match the type of the return value that is specified in the Interface
part, and the parameter modifier is IN.
If the
callback function
is invoked from a SOAP service or from an EGL REST-RPC service, the
relationship of the function parameters and the service-invocation
parameters is best described by an example:
- Consider the following function prototype in an Interface part:
Interface EmployeeService {}
Function GetEmployeeDetail(employeeCode STRING IN,
employeeSalary FLOAT OUT,
employeeStatus STRING INOUT)
returns(myEmployeeRecordPart);
end
- This example shows an interface declaration and call statement
used to invoke the service:
myInterface EmployeeService;
call myInterface.GetEmployeeDetail("A123", 25.8, "Full-time")
returning to myCallback onException myExceptionHandler;
- Here is the outline of a callback function:
Function myCallBack(salary FLOAT IN,
status STRING IN,
myRecord myEmployeeRecordPart IN)
// statements here
end
The function includes one parameter for each service-operation
parameter that is OUT or INOUT. The order of those parameters in the
callback function is the same as the order in the service operation.
The service-operation return value is represented as the last parameter
in the callback function.
In general, the rules for designing the
callback function
for a web SOAP service or an EGL REST-RPC service are as follows:
- The function has a series of parameters that are in the same order
as the OUT and INOUT parameters in the service invocation
- If the service invocation has a return value, the callback function
includes an additional, last parameter to accept the return value
- Each parameter in the function has the IN modifier
onException function
The
onException function
has the following characteristics:
- No return value
- The function accepts an Exception record of type AnyException,
and you can test that record to determine the specific type received
Here is the outline of an onException function:
Function myExceptionHandler(exp AnyException)
case
when (exp isa ServiceBindingException)
;
when (exp isa ServiceInvocationException)
;
otherwise
;
end
end
Errors might occur in the following places:
- In a service binding; that is, in how the service access is specified
in your code. This error might involve a problem in the deployment
descriptor.
- In the communication of the Rich UI application with the EGL Rich
UI Proxy
- In the EGL Rich UI Proxy
- In the communication of the EGL Rich UI Proxy with the service
- In the service
A problem in a service binding results in a ServiceBindingException.
Other problems result in a ServiceInvocationException or
a RuntimeException, which is less likely.