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
16 #include "duration_statistic.h"
17 #include "chrono"
18 #include "conn_log.h"
19
20 namespace OHOS::SoftBus {
GetTime()21 uint64_t DurationStatistic::GetTime()
22 {
23 auto now = std::chrono::system_clock::now();
24 auto nowTimeMs = std::chrono::time_point_cast<std::chrono::milliseconds>(now);
25 auto value = nowTimeMs.time_since_epoch();
26 return static_cast<uint64_t>(value.count());
27 }
28
Start(uint32_t requestId,const std::shared_ptr<DurationStatisticCalculator> & calculator)29 void DurationStatistic::Start(uint32_t requestId, const std::shared_ptr<DurationStatisticCalculator> &calculator)
30 {
31 std::lock_guard lock(mutex_);
32 calculators_.insert(std::make_pair(requestId, calculator));
33 }
34
Record(uint32_t requestId,const std::string & event)35 void DurationStatistic::Record(uint32_t requestId, const std::string &event)
36 {
37 std::lock_guard lock(mutex_);
38 if (stateTimeMap_[requestId].find(event) != stateTimeMap_[requestId].end()) {
39 stateTimeMap_[requestId][event] = GetTime();
40 }
41 stateTimeMap_[requestId].insert(std::make_pair(event, GetTime()));
42 }
43
RecordReNegotiate(uint32_t requestId,bool flag)44 void DurationStatistic::RecordReNegotiate(uint32_t requestId, bool flag)
45 {
46 std::lock_guard lock(mutex_);
47 reNegotiateFlagMap_.insert(std::make_pair(requestId, flag));
48 }
49
End(uint32_t requestId)50 void DurationStatistic::End(uint32_t requestId)
51 {
52 std::lock_guard lock(mutex_);
53 if (calculators_[requestId] != nullptr) {
54 calculators_[requestId]->CalculateAllEvent(requestId, stateTimeMap_[requestId]);
55 }
56 }
57
Clear(uint32_t requestId)58 void DurationStatistic::Clear(uint32_t requestId)
59 {
60 std::lock_guard lock(mutex_);
61 stateTimeMap_.erase(requestId);
62 calculators_.erase(requestId);
63 reNegotiateFlagMap_.erase(requestId);
64 }
65
CalculateAllEvent(uint32_t requestId,std::map<std::string,uint64_t> records)66 void P2pCalculator::CalculateAllEvent(uint32_t requestId, std::map<std::string, uint64_t> records)
67 {
68 CONN_LOGI(CONN_WIFI_DIRECT, "p2p calculateEvent");
69 }
70
Register(const OHOS::SoftBus::DurationStatisticCalculatorFactory::Creator & creator)71 void DurationStatisticCalculatorFactory::Register(
72 const OHOS::SoftBus::DurationStatisticCalculatorFactory::Creator &creator)
73 {
74 creator_ = creator;
75 }
76
NewInstance(enum WifiDirectConnectType type)77 std::shared_ptr<DurationStatisticCalculator> DurationStatisticCalculatorFactory::NewInstance(
78 enum WifiDirectConnectType type)
79 {
80 CONN_LOGI(CONN_WIFI_DIRECT, "enter");
81 if (creator_ == nullptr) {
82 return std::make_shared<P2pCalculator>(P2pCalculator::GetInstance());
83 }
84 return creator_(type);
85 }
86
GetStateTimeMapElement(uint32_t requestId)87 std::map<std::string, uint64_t> DurationStatistic::GetStateTimeMapElement(uint32_t requestId)
88 {
89 std::lock_guard lock(mutex_);
90 return stateTimeMap_[requestId];
91 }
92
ReNegotiateFlag(uint32_t requestId)93 bool DurationStatistic::ReNegotiateFlag(uint32_t requestId)
94 {
95 std::lock_guard lock(mutex_);
96 if (reNegotiateFlagMap_.find(requestId) != reNegotiateFlagMap_.end()) {
97 return true;
98 }
99 return false;
100 }
101 } // namespace OHOS::SoftBus