Service proxy fire-and-forget method class, one for each ClientServerOperation ( ClientServerOperation.fireAndForget==TRUE) defined in the ServiceInterface in the role method.
Enables the unacknowledged invocation of one-way service interface methods without a return value at client level.
AI-GENERATEDunreviewedModel: gemini-3.8-flash-medium · Effort: medium · Temperature: not controllable · Prompt: c09dd8b0ab24ProvenanceOpen questions (2)
translated from the German guidegemini-3.8-flash-low · 2026-10-13 · German original
Enables the unacknowledged invocation of one-way service interface methods without a return value at client level.
The proxy class enables the client application to trigger unacknowledged method invocations for service operations with fire-and-forget semantics [SWS_CM_90435]. When calling the function operator, the input parameters are transmitted without creating a return value or a response future for a result. At the same time, end-to-end protection is executed with each method call, the current check status of which can be queried separately [SWS_CM_00147]. A call is exception-safe, but fails with an authorization violation in case of insufficient access rights.
Context
The class <SI-Namespace>::proxy::methods::<FnFMethod> represents a fire-and-forget method on the client or proxy side in the Communication Management of the AUTOSAR Adaptive Platform [SWS_CM_90435]. In a service-oriented architecture, exactly one such instance in the proxy role exists for each operation (ClientServerOperation) defined in the interface where ClientServerOperation.fireAndForget == TRUE is specified [SWS_CM_90435], SWS CommunicationManagement §8.3.4.1.2.1 “operator()”.
Its core responsibility lies in accepting invocation arguments and forwarding them to the transmission layer. Unlike synchronous or asynchronous bidirectional invocations that notify the caller via a ara::core::Future and transport any application errors [SWS_CM_00197], a fire-and-forget invocation requires neither a response nor an acknowledgement from the server side. The interaction partners include the calling client application, the method instance of the service proxy, and the downstream communication binding including E2E protection.
Context diagram: Components and interface relationships of the proxy fire-and-forget method class. Sources: [SWS_CM_90435], [SWS_CM_00147]
Lifecycle
The class is declared within the generated header file #include "<SiNamespaceDerivedDirectoryPath>/<SiShortname>_proxy.h" in the hierarchical scope <SI-Namespace>::proxy::methods::<FnFMethod>[SWS_CM_90435]. The lifetime of the method instance is likely tied to the lifetime of the enclosing service proxy object (interpretation: the method is created and destroyed as a sub-object together with the service proxy). Question Q-9ee6da68f325c3d0 (open)
Beyond the invocation itself, the class possesses an internal state regarding E2E protection (end-to-end protection). This E2E state is determined on each method invocation via the function E2E_Check() and can be queried via GetE2EStateMachineState(), which returns the status value of type ara::com::e2e::SMState[SWS_CM_00147], SWS CommunicationManagement §8.3.4.1.1.1 “GetE2EStateMachineState”. All member functions are declared as noexcept[SWS_CM_00147], [SWS_CM_90435]; external synchronization is likely required when invoked concurrently from multiple threads if the binding does not guarantee reentrancy. Question Q-e59aae09676d76c2 (open)
Usage Path
The typical procedure for using a fire-and-forget method comprises the following steps:
Proxy provisioning: The application instantiates or acquires the generated service proxy via the defined header interface [SWS_CM_90435].
Execute method invocation: The application calls the method object via operator(), passing the input parameters [SWS_CM_90435]. The function provides no return value (void) and returns immediately without waiting for a server response SWS CommunicationManagement §8.3.4.1.2.1 “operator()”.
E2E update: During the invocation of operator(), the middleware internally performs the protection check E2E_Check() and updates the internal state machine [SWS_CM_00147].
Sequence diagram: Typical interaction sequence when invoking a fire-and-forget method followed by a status query. Sources: [SWS_CM_90435], [SWS_CM_00147]
Error Scenarios
Both operator() and GetE2EStateMachineState() are exception-safe and declared as noexcept[SWS_CM_00147], [SWS_CM_90435]. Therefore, no C++ exceptions are thrown.
In the case of missing access rights, grant enforcement takes effect: If the calling context lacks the necessary permissions, the invocation is denied and a InsufficientPermissionsViolation is registered [SWS_CM_90435].
Since no return is made via a ara::core::Future and fire-and-forget operations do not support the transmission of a ApApplicationError or ara::core::ErrorCode[SWS_CM_00197], transmission errors are not reported back to the caller. Any errors in data security or in the transmission channel manifest exclusively in the state of the E2E state machine, which can be diagnosed via GetE2EStateMachineState()[SWS_CM_00147].
This guide is based on the AUTOSAR Adaptive Platform Release R25-11 specification and describes the functionality of the proxy fire-and-forget method class.
UML class diagram
Hohle Dreieckspfeile = Vererbung (zeigt zur Basisklasse); Klicken öffnet die jeweilige Klassenseite.
Returns the state of the specific fnfmethod class, which was determined by the last run of E2E_Check() function invoked during the last call of operator()
Returns the state of the specific fnfmethod class, which was determined by the last run of E2E_Check() function invoked during the last call of operator()
gemini-3.8-flash-low· 2026-10-13 · German original