// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef CHROMEOS_ASH_COMPONENTS_DBUS_CICERONE_CICERONE_CLIENT_H_
#define CHROMEOS_ASH_COMPONENTS_DBUS_CICERONE_CICERONE_CLIENT_H_

#include "base/component_export.h"
#include "chromeos/ash/components/dbus/cicerone/cicerone_service.pb.h"
#include "chromeos/dbus/common/dbus_callback.h"
#include "chromeos/dbus/common/dbus_client.h"
#include "dbus/object_proxy.h"

namespace ash {

// CiceroneClient is used to communicate with Cicerone, which is used to
// communicate with containers running inside VMs.
class COMPONENT_EXPORT(CICERONE) CiceroneClient : public chromeos::DBusClient {
 public:
  class Observer {
   public:
    // Called when Cicerone service exits.
    virtual void CiceroneServiceStopped() {}

    // Called when Cicerone service is either started or restarted.
    virtual void CiceroneServiceStarted() {}

    // OnContainerStarted is signaled by Cicerone after the long-running Lxd
    // container startup process has been completed and the container is ready.
    virtual void OnContainerStarted(
        const vm_tools::cicerone::ContainerStartedSignal& signal) {}

    // OnContainerShutdown is signaled by Cicerone when a container is shutdown.
    virtual void OnContainerShutdown(
        const vm_tools::cicerone::ContainerShutdownSignal& signal) {}

    // This is signaled from the container while a package is being installed
    // via InstallLinuxPackage.
    virtual void OnInstallLinuxPackageProgress(
        const vm_tools::cicerone::InstallLinuxPackageProgressSignal& signal) {}

    // This is signaled from the container while a package is being uninstalled
    // via UninstallPackageOwningFile.
    virtual void OnUninstallPackageProgress(
        const vm_tools::cicerone::UninstallPackageProgressSignal& signal) {}

    // OnLxdContainerCreated is signaled from Cicerone when the long running
    // creation of an Lxd container is complete.
    virtual void OnLxdContainerCreated(
        const vm_tools::cicerone::LxdContainerCreatedSignal& signal) {}

    // OnLxdContainerDeleted is signaled from Cicerone when the long running
    // deletion of an Lxd container is complete.
    virtual void OnLxdContainerDeleted(
        const vm_tools::cicerone::LxdContainerDeletedSignal& signal) {}

    // OnLxdContainerDownloading is signaled from Cicerone giving download
    // progress on the container.
    virtual void OnLxdContainerDownloading(
        const vm_tools::cicerone::LxdContainerDownloadingSignal& signal) {}

    // OnTremplinStarted is signaled from Cicerone when Tremplin gRPC service is
    // first connected in a VM. This service is required for CreateLxdContainer
    // and StartLxdContainer.
    virtual void OnTremplinStarted(
        const vm_tools::cicerone::TremplinStartedSignal& signal) {}

    // OnLxdContainerStarting is signaled from Cicerone when async container
    // startup is used. This is necessary if long running file remapping is
    // required before an old container is safe to use.
    virtual void OnLxdContainerStarting(
        const vm_tools::cicerone::LxdContainerStartingSignal& signal) {}

    // OnExportLxdContainerProgress is signalled from Cicerone while a container
    // is being exported via ExportLxdContainer.
    virtual void OnExportLxdContainerProgress(
        const vm_tools::cicerone::ExportLxdContainerProgressSignal& signal) {}

    // OnImportLxdContainerProgress is signalled from Cicerone while a container
    // is being imported via ImportLxdContainer.
    virtual void OnImportLxdContainerProgress(
        const vm_tools::cicerone::ImportLxdContainerProgressSignal& signal) {}

    // OnPendingAppListUpdates is signalled from Cicerone when the number of
    // pending app list updates changes.
    virtual void OnPendingAppListUpdates(
        const vm_tools::cicerone::PendingAppListUpdatesSignal& signal) {}

    // This is signaled from the container while a playbook is being applied
    // via ApplyAnsiblePlaybook.
    virtual void OnApplyAnsiblePlaybookProgress(
        const vm_tools::cicerone::ApplyAnsiblePlaybookProgressSignal& signal) {}

    // This is signaled from Cicerone while a container is being upgraded
    // via UpgradeContainer.
    virtual void OnUpgradeContainerProgress(
        const vm_tools::cicerone::UpgradeContainerProgressSignal& signal) {}

