src/sys/activity/activity_provider_connection.h

// Copyright 2019 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.

#ifndef SRC_SYS_ACTIVITY_ACTIVITY_PROVIDER_CONNECTION_H_
#define SRC_SYS_ACTIVITY_ACTIVITY_PROVIDER_CONNECTION_H_

#include <fuchsia/ui/activity/cpp/fidl.h>
#include <inttypes.h>
#include <lib/fidl/cpp/binding.h>
#include <lib/zx/time.h>
#include <zircon/types.h>

#include <optional>
#include <queue>
#include <random>

#include "src/lib/fxl/macros.h"
#include "src/sys/activity/common.h"
#include "src/sys/activity/state_machine_driver.h"

namespace activity {

// ActivityProviderConnection is the server-side implementation of the activity
// service's fuchsia.ui.activity.Provider FIDL interface.
//
// One instance of ActivityProviderConnection is created to manage the
// connection with a single client.
class ActivityProviderConnection : public fuchsia::ui::activity::Provider {
 public:
  ActivityProviderConnection(StateMachineDriver* state_machine_driver,
                             async_dispatcher_t* dispatcher,
                             fidl::InterfaceRequest<fuchsia::ui::activity::Provider> request,
                             uint32_t random_seed);
  ~ActivityProviderConnection();

  // Cleans up any resources owned by the instance, including unregistering it as an observer
  // with |state_machine_driver_|.
  zx_status_t Stop();

  void set_error_handler(fit::function<void(zx_status_t)> callback) {
    binding_.set_error_handler(std::move(callback));
  }

  // fuchsia::ui::activity::Provider API
  virtual void WatchState(::fidl::InterfaceHandle<fuchsia::ui::activity::Listener> listener);

 private:
  void OnStateChanged(fuchsia::ui::activity::State state, zx::time transition_time);

  // Publish the latest state to |listener_| if there is any new state to send.
  //
  // When new state is published, PublishStateIfAvailable() will be recursively
  // invoked (asynchronously) once the listener finishes receiving the state.
  // Thus, this method will continuously publish state to the client as quickly
  // as the client can receive it, until the client has observed all state
  // (i.e. until |state_changes_| is empty).
  //
  // Once |state_changes_| is empty, this method sets |listener_ready_| and
  // returns. The next call to OnStateChanged() will (asynchronously) invoke
  // this method.
  //
  // Expected to be run within |dispatcher_|.
  void PublishStateIfAvailable();
  void PublishState();

  ObserverId GenerateObserverId();

  struct StateChange {
    StateChange(fuchsia::ui::activity::State state, zx::time time) : state(state), time(time) {}
    fuchsia::ui::activity::State state;
    zx::time time;
  };

  StateMachineDriver* state_machine_driver_;
  std::optional<ObserverId> observer_id_;
  std::default_random_engine random_;

  // FIFO of state changes which have been observed but have not yet been sent
  // to the Listener client.
  std::queue<StateChange> state_changes_;
  bool listener_ready_;

  async_dispatcher_t* dispatcher_;
  async::TaskClosureMethod<ActivityProviderConnection,
                           &ActivityProviderConnection::PublishStateIfAvailable>
      publish_state_task_{this};

  fidl::InterfacePtr<fuchsia::ui::activity::Listener> listener_;
  fidl::Binding<fuchsia::ui::activity::Provider> binding_;

  FXL_DISALLOW_COPY_ASSIGN_AND_MOVE(ActivityProviderConnection);
};

}  // namespace activity

#endif  // SRC_SYS_ACTIVITY_ACTIVITY_PROVIDER_CONNECTION_H_