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 &param);
63     P2pOperationResult Connect(const P2pConnectParam &param);
64     P2pOperationResult DestroyGroup(const P2pDestroyGroupParam &param);
65     P2pOperationResult Disconnect(const P2pDestroyGroupParam &param);
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 &param);
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