    // This is signaled from Cicerone while LXD is starting via StartLxd.
    virtual void OnStartLxdProgress(
        const vm_tools::cicerone::StartLxdProgressSignal& signal) {}

    // This is signaled from Cicerone when a file in a watched directory is
    // changed.  It is used by FilesApp.
    virtual void OnFileWatchTriggered(
        const vm_tools::cicerone::FileWatchTriggeredSignal& signal) {}

    // This is signaled from Cicerone when a container runs into low disk space.
    virtual void OnLowDiskSpaceTriggered(
        const vm_tools::cicerone::LowDiskSpaceTriggeredSignal& signal) {}

    // This is signaled from Cicerone when the VM is requesting to inhibit
    // sleep.
    virtual void OnInhibitScreensaver(
        const vm_tools::cicerone::InhibitScreensaverSignal& signal) {}

    // This is signaled from Cicerone when the VM is requesting to uninhibit
    // sleep.
    virtual void OnUninhibitScreensaver(
        const vm_tools::cicerone::UninhibitScreensaverSignal& signal) {}

   protected:
    virtual ~Observer() = default;
  };

  CiceroneClient(const CiceroneClient&) = delete;
  CiceroneClient& operator=(const CiceroneClient&) = delete;

  ~CiceroneClient() override;

  // Adds an observer.
  virtual void AddObserver(Observer* observer) = 0;

  // Removes an observer if added.
  virtual void RemoveObserver(Observer* observer) = 0;

  // IsContainerStartedSignalConnected must return true before StartLxdContainer
  // is called.
  virtual bool IsContainerStartedSignalConnected() = 0;

  // IsContainerShutdownSignalConnected must return true before
  // StartLxdContainer is called.
  virtual bool IsContainerShutdownSignalConnected() = 0;

  // This should be true prior to calling InstallLinuxPackage.
  virtual bool IsInstallLinuxPackageProgressSignalConnected() = 0;

  // This should be true prior to calling UninstallPackageOwningFile.
  virtual bool IsUninstallPackageProgressSignalConnected() = 0;

  // This should be true prior to calling CreateLxdContainer or
  // StartLxdContainer.
  virtual bool IsLxdContainerCreatedSignalConnected() = 0;

  // This should be true prior to calling DeleteLxdContainer.
  virtual bool IsLxdContainerDeletedSignalConnected() = 0;

  // This should be true prior to calling CreateLxdContainer or
  // StartLxdContainer.
  virtual bool IsLxdContainerDownloadingSignalConnected() = 0;

  // This should be true prior to calling CreateLxdContainer or
  // StartLxdContainer.
  virtual bool IsTremplinStartedSignalConnected() = 0;

  // This should be true prior to calling StartLxdContainer in async mode.
  virtual bool IsLxdContainerStartingSignalConnected() = 0;

  // This should be true prior to calling ExportLxdContainer.
  virtual bool IsExportLxdContainerProgressSignalConnected() = 0;

  // This should be true prior to calling ImportLxdContainer.
  virtual bool IsImportLxdContainerProgressSignalConnected() = 0;

  // This should be true before expecting to receive
  // PendingAppListUpdatesSignal.
  virtual bool IsPendingAppListUpdatesSignalConnected() = 0;

  // This should be true prior to calling ApplyAnsiblePlaybook.
  virtual bool IsApplyAnsiblePlaybookProgressSignalConnected() = 0;

  // This should be true prior to calling UpgradeContainer.
  virtual bool IsUpgradeContainerProgressSignalConnected() = 0;

  // This should be true prior to calling StartLxd.
  virtual bool IsStartLxdProgressSignalConnected() = 0;

  // This should be true prior to calling AddFileWatch.
  virtual bool IsFileWatchTriggeredSignalConnected() = 0;

  // This should be true before expecting to receive
  // LowDiskSpaceTriggeredSignal.
  virtual bool IsLowDiskSpaceTriggeredSignalConnected() = 0;

  // This should be true before expecting to receive
  // InhibitScreensaverSignal
  virtual bool IsInhibitScreensaverSignalConencted() = 0;

  // This should be true before expecting to receive
  // UninhibitScreensaverSignal.
  virtual bool IsUninhibitScreensaverSignalConencted() = 0;

  // Launches an application inside a running Container.
  // |callback| is called after the method call finishes.
  virtual void LaunchContainerApplication(
      const vm_tools::cicerone::LaunchContainerApplicationRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::LaunchContainerApplicationResponse> callback) = 0;

