client_state.h

Go to the documentation of this file.

 
#pragma once
 
// standard includes
#include <cstddef>
#include <string>
#include <vector>
 
// nxdk includes
#include <hal/video.h>
 
// standard includes
#include "src/app/host_records.h"
#include "src/app/pairing_flow.h"
#include "src/input/navigation_input.h"
#include "src/logging/logger.h"
#include "src/startup/saved_files.h"
#include "src/ui/menu_model.h"
 
namespace app {
 
  enum class ScreenId {
    home,  
    hosts,  
    apps,  
    add_host,  
    pair_host,  
    settings,  
  };
 
  enum class HostsFocusArea {
    toolbar,  
    grid,  
  };
 
  enum class ModalId {
    none,  
    support,  
    host_actions,  
    host_details,  
    app_actions,  
    app_details,  
    confirmation,  
    log_viewer,  
  };
 
  enum class LogViewerPlacement {
    full,  
    left,  
    right,  
  };
 
  enum class SettingsFocusArea {
    categories,  
    options,  
  };
 
  enum class SettingsCategory {
    logging,  
    display,  
    input,  
    reset,  
  };
 
  enum class ConfirmationAction {
    none,  
    delete_saved_file,  
    factory_reset,  
  };
 
  enum class AddHostField {
    address,  
    port,  
  };
 
  struct AddHostKeypadState {
    bool visible;  
    std::size_t selectedButtonIndex;  
    std::string stagedInput;  
  };
 
  struct AddHostDraft {
    std::string addressInput;  
    std::string portInput;  
    AddHostField activeField;  
    AddHostKeypadState keypad;  
    ScreenId returnScreen;  
    std::string validationMessage;  
    std::string connectionMessage;  
    bool lastConnectionSucceeded;  
  };
 
  struct ModalState {
    ModalId id = ModalId::none;  
    std::size_t selectedActionIndex = 0;  
 
    bool active() const {
      return id != ModalId::none;
    }
  };
 
  struct ConfirmationDialogState {
    ConfirmationAction action = ConfirmationAction::none;  
    std::string targetPath;  
    std::string title;  
    std::vector<std::string> lines;  
  };
 
  struct ShellState {
    ScreenId activeScreen = ScreenId::hosts;  
    bool overlayVisible = false;  
    bool shouldExit = false;  
    std::size_t overlayScrollOffset = 0U;  
    std::string statusMessage;  
  };
 
  struct HostsState {
    bool dirty = false;  
    bool loaded = false;  
    HostsFocusArea focusArea = HostsFocusArea::toolbar;  
    std::size_t selectedToolbarButtonIndex = 0U;  
    std::size_t selectedHostIndex = 0U;  
    std::vector<HostRecord> items;  
    HostRecord active;  
    bool activeLoaded = false;  
    std::string selectedAddress;  
    uint16_t selectedPort = 0;  
    std::vector<std::string> pairingResetEndpoints;  
 
    bool empty() const {
      return items.empty();
    }
 
    std::size_t size() const {
      return items.size();
    }
 
    auto begin() {
      return items.begin();
    }
 
    auto end() {
      return items.end();
    }
 
    auto begin() const {
      return items.begin();
    }
 
    auto end() const {
      return items.end();
    }
 
    void clear() {
      items.clear();
    }
 
    HostRecord &front() {
      return items.front();
    }
 
    const HostRecord &front() const {
      return items.front();
    }
 
    HostRecord &back() {
      return items.back();
    }
 
    const HostRecord &back() const {
      return items.back();
    }
 
    HostRecord &operator[](std::size_t index) {
      return items[index];
    }
 
    const HostRecord &operator[](std::size_t index) const {
      return items[index];
    }
  };
 
  struct AppsState {
    std::size_t selectedAppIndex = 0U;  
    std::size_t scrollPage = 0U;  
    bool showHiddenApps = false;  
  };
 
