1 /*
2  * Copyright (c) 2021 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 "virtual_time_sync_communicator.h"
17 
18 #include "log_print.h"
19 
20 namespace DistributedDB {
VirtualTimeSyncCommunicator()21 VirtualTimeSyncCommunicator::VirtualTimeSyncCommunicator()
22     : srcTimeSync_(nullptr),
23       dstTimeSync_(nullptr),
24       timeOffset_(0),
25       deviceID_(""),
26       syncTaskcontext_(nullptr),
27       isEnable_(true)
28 {
29 }
30 
~VirtualTimeSyncCommunicator()31 VirtualTimeSyncCommunicator::~VirtualTimeSyncCommunicator() {}
32 
RegOnMessageCallback(const OnMessageCallback & onMessage,const Finalizer & inOper)33 int VirtualTimeSyncCommunicator::RegOnMessageCallback(const OnMessageCallback &onMessage, const Finalizer &inOper)
34 {
35     return 0;
36 }
37 
RegOnConnectCallback(const OnConnectCallback & onConnect,const Finalizer & inOper)38 int VirtualTimeSyncCommunicator::RegOnConnectCallback(const OnConnectCallback &onConnect, const Finalizer &inOper)
39 {
40     return 0;
41 }
42 
RegOnSendableCallback(const std::function<void (void)> & onSendable,const Finalizer & inOper)43 int VirtualTimeSyncCommunicator::RegOnSendableCallback(const std::function<void(void)> &onSendable,
44     const Finalizer &inOper)
45 {
46     return 0;
47 }
48 
Activate()49 void VirtualTimeSyncCommunicator::Activate()
50 {
51 }
52 
53 // return maximum allowed data size
GetCommunicatorMtuSize() const54 uint32_t VirtualTimeSyncCommunicator::GetCommunicatorMtuSize() const
55 {
56     return 0;
57 }
58 
GetCommunicatorMtuSize(const std::string & target) const59 uint32_t VirtualTimeSyncCommunicator::GetCommunicatorMtuSize(const std::string &target) const
60 {
61     return GetCommunicatorMtuSize();
62 }
63 
GetTimeout() const64 uint32_t VirtualTimeSyncCommunicator::GetTimeout() const
65 {
66     return 0;
67 }
68 
GetTimeout(const std::string & target) const69 uint32_t VirtualTimeSyncCommunicator::GetTimeout(const std::string &target) const
70 {
71     return 0;
72 }
73 
IsDeviceOnline(const std::string & device) const74 bool VirtualTimeSyncCommunicator::IsDeviceOnline(const std::string &device) const
75 {
76     return true;
77 }
78 
79 // Get local target name for identify self
GetLocalIdentity(std::string & outTarget) const80 int VirtualTimeSyncCommunicator::GetLocalIdentity(std::string &outTarget) const
81 {
82     return 0;
83 }
84 
SendMessage(const std::string & dstTarget,const Message * inMsg,const SendConfig & config)85 int VirtualTimeSyncCommunicator::SendMessage(const std::string &dstTarget, const Message *inMsg,
86     const SendConfig &config)
87 {
88     return SendMessage(dstTarget, inMsg, config, nullptr);
89 }
90 
SendMessage(const std::string & dstTarget,const Message * inMsg,const SendConfig & config,const OnSendEnd & onEnd)91 int VirtualTimeSyncCommunicator::SendMessage(const std::string &dstTarget, const Message *inMsg,
92     const SendConfig &config, const OnSendEnd &onEnd)
93 {
94     if (!isEnable_) {
95         LOGD("[VirtualTimeSyncCommunicator]the VirtualTimeSyncCommunicator disabled!");
96         return -E_PERIPHERAL_INTERFACE_FAIL;
97     }
98     LOGD("VirtualTimeSyncCommunicator::sendMessage dev = %s, syncid = %d", dstTarget.c_str(), inMsg->GetSequenceId());
99     int errCode;
100     if (dstTarget == deviceID_) {
101         if (srcTimeSync_ == nullptr) {
102             LOGD("srcTimeSync_ = nullprt");
103             return -E_INVALID_ARGS;
104         }
105         if (syncTaskcontext_ == nullptr) {
106             LOGD("syncTaskcontext_ = nullprt");
107             return -E_INVALID_ARGS;
108         }
109         errCode = srcTimeSync_->AckRecv(inMsg);
110     } else {
111         if (dstTimeSync_ == nullptr) {
112             LOGD("dstTimeSync_ is nullprt");
113             return -E_INVALID_ARGS;
114         }
115         Message *msgTmp = const_cast<Message *>(inMsg);
116         errCode = dstTimeSync_->RequestRecv(msgTmp);
117     }
118     if (inMsg != nullptr) {
119         delete inMsg;
120         inMsg = nullptr;
121     }
122     return errCode;
123 }
124 
GetRemoteCommunicatorVersion(const std::string & deviceId,uint16_t & version) const125 int VirtualTimeSyncCommunicator::GetRemoteCommunicatorVersion(const std::string &deviceId, uint16_t &version) const
126 {
127     version = version_;
128     return E_OK;
129 }
130 
SetTimeSync(TimeSync * srcTimeSync,TimeSync * dstTimeSync,const std::string & deviceID,SyncTaskContext * syncTaskcontext)131 void VirtualTimeSyncCommunicator::SetTimeSync(TimeSync *srcTimeSync, TimeSync *dstTimeSync,
132     const std::string &deviceID, SyncTaskContext *syncTaskcontext)
133 {
134     srcTimeSync_ = srcTimeSync;
135     dstTimeSync_ = dstTimeSync;
136     deviceID_ = deviceID;
137     syncTaskcontext_ = syncTaskcontext;
138 }
139 
GetTimeOffset(TimeOffset & timeOffset) const140 void VirtualTimeSyncCommunicator::GetTimeOffset(TimeOffset &timeOffset) const
141 {
142     timeOffset = timeOffset_;
143 }
144 
Disable()145 void VirtualTimeSyncCommunicator::Disable()
146 {
147     isEnable_ = false;
148 }
149 
SetRemoteVersion(uint16_t remoteVersion)150 void VirtualTimeSyncCommunicator::SetRemoteVersion(uint16_t remoteVersion)
151 {
152     version_ = remoteVersion;
153 }
154 } // namespace DistributedDB