  // Gets application icons from inside a Container.
  // |callback| is called after the method call finishes.
  virtual void GetContainerAppIcons(
      const vm_tools::cicerone::ContainerAppIconRequest& request,
      chromeos::DBusMethodCallback<vm_tools::cicerone::ContainerAppIconResponse>
          callback) = 0;

  // Gets information about a Linux package file inside a container.
  // |callback| is called after the method call finishes.
  virtual void GetLinuxPackageInfo(
      const vm_tools::cicerone::LinuxPackageInfoRequest& request,
      chromeos::DBusMethodCallback<vm_tools::cicerone::LinuxPackageInfoResponse>
          callback) = 0;

  // Installs a package inside the container.
  // |callback| is called after the method call finishes.
  virtual void InstallLinuxPackage(
      const vm_tools::cicerone::InstallLinuxPackageRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::InstallLinuxPackageResponse> callback) = 0;

  // Uninstalls the package that owns the indicated .desktop file.
  // |callback| is called after the method call finishes.
  virtual void UninstallPackageOwningFile(
      const vm_tools::cicerone::UninstallPackageOwningFileRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::UninstallPackageOwningFileResponse> callback) = 0;

  // Creates a new Lxd Container.
  // |callback| is called to indicate creation status.
  // |Observer::OnLxdContainerCreated| will be called on completion.
  // |Observer::OnLxdContainerDownloading| is called to indicate progress.
  virtual void CreateLxdContainer(
      const vm_tools::cicerone::CreateLxdContainerRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::CreateLxdContainerResponse> callback) = 0;

  // Deletes an Lxd Container.
  // |callback| is called to indicate deletion status.
  // |Observer::OnLxdContainerDeleted| will be called on completion.
  virtual void DeleteLxdContainer(
      const vm_tools::cicerone::DeleteLxdContainerRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::DeleteLxdContainerResponse> callback) = 0;

  // Starts a new Lxd Container.
  // |callback| is called when the method completes.
  virtual void StartLxdContainer(
      const vm_tools::cicerone::StartLxdContainerRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::StartLxdContainerResponse> callback) = 0;

  // Stops a running Lxd Container.
  // |callback| is called when the method completes.
  virtual void StopLxdContainer(
      const vm_tools::cicerone::StopLxdContainerRequest& request,
      chromeos::DBusMethodCallback<vm_tools::cicerone::StopLxdContainerResponse>
          callback) = 0;

  // Gets the Lxd container username.
  // |callback| is called when the method completes.
  virtual void GetLxdContainerUsername(
      const vm_tools::cicerone::GetLxdContainerUsernameRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::GetLxdContainerUsernameResponse> callback) = 0;

  // Sets the Lxd container user, creating it if needed.
  // |callback| is called when the method completes.
  virtual void SetUpLxdContainerUser(
      const vm_tools::cicerone::SetUpLxdContainerUserRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::SetUpLxdContainerUserResponse> callback) = 0;

  // Exports the Lxd container.
  // |callback| is called when the method completes.
  virtual void ExportLxdContainer(
      const vm_tools::cicerone::ExportLxdContainerRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::ExportLxdContainerResponse> callback) = 0;

  // Imports the Lxd container.
  // |callback| is called when the method completes.
  virtual void ImportLxdContainer(
      const vm_tools::cicerone::ImportLxdContainerRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::ImportLxdContainerResponse> callback) = 0;

  // Cancels the in progress Lxd container export.
  // |callback| is called when the method completes.
  virtual void CancelExportLxdContainer(
      const vm_tools::cicerone::CancelExportLxdContainerRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::CancelExportLxdContainerResponse> callback) = 0;

  // Cancels the in progress Lxd container import.
  // |callback| is called when the method completes.
  virtual void CancelImportLxdContainer(
      const vm_tools::cicerone::CancelImportLxdContainerRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::CancelImportLxdContainerResponse> callback) = 0;

  // Applies Ansible playbook.
  // |callback| is called after the method call finishes.
  virtual void ApplyAnsiblePlaybook(
      const vm_tools::cicerone::ApplyAnsiblePlaybookRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::ApplyAnsiblePlaybookResponse> callback) = 0;

  // Configure the container to allow sideloading Android apps into Arc.
  // |callback| is called once configuration finishes.
  virtual void ConfigureForArcSideload(
      const vm_tools::cicerone::ConfigureForArcSideloadRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::ConfigureForArcSideloadResponse> callback) = 0;

