src/connectivity/bluetooth/core/bt-host/sm/fake_phase_listener.h

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

#ifndef SRC_CONNECTIVITY_BLUETOOTH_CORE_BT_HOST_SM_FAKE_PHASE_LISTENER_H_
#define SRC_CONNECTIVITY_BLUETOOTH_CORE_BT_HOST_SM_FAKE_PHASE_LISTENER_H_

#include <gtest/gtest.h>

#include "src/connectivity/bluetooth/core/bt-host/sm/pairing_phase.h"
#include "src/lib/fxl/memory/weak_ptr.h"

namespace bt {
namespace sm {

class FakeListener : public PairingPhase::Listener {
 public:
  FakeListener() : weak_ptr_factory_(this) {}
  ~FakeListener() override = default;

  // PairingPhase::Listener override:
  std::optional<IdentityInfo> OnIdentityRequest() override {
    identity_info_count_++;
    return identity_info_;
  }

  // PairingPhase::Listener override. Confirms pairing even without a delegate present so that the
  // simplest pairing flows (JustWorks) work with minimal configuration.
  void ConfirmPairing(ConfirmCallback confirm) override {
    if (confirm_delegate_) {
      confirm_delegate_(std::move(confirm));
    } else {
      confirm(true);
    }
  }

  // PairingPhase::Listener override:
  void DisplayPasskey(uint32_t passkey, bool is_numeric_comparison,
                      ConfirmCallback confirm) override {
    if (display_delegate_) {
      display_delegate_(passkey, is_numeric_comparison, std::move(confirm));
    } else {
      ADD_FAILURE() << "No passkey display delegate set for pairing";
    }
  }

  // PairingPhase::Listener override:
  void RequestPasskey(PasskeyResponseCallback respond) override {
    if (request_passkey_delegate_) {
      request_passkey_delegate_(std::move(respond));
    } else {
      ADD_FAILURE() << "No passkey entry delegate set for passkey entry pairing";
    }
  }
  // PairingPhase::Listener override:
  void OnNewLongTermKey(const LTK& ltk) override {
    ltk_count_++;
    ltk_ = ltk;
  }

  // PairingPhase::Listener override:
  void OnPairingFailed(Status error) override {
    pairing_error_count_++;
    last_error_ = error;
  }

  fxl::WeakPtr<PairingPhase::Listener> as_weak_ptr() { return weak_ptr_factory_.GetWeakPtr(); }

  void set_identity_info(std::optional<IdentityInfo> value) { identity_info_ = value; }
  int identity_info_count() const { return identity_info_count_; }

  using ConfirmDelegate = fit::function<void(ConfirmCallback)>;
  void set_confirm_delegate(ConfirmDelegate delegate) { confirm_delegate_ = std::move(delegate); }

  using DisplayDelegate = fit::function<void(uint32_t, bool, ConfirmCallback)>;
  void set_display_delegate(DisplayDelegate delegate) { display_delegate_ = std::move(delegate); }

  // sm::Delegate override:
  using RequestPasskeyDelegate = fit::function<void(PasskeyResponseCallback)>;
  void set_request_passkey_delegate(RequestPasskeyDelegate delegate) {
    request_passkey_delegate_ = std::move(delegate);
  }

  int pairing_error_count() const { return pairing_error_count_; }
  Status last_error() const { return last_error_; }

  int ltk_count() const { return ltk_count_; }
  const LTK& ltk() const { return ltk_; }

 private:
  std::optional<IdentityInfo> identity_info_ = std::nullopt;
  int identity_info_count_ = 0;

  // Delegate functions used to respond to user input requests from the pairing state.
  ConfirmDelegate confirm_delegate_;
  DisplayDelegate display_delegate_;
  RequestPasskeyDelegate request_passkey_delegate_;

  int ltk_count_ = 0;
  LTK ltk_;

  int pairing_error_count_ = 0;
  Status last_error_;

  fxl::WeakPtrFactory<FakeListener> weak_ptr_factory_;
};

}  // namespace sm
}  // namespace bt

#endif  // SRC_CONNECTIVITY_BLUETOOTH_CORE_BT_HOST_SM_FAKE_PHASE_LISTENER_H_