// Copyright 2024 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_WIFI_P2P_WIFI_P2P_CONTROLLER_H_
#define CHROMEOS_ASH_COMPONENTS_WIFI_P2P_WIFI_P2P_CONTROLLER_H_
#include "base/check.h"
#include "base/component_export.h"
#include "base/files/scoped_file.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/task/single_thread_task_runner.h"
#include "base/values.h"
#include "chromeos/ash/components/dbus/shill/shill_property_changed_observer.h"
namespace ash {
class WifiP2PGroup;
// Class for handling initialization and access to chromeos wifi_p2p controller.
// Exposes functions for following operations:
// 1. Create a p2p group
// 2. Destroy a p2p group
// 3. Connect to a p2p group
// 4. Disconnect from a p2p group
// 5. Fetch p2p group/client properties
// 6. Tag socket to a WiFi direct group network rules.
class COMPONENT_EXPORT(CHROMEOS_ASH_COMPONENTS_WIFI_P2P) WifiP2PController
: public ShillPropertyChangedObserver {
public:
class Observer : public base::CheckedObserver {
public:
~Observer() override = default;
virtual void OnWifiDirectConnectionDisconnected(const int shill_id,
bool is_owner) = 0;
};
// Sets the global instance. Must be called before any calls to Get().
static void Initialize();
// Destroys the global instance.
static void Shutdown();
// Gets the global instance. Initialize() must be called first.
static WifiP2PController* Get();
// Returns true if the global instance has been initialized.
static bool IsInitialized();
struct WifiP2PCapabilities {
WifiP2PCapabilities(const bool is_owner_ready,
const bool is_client_ready,
const bool is_p2p_supported)
: is_owner_ready(is_owner_ready),
is_client_ready(is_client_ready),
is_p2p_supported(is_p2p_supported) {}
~WifiP2PCapabilities() = default;
// Whether platform is ready for creating p2p GO interface without any
// concurrency conflict.
bool is_owner_ready;
// Whether platform is ready for creating p2p GC interface without any
// concurrency conflict.
bool is_client_ready;
// Whether the device supports p2p operations or not.
bool is_p2p_supported;
};
// Represents the Wifi P2P operation result. Entries should not be renumbered
// and numeric values should never be reused.
enum class OperationResult {
kSuccess = 0,
// Wifi direct is disallowed in platform per Manager.P2PAllowed.
kNotAllowed = 1,
// Wifi direct operation is not supported in the platform.
kNotSupported = 2,
// Creating Wifi direct interface is not possible with existing interfaces.
kConcurrencyNotSupported = 3,
// The requested refruency is not supported.
kFrequencyNotSupported = 4,
// Wifi direct group rejects the authentication attempt.
kAuthFailure = 5,
// Didn't discover the Wifi direct group.
kGroupNotFound = 6,
// Already connected to the Wifi direct group.
kAlreadyConnected = 7,
// Device is not connected to a Wifi direct group.
kNotConnected = 8,
// Wifi direct operation is already in progress.
kOperationInProgress = 9,
// Invalid arguments.
kInvalidArguments = 10,
// Wifi direct operation timed out.
kTimeout = 11,
// Wifi direct operation response has an invalid result code.
kInvalidResultCode = 12,
// Wifi direct group miss or has invalid properties.
kInvalidGroupProperties = 13,
// Wifi direct operation failure.
kOperationFailed = 14,
// Wifi direct operation failed due to DBus error.
kDBusError = 15,
kMaxValue = kDBusError,
};
enum class OperationType {
kCreateGroup,
kConnectGroup,
kDestroyGroup,
kDisconnectGroup,
};
friend std::ostream& operator<<(std::ostream& stream,
const OperationType& type);
// Return callback for the CreateWifiP2PGroup or ConnectToWifiP2PGroup
// methods.
using WifiP2PGroupCallback =
base::OnceCallback<void(OperationResult result,
std::optional<WifiP2PGroup> group_metadata)>;
// SSID and passphrase should be provided or omit at the same time. If both
// SSID and passphrase are provide, it will attempt to create the WiFi P2P
// group with the given `ssid` and `passphrase`. Otherwise, the platform will
// generate the ssid and passphrase.
void CreateWifiP2PGroup(std::optional<std::string> ssid,
std::optional<std::string> passphrase,
WifiP2PGroupCallback callback);
// Destroys the Wifi P2P group using its shill id.
void DestroyWifiP2PGroup(
int shill_id,
base::OnceCallback<void(OperationResult result)> callback);
// Disconnects from the Wifi P2P group.
void DisconnectFromWifiP2PGroup(
int shill_id,
base::OnceCallback<void(OperationResult result)> callback);
// Connect to a Wifi P2P group with given `ssid` and `passphrase`. If
// `frequency` is provided, the operation will fail if no group found at the
// specified frequency. If it is omitted, the system will scan full supported
// channels to find the group.
void ConnectToWifiP2PGroup(const std::string& ssid,
const std::string& passphrase,
std::optional<uint32_t> frequency,
WifiP2PGroupCallback callback);
const WifiP2PCapabilities& GetP2PCapabilities() const;
// Tags the TCP/UDP socket with the given `socket_fd` to the network
// specified by `network_id`. The `socket_fd` should be the duplicate of the
// fd that the caller process actually keeps.
void TagSocket(int network_id,
base::ScopedFD socket_fd,
base::OnceCallback<void(bool success)> callback);
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
private:
WifiP2PController();
WifiP2PController(const WifiP2PController&) = delete;
WifiP2PController& operator=(const WifiP2PController&) = delete;
~WifiP2PController() override;
void Init();
// ShillPropertyChangedObserver overrides
void OnPropertyChanged(const std::string& key,
const base::Value& value) override;
void OnCreateOrConnectP2PGroupSuccess(const OperationType& type,
WifiP2PGroupCallback callback,
base::Value::Dict result);
void OnCreateOrConnectP2PGroupFailure(const OperationType& type,
WifiP2PGroupCallback callback,
const std::string& error_name,
const std::string& error_message);
void OnDestroyOrDisconnectP2PGroupSuccess(
const OperationType& type,
base::OnceCallback<void(OperationResult result)> callback,
base::Value::Dict result);
void OnDestroyOrDisconnectP2PGroupFailure(
const OperationType& type,
base::OnceCallback<void(OperationResult result)> callback,
const std::string& error_name,
const std::string& error_message);
void OnTagSocketCompleted(base::OnceCallback<void(bool success)> callback,
bool success);
void GetP2PGroupMetadata(int shill_id,
const OperationType& type,
WifiP2PGroupCallback callback,
std::optional<base::Value::Dict> properties);
// Callback when set shill manager property operation failed.
void OnSetManagerPropertyFailure(const std::string& property_name,
const std::string& error_name,
const std::string& error_message);
void OnGetManagerProperties(std::optional<base::Value::Dict> properties);
void UpdateP2PCapabilities(const base::Value::Dict& capabilities);
void CompleteWifiP2PGroupCallback(const OperationType& type,
const OperationResult& result,
WifiP2PGroupCallback callback,
std::optional<WifiP2PGroup> group_metadata);
void CheckAndNotifyDisconnection(bool is_owner,
const base::Value& property_list,
const std::string& interface_state_property,
const std::string& shill_id_property,
const std::string& idle_state_property);
base::ObserverList<Observer> observer_list_;
WifiP2PCapabilities wifi_p2p_capabilities_{false, false, false};
base::WeakPtrFactory<WifiP2PController> weak_ptr_factory_{this};
};
} // namespace ash
#endif // CHROMEOS_ASH_COMPONENTS_WIFI_P2P_WIFI_P2P_CONTROLLER_H_
Codebase Browser
chromium