  // Upgrades the container.
  // |callback| is called when the method completes.
  virtual void UpgradeContainer(
      const vm_tools::cicerone::UpgradeContainerRequest& request,
      chromeos::DBusMethodCallback<vm_tools::cicerone::UpgradeContainerResponse>
          callback) = 0;

  // Cancels the in progress container upgrade.
  // |callback| is called when the method completes.
  virtual void CancelUpgradeContainer(
      const vm_tools::cicerone::CancelUpgradeContainerRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::CancelUpgradeContainerResponse> callback) = 0;

  // Starts LXD.
  // |callback| is called when the method completes.
  virtual void StartLxd(
      const vm_tools::cicerone::StartLxdRequest& request,
      chromeos::DBusMethodCallback<vm_tools::cicerone::StartLxdResponse>
          callback) = 0;

  // Adds a file watcher.  Used by FilesApp.
  // |callback| is called when the method completes.
  virtual void AddFileWatch(
      const vm_tools::cicerone::AddFileWatchRequest& request,
      chromeos::DBusMethodCallback<vm_tools::cicerone::AddFileWatchResponse>
          callback) = 0;

  // Removes a file watch.
  // |callback| is called when the method completes.
  virtual void RemoveFileWatch(
      const vm_tools::cicerone::RemoveFileWatchRequest& request,
      chromeos::DBusMethodCallback<vm_tools::cicerone::RemoveFileWatchResponse>
          callback) = 0;

  // Looks up vsh session data such as container shell pid.
  // |callback| is called when the method completes.
  virtual void GetVshSession(
      const vm_tools::cicerone::GetVshSessionRequest& request,
      chromeos::DBusMethodCallback<vm_tools::cicerone::GetVshSessionResponse>
          callback) = 0;

  // Attaches a USB device to a LXD container.
  // |callback| is called when the method completes.
  virtual void AttachUsbToContainer(
      const vm_tools::cicerone::AttachUsbToContainerRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::AttachUsbToContainerResponse> callback) = 0;

  // Detaches a USB device from a LXD container.
  // |callback| is called when the method completes.
  virtual void DetachUsbFromContainer(
      const vm_tools::cicerone::DetachUsbFromContainerRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::DetachUsbFromContainerResponse> callback) = 0;

  // Send signal with files user has selected in SelectFile dialog. This is sent
  // in response to VmApplicationsServiceProvider::SelectFile().
  virtual void FileSelected(
      const vm_tools::cicerone::FileSelectedSignal& signal) = 0;

  // Lists the containers Cicerone knows about.
  // |callback| is called when the method completes.
  virtual void ListRunningContainers(
      const vm_tools::cicerone::ListRunningContainersRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::ListRunningContainersResponse> callback) = 0;

  // Queries Garcon for info about the current session.
  // |callback| is called when the method completes.
  virtual void GetGarconSessionInfo(
      const vm_tools::cicerone::GetGarconSessionInfoRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::GetGarconSessionInfoResponse> callback) = 0;

  // Updates the VM devices available for a LXD container.
  // |callback| is called when the method completes.
  virtual void UpdateContainerDevices(
      const vm_tools::cicerone::UpdateContainerDevicesRequest& request,
      chromeos::DBusMethodCallback<
          vm_tools::cicerone::UpdateContainerDevicesResponse> callback) = 0;

  // Registers |callback| to run when the Cicerone service becomes available.
  // If the service is already available, or if connecting to the name-owner-
  // changed signal fails, |callback| will be run once asynchronously.
  // Otherwise, |callback| will be run once in the future after the service
  // becomes available.
  virtual void WaitForServiceToBeAvailable(
      dbus::ObjectProxy::WaitForServiceToBeAvailableCallback callback) = 0;

  // Creates and initializes the global instance. |bus| must not be null.
  static void Initialize(dbus::Bus* bus);

  // Creates and initializes a fake global instance if not already created.
  static void InitializeFake();

  // Destroys the global instance if it has been initialized.
  static void Shutdown();

  // Returns the global instance if initialized. May return null.
  static CiceroneClient* Get();

 protected:
  // Initialize() should be used instead.
  CiceroneClient();
};

}  // namespace ash

#endif  // CHROMEOS_ASH_COMPONENTS_DBUS_CICERONE_CICERONE_CLIENT_H_