sdk/fidl/fuchsia.ui.pointer/event.fidl

// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

library fuchsia.ui.pointer;

///
/// Aliases
///

/// A floating-point two-dimensional point.
/// - The values are placed in (x, y) order.
using Point2 = array<float32>:2;

/// A floating-point two-dimensional vector.
/// - The values are placed in (x, y) order.
using Vec2 = array<float32>:2;

///
/// DeviceInfo
///

/// A characterization of a device that issues pointer event streams.
/// A device may track multiple pointers, and a pointer's continuous engagement
/// is modeled as a pointer event stream: a discrete stream of samples that
/// follow a simple state machine, modeled with |EventPhase|.
enum DeviceType {
    /// A device intended for manipulation by direct contact over its surface.
    TOUCH = 1;
};

/// Information about a device that issues pointer event streams.
///
/// All fields are required.
table DeviceInfo {
    /// An identifier for the pointer device that issues pointer event streams.
    /// A device may own multiple pointers, each with its own pointer id.
    1: uint32 id;

    /// A characterization of a device that issues pointer event streams.
    2: DeviceType type;
};

///
/// PointerSample
///

/// The possible states of a pointer event stream's state machine.
/// An event stream follows these state machines:
/// ADD - CHANGE* - REMOVE
/// ADD - CHANGE* - CANCEL
enum EventPhase {
    /// The device has started tracking the pointer.
    ADD = 1;

    /// The device has reported an update to the pointer state.
    CHANGE = 2;

    /// The device has stopped tracking the pointer.
    REMOVE = 3;

    /// The event stream is no longer available.
    CANCEL = 4;
};

/// A description of each sampled data point in a pointer event stream.
/// All fields are required.
table PointerSample {
    /// An identifier for the pointer device that issues pointer event streams.
    /// A device may own multiple pointers, each with its own |pointer_id|.
    1: uint32 device_id;

    /// An identifier of the pointer that issued this event. It is unique only
    /// to a specific |device_id|. Each (device_id, pointer_id) pointer issues
    /// at most one pointer event stream at a time.
    2: uint32 pointer_id;

    /// The state of this event in the pointer event stream's state machine.
    3: EventPhase phase;

    /// The position of this event, in the viewport's coordinate system.
    4: Point2 position_in_viewport;
};

///
/// EventStreamOwnership
///

/// The pointer event stream's disposition, sent from server to client.
enum EventStreamOwnershipStatus {
    /// The client has been denied ownership of the event stream.
    DENIED = 1;

    /// The client has been granted ownership of the event stream.
    GRANTED = 2;
};

/// The ownership status of a pointer event stream, sent from server to client.
///
/// All fields are required.
table EventStreamOwnership {
    /// An identifier for the pointer device that issues pointer event streams.
    /// A device may own multiple pointers, each with its own |pointer_id|.
    1: uint32 device_id;

    /// An identifier of the pointer that issues a pointer event stream. It is
    /// unique only to a specific |device_id|. Each (device_id, pointer_id)
    /// pointer issues at most one pointer event stream at a time.
    2: uint32 pointer_id;

    /// The pointer event stream's disposition, sent from server to client.
    3: EventStreamOwnershipStatus status;
};

///
/// Event
///

/// A selection of FIFO data sent over the channel.
/// Each data may have a different issuance policy.
flexible union Data {
    /// The parameters of the associated view and viewport, sufficient to
    /// correctly interpret the position, orientation, magnitude, and
    /// inter-event distance of pointer events dispatched to a view.
    /// - It is issued on connection and on change.
    1: ViewParameters view_parameters;

    /// A description of the pointer device, sufficient to correctly interpret
    /// the capabilities and usage intent of the device.
    /// - It is issued once per device.
    2: DeviceInfo device_info;

    /// A description of each sampled data point in a pointer event stream.
    /// - It is issued on every sample in the pointer event stream.
    3: PointerSample pointer_sample;

    /// The result of gesture disambiguation for a pointer event stream.
    /// - It is issued once per pointer event stream.
    4: EventStreamOwnership event_stream_ownership;
};

/// The self-sufficient, self-consistent collection of pointer-related data,
/// sent from server to client.
table Event {
    /// The time this event was observed.
    ///
    /// Required.
    1: zx.time timestamp;

    /// The event's data.
    ///
    /// Required.
    2: Data data;

    /// An identifier to correlate this event's send/receive occurrence across
    /// component boundaries or abstraction layers.
    3: uint64 trace_flow_id;
};

///
/// Response
///

/// The possible event stream dispositions that a client can respond with to a
/// given |PointerSample|. Used as part of a gesture disambiguation scheme.
///
/// The responses revolve around the idea of an ownership claim on a pointer event
/// stream (i.e., current and future events of that event stream). Clients may
/// assert a claim of ownership on the current event stream, but only one
/// client's claim is granted by the server; other clients' claims are denied.
enum ResponseType {
    /// The client declines ownership of the event stream.
    NO = 1;

    /// The client has not yet claimed ownership of the event stream.
    MAYBE = 2;

    /// The client needs to see a subsequent event stream to decide its claim on
    /// the current event stream.
    HOLD = 3;

    /// The client claims ownership the event stream.
    YES = 4;
};

/// A feedback event per |Event|, sent from client to server.
///
/// Only |PointerSample| requires a |ResponseType|; for other events, an empty
/// |Response| table is sent to the server.
table Response {
    /// The event stream disposition that a client responds with for a given
    /// |PointerSample|.
    1: ResponseType response_type;

    /// An identifier to correlate this response's send/receive occurrence across
    /// component boundaries or abstraction layers.
    2: uint64 trace_flow_id;
};