1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #ifndef P2P_ENTITY_H 16 #define P2P_ENTITY_H 17 18 #include <memory> 19 #include <mutex> 20 #include <queue> 21 #include <string> 22 #include <vector> 23 24 #include "conn_log.h" 25 #include "kits/c/wifi_p2p.h" 26 27 #include "adapter/p2p_adapter.h" 28 #include "channel/auth_negotiate_channel.h" 29 #include "p2p_available_state.h" 30 #include "p2p_broadcast_receiver.h" 31 #include "p2p_create_group_state.h" 32 #include "p2p_destroy_group_state.h" 33 #include "p2p_entity_state.h" 34 #include "p2p_operation.h" 35 #include "wifi_direct_entity.h" 36 #include "wifi_direct_initiator.h" 37 38 namespace OHOS::SoftBus { 39 using P2pCreateGroupParam = P2pAdapter::CreateGroupParam; 40 using P2pConnectParam = P2pAdapter::ConnectParam; 41 using P2pDestroyGroupParam = P2pAdapter::DestroyGroupParam; 42 43 struct ClientJoinEvent { 44 int32_t result_; 45 std::string remoteDeviceId_; 46 std::string remoteMac_; 47 }; 48 49 class P2pEntity : public WifiDirectEntity { 50 public: 51 static constexpr int TIMEOUT_WAIT_CLIENT_JOIN_MS = 10000; 52 GetInstance()53 static P2pEntity &GetInstance() 54 { 55 static P2pEntity instance; 56 return instance; 57 } 58 59 static void Init(); 60 void DisconnectLink(const std::string &remoteMac) override; 61 void DestroyGroupIfNeeded() override; 62 P2pOperationResult CreateGroup(const P2pCreateGroupParam ¶m); 63 P2pOperationResult Connect(const P2pConnectParam ¶m); 64 P2pOperationResult DestroyGroup(const P2pDestroyGroupParam ¶m); 65 P2pOperationResult Disconnect(const P2pDestroyGroupParam ¶m); 66 int32_t ReuseLink(); 67 68 void NotifyNewClientJoining(const std::string &remoteMac); 69 void CancelNewClientJoining(const std::string &remoteMac); 70 void RemoveNewClientJoining(const std::string &remoteMac); 71 void ClearJoiningClient(); 72 size_t GetJoiningClientCount(); 73 74 void ChangeState(P2pEntityState *state, const std::shared_ptr<P2pOperation> &operation); 75 76 void OnP2pStateChangeEvent(P2pState state); 77 void OnP2pConnectionChangeEvent( 78 const WifiP2pLinkedInfo &info, const std::shared_ptr<P2pAdapter::WifiDirectP2pGroupInfo> &groupInfo); 79 80 void PushOperation(const std::shared_ptr<P2pOperation> &operation); 81 void ExecuteNextOperation(); 82 bool HasPendingOperation(); 83 void ClearPendingOperation(); 84 85 void UpdateInterfaceManager( 86 const WifiP2pLinkedInfo &info, const std::shared_ptr<P2pAdapter::WifiDirectP2pGroupInfo> &groupInfo); 87 void UpdateLinkManager( 88 const WifiP2pLinkedInfo &info, const std::shared_ptr<P2pAdapter::WifiDirectP2pGroupInfo> &groupInfo); 89 90 void UpdateInterfaceManagerWhenStateChanged(P2pState state); 91 static void Listener(BroadcastReceiverAction action, const struct BroadcastParam ¶m); 92 Lock()93 void Lock() 94 { 95 CONN_LOGD(CONN_WIFI_DIRECT, "lock"); 96 operationLock_.lock(); 97 } Unlock()98 void Unlock() 99 { 100 CONN_LOGD(CONN_WIFI_DIRECT, "unlock"); 101 operationLock_.unlock(); 102 } 103 104 private: 105 P2pEntity(); 106 107 class Initiator { 108 public: Initiator()109 Initiator() 110 { 111 WifiDirectInitiator::GetInstance().Add(P2pEntity::Init); 112 } 113 }; 114 115 static inline Initiator initiator_; 116 117 friend P2pCreateGroupState; 118 friend P2pAvailableState; 119 friend P2pDestroyGroupState; 120 std::recursive_mutex operationLock_; 121 P2pEntityState *state_; 122 int currentFrequency_ = 0; 123 std::recursive_mutex pendingOperationLock_; 124 std::queue<std::shared_ptr<P2pOperation>> pendingOperations_; 125 126 OHOS::Utils::Timer timer_; 127 std::recursive_mutex joiningClientsLock_; 128 std::map<std::string, uint32_t> joiningClients_; 129 }; 130 } // namespace OHOS::SoftBus 131 #endif 132