  struct SettingsState {
    SettingsFocusArea focusArea = SettingsFocusArea::categories;  
    SettingsCategory selectedCategory = SettingsCategory::logging;  
    std::string logFilePath;  
    std::vector<std::string> logViewerLines;  
    std::size_t logViewerScrollOffset = 0U;  
    LogViewerPlacement logViewerPlacement = LogViewerPlacement::full;  
    logging::LogLevel loggingLevel = logging::LogLevel::none;  
    logging::LogLevel xemuConsoleLoggingLevel = logging::LogLevel::none;  
    std::vector<VIDEO_MODE> availableVideoModes;  
    VIDEO_MODE preferredVideoMode {};  
    bool preferredVideoModeSet = false;  
    int streamFramerate = 30;  
    int streamBitrateKbps = 1000;  
    bool playAudioOnPc = false;  
    bool showPerformanceStats = false;  
    bool playAudioOnXbox = true;  
    bool dirty = false;  
    std::vector<startup::SavedFileEntry> savedFiles;  
    bool savedFilesDirty = true;  
  };
 
  struct ClientState {
    ShellState shell;  
    HostsState hosts;  
    AppsState apps;  
    ui::MenuModel menu;  
    ui::MenuModel detailMenu;  
    AddHostDraft addHostDraft;  
    PairingDraft pairingDraft;  
    ModalState modal;  
    SettingsState settings;  
    ConfirmationDialogState confirmation;  
  };
 
  struct AppNavigationUpdate {
    bool screenChanged = false;  
    bool overlayChanged = false;  
    bool overlayVisibilityChanged = false;  
    bool exitRequested = false;  
    bool modalOpened = false;  
    bool modalClosed = false;  
    std::string activatedItemId;  
  };
 
  struct AppRequestUpdate {
    bool connectionTestRequested = false;  
    std::string connectionTestAddress;  
    uint16_t connectionTestPort = 0;  
    bool pairingRequested = false;  
    bool pairingCancelledRequested = false;  
    std::string pairingAddress;  
    uint16_t pairingPort = 0;  
    std::string pairingPin;  
    bool appsBrowseRequested = false;  
    bool appsBrowseShowHidden = false;  
    bool streamLaunchRequested = false;  
    bool logViewRequested = false;  
  };
 
  struct AppPersistenceUpdate {
    bool hostsChanged = false;  
    bool settingsChanged = false;  
    bool savedFileDeleteRequested = false;  
    std::string savedFileDeletePath;  
    bool factoryResetRequested = false;  
    bool hostDeleteCleanupRequested = false;  
    bool deletedHostWasPaired = false;  
    std::string deletedHostAddress;  
    uint16_t deletedHostPort = 0;  
    std::vector<std::string> deletedHostCoverArtCacheKeys;  
  };
 
  struct AppUpdate {
    AppNavigationUpdate navigation;  
    AppRequestUpdate requests;  
    AppPersistenceUpdate persistence;  
  };
 
  ClientState create_initial_state();
 
  const char *to_string(ScreenId screen);
 
  void replace_hosts(ClientState &state, std::vector<HostRecord> hosts, std::string statusMessage = {});
 
  bool merge_discovered_host(ClientState &state, std::string displayName, const std::string &address, uint16_t port);
 
  void replace_saved_files(ClientState &state, std::vector<startup::SavedFileEntry> savedFiles);
 
  std::string current_add_host_address(const ClientState &state);
 
  uint16_t current_add_host_port(const ClientState &state);
 
  std::string current_pairing_pin(const ClientState &state);
 
  void apply_connection_test_result(ClientState &state, bool success, std::string message);
 
  bool apply_pairing_result(ClientState &state, const std::string &address, uint16_t port, bool success, std::string message);
 
  void apply_app_list_result(
    ClientState &state,
    const std::string &address,
    uint16_t port,
    std::vector<HostAppRecord> apps,
    uint64_t appListContentHash,
    bool success,
    std::string message
  );
 
  void mark_cover_art_cached(ClientState &state, const std::string &address, uint16_t port, int appId);
 
  void set_log_file_path(ClientState &state, std::string logFilePath);
 
  void apply_log_viewer_contents(ClientState &state, std::vector<std::string> lines, std::string statusMessage);
 
  bool host_requires_manual_pairing(const ClientState &state, const std::string &address, uint16_t port);
 
  bool begin_selected_host_app_browse(ClientState &state, bool showHiddenApps);
 
  const HostRecord *selected_host(const ClientState &state);
 
  const HostAppRecord *selected_app(const ClientState &state);
 
  const HostRecord *apps_host(const ClientState &state);
 
  AppUpdate handle_command(ClientState &state, input::UiCommand command);
 
}  // namespace app