class WireWeakAsyncClientImpl

A method for a client to receive touch pointer events.

This call is formulated as a "hanging get" pattern: the client asks for

a set of recent events, and receives them via the callback. This

pull-based approach ensures that clients consume events at their own

pace; events don't clog up the channel in an unbounded manner.

Flow control. The caller is allowed at most one in-flight |Watch| call

at a time; it is a logical error to have concurrent calls to |Watch|.

Non-compliance results in channel closure.

Client pacing. The server will dispatch events to the caller on a FIFO,

lossless, best-effort basis, but the caller must allocate enough time to

keep up with new events. An unresponsive client may be categorized as

"App Not Responding" and targeted for channel closure.

Responses. The gesture disambiguation scheme relies on the server

receiving a |TouchResponse| for each |TouchEvent|.|TouchPointerSample|;

non-sample events should return an empty |TouchResponse| table to the

server. Responses for *previous* events are fed to the server on the

*next* call of |Watch| [1]. Each element in the |responses| vector is

interpreted as the pairwise response to the event in the previous

|events| vector; the vector lengths must match. Note that the client's

contract to respond to events starts as soon as it registers its

endpoint with scenic, NOT when it first calls `Watch()`.

Initial response. The first call to |Watch| must be an empty vector.

Event times. The timestamps on each event in the event vector are *not*

guaranteed monotonic; touch events from different devices may be

injected into Scenic at different times. Generally, events from a single

device are expected to have monotonically increasing timestamps.

View parameters. Occasionally, changes in view or viewport require

notifying the client. If a |TouchEvent| carries |ViewParameters|, these

parameters apply to successive |TouchPointerSample|s until the next

|ViewParameters|.

[1] The hanging get pattern enables straightforward API evolution, but

unfortunately does not admit an idiomatic matching of response to event.

The request and callback are allocated on the heap.

The gesture protocol allows a client to enact a "hold" on an open

interaction of touch events; it prevents resolution of interaction

ownership, even after the interaction closes. This method updates the

client's previous "hold" by replacing it with a response that allows

ownership resolution to proceed.

See |TouchInteractionId| for how a stream is structured into

interactions.

Flow control. The caller is allowed at most one |UpdateResponse| call

per interaction, and it must be on a closed interaction. It is a logical

error to call |UpdateResponse| when a normal response is possible with

the |Watch| call.

Validity. This TouchResponse must not be another "hold" response, and

the overwritten response is expected to be a "hold" response.

Allocates 72 bytes of request buffer on the stack. The callback is stored on the heap.