mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-15 15:16:12 -04:00
226 lines
8.0 KiB
C++
226 lines
8.0 KiB
C++
// Copyright 2021 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#ifndef CORE_INTERNAL_OFFLINE_SIMULATION_USER_H_
|
|
#define CORE_INTERNAL_OFFLINE_SIMULATION_USER_H_
|
|
|
|
#include <string>
|
|
|
|
#include "gtest/gtest.h"
|
|
#include "absl/functional/any_invocable.h"
|
|
#include "absl/strings/string_view.h"
|
|
#include "connections/implementation/bwu_manager.h"
|
|
#include "connections/implementation/client_proxy.h"
|
|
#include "connections/implementation/offline_service_controller.h"
|
|
#include "internal/interop/device.h"
|
|
#include "internal/platform/atomic_boolean.h"
|
|
#include "internal/platform/condition_variable.h"
|
|
#include "internal/platform/count_down_latch.h"
|
|
#include "internal/platform/future.h"
|
|
|
|
// Test-only class to help run end-to-end simulations for nearby connections
|
|
// protocol.
|
|
//
|
|
// This is a "standalone" version of PcpManager. It can run independently,
|
|
// provided MediumEnvironment has adequate support for all medium types in use.
|
|
|
|
namespace nearby {
|
|
namespace connections {
|
|
|
|
class OfflineSimulationUser {
|
|
public:
|
|
struct DiscoveredInfo {
|
|
std::string endpoint_id;
|
|
ByteArray endpoint_info;
|
|
std::string service_id;
|
|
|
|
bool Empty() const { return endpoint_id.empty(); }
|
|
void Clear() { endpoint_id.clear(); }
|
|
};
|
|
|
|
explicit OfflineSimulationUser(
|
|
absl::string_view device_name,
|
|
BooleanMediumSelector allowed = BooleanMediumSelector())
|
|
: info_{ByteArray{std::string(device_name)}},
|
|
advertising_options_{
|
|
{
|
|
Strategy::kP2pCluster,
|
|
allowed,
|
|
},
|
|
},
|
|
connection_options_{
|
|
.keep_alive_interval_millis = FeatureFlags::GetInstance()
|
|
.GetFlags()
|
|
.keep_alive_interval_millis,
|
|
.keep_alive_timeout_millis = FeatureFlags::GetInstance()
|
|
.GetFlags()
|
|
.keep_alive_timeout_millis,
|
|
},
|
|
discovery_options_{{
|
|
Strategy::kP2pCluster,
|
|
allowed,
|
|
}},
|
|
ctrl_(BwuManager::Config()) {}
|
|
virtual ~OfflineSimulationUser() = default;
|
|
|
|
// Calls PcpManager::StartAdvertising().
|
|
// If latch is provided, will call latch->CountDown() in the initiated_cb
|
|
// callback.
|
|
Status StartAdvertising(const std::string& service_id, CountDownLatch* latch);
|
|
|
|
// Calls PcpManager::StopAdvertising().
|
|
void StopAdvertising();
|
|
|
|
// Calls PcpManager::UpdateAdvertisingOptions().
|
|
Status UpdateAdvertisingOptions(absl::string_view service_id,
|
|
const AdvertisingOptions& options);
|
|
|
|
// Calls PcpManager::StartDiscovery().
|
|
// If found_latch is provided, will call found_latch->CountDown() in the
|
|
// endpoint_found_cb callback.
|
|
// If lost_latch is provided, will call lost_latch->CountDown() in the
|
|
// endpoint_lost_cb callback.
|
|
Status StartDiscovery(const std::string& service_id,
|
|
CountDownLatch* found_latch,
|
|
CountDownLatch* lost_latch = nullptr);
|
|
|
|
// Calls PcpManager::StopDiscovery().
|
|
void StopDiscovery();
|
|
|
|
// Calls PcpManager::UpdateDiscoveryOptions().
|
|
Status UpdateDiscoveryOptions(absl::string_view service_id,
|
|
const DiscoveryOptions& options);
|
|
|
|
// Calls PcpManager::InjectEndpoint();
|
|
void InjectEndpoint(const std::string& service_id,
|
|
const OutOfBandConnectionMetadata& metadata);
|
|
|
|
// Calls PcpManager::RequestConnection().
|
|
// If latch is provided, latch->CountDown() will be called in the initiated_cb
|
|
// callback.
|
|
Status RequestConnection(CountDownLatch* latch);
|
|
|
|
// Calls PcpManager::RequestConnectionV3.
|
|
// If latch is provided, latch->CountDown() will be called in the initiated_cb
|
|
// callback.
|
|
Status RequestConnectionV3(CountDownLatch* latch,
|
|
const NearbyDevice& remote_device);
|
|
|
|
// Calls PcpManager::AcceptConnection.
|
|
// If latch is provided, latch->CountDown() will be called in the accepted_cb
|
|
// callback.
|
|
Status AcceptConnection(CountDownLatch* latch);
|
|
|
|
// Calls PcpManager::RejectConnection.
|
|
// If latch is provided, latch->CountDown() will be called in the rejected_cb
|
|
// callback.
|
|
Status RejectConnection(CountDownLatch* latch);
|
|
|
|
// Unlike acceptance, rejection does not have to be mutual, in order to work.
|
|
// This method will allow to synchronize on the remote rejection, without
|
|
// performing a local rejection.
|
|
// latch.CountDown() will be called in the rejected_cb callback.
|
|
void ExpectRejectedConnection(CountDownLatch& latch) {
|
|
reject_latch_ = &latch;
|
|
}
|
|
|
|
void ExpectPayload(CountDownLatch& latch) { payload_latch_ = &latch; }
|
|
void ExpectDisconnect(CountDownLatch& latch) { disconnect_latch_ = &latch; }
|
|
|
|
const DiscoveredInfo& GetDiscovered() const { return discovered_; }
|
|
ByteArray GetInfo() const { return info_; }
|
|
|
|
bool WaitForProgress(
|
|
absl::AnyInvocable<bool(const PayloadProgressInfo&)> pred,
|
|
absl::Duration timeout);
|
|
|
|
Payload& GetPayload() { return payload_; }
|
|
void SendPayload(Payload payload) {
|
|
sender_payload_id_ = payload.GetId();
|
|
ctrl_.SendPayload(&client_, {discovered_.endpoint_id}, std::move(payload));
|
|
}
|
|
|
|
Status CancelPayload() {
|
|
if (sender_payload_id_) {
|
|
return ctrl_.CancelPayload(&client_, sender_payload_id_);
|
|
} else {
|
|
return ctrl_.CancelPayload(&client_, payload_.GetId());
|
|
}
|
|
}
|
|
|
|
void Disconnect();
|
|
|
|
bool IsAdvertising() const { return client_.IsAdvertising(); }
|
|
|
|
bool IsDiscovering() const { return client_.IsDiscovering(); }
|
|
|
|
bool IsConnected() const {
|
|
return client_.IsConnectedToEndpoint(discovered_.endpoint_id);
|
|
}
|
|
|
|
void Stop() {
|
|
StopAdvertising();
|
|
StopDiscovery();
|
|
ctrl_.Stop();
|
|
}
|
|
|
|
protected:
|
|
// ConnectionListener callbacks
|
|
void OnConnectionInitiated(const std::string& endpoint_id,
|
|
const ConnectionResponseInfo& info,
|
|
bool is_outgoing);
|
|
void OnConnectionAccepted(const std::string& endpoint_id);
|
|
void OnConnectionRejected(const std::string& endpoint_id, Status status);
|
|
void OnEndpointDisconnect(const std::string& endpoint_id);
|
|
|
|
// DiscoveryListener callbacks
|
|
void OnEndpointFound(const std::string& endpoint_id,
|
|
const ByteArray& endpoint_info,
|
|
const std::string& service_id);
|
|
void OnEndpointLost(const std::string& endpoint_id);
|
|
|
|
// PayloadListener callbacks
|
|
void OnPayload(absl::string_view endpoint_id, Payload payload);
|
|
void OnPayloadProgress(absl::string_view endpoint_id,
|
|
const PayloadProgressInfo& info);
|
|
|
|
std::string service_id_;
|
|
DiscoveredInfo discovered_;
|
|
ByteArray info_;
|
|
AdvertisingOptions advertising_options_;
|
|
ConnectionOptions connection_options_;
|
|
DiscoveryOptions discovery_options_;
|
|
Mutex progress_mutex_;
|
|
ConditionVariable progress_sync_{&progress_mutex_};
|
|
PayloadProgressInfo progress_info_;
|
|
Payload payload_;
|
|
Payload::Id sender_payload_id_ = 0;
|
|
CountDownLatch* initiated_latch_ = nullptr;
|
|
CountDownLatch* accept_latch_ = nullptr;
|
|
CountDownLatch* reject_latch_ = nullptr;
|
|
CountDownLatch* found_latch_ = nullptr;
|
|
CountDownLatch* lost_latch_ = nullptr;
|
|
CountDownLatch* payload_latch_ = nullptr;
|
|
CountDownLatch* disconnect_latch_ = nullptr;
|
|
Future<bool>* future_ = nullptr;
|
|
absl::AnyInvocable<bool(const PayloadProgressInfo&)> predicate_;
|
|
ClientProxy client_;
|
|
OfflineServiceController ctrl_;
|
|
};
|
|
|
|
} // namespace connections
|
|
} // namespace nearby
|
|
|
|
#endif // CORE_INTERNAL_OFFLINE_SIMULATION_USER_H_
|