1 /* 2 * Copyright (c) 2024-2025 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 #ifndef OHOS_DSCHED_CONTINUE_H 17 #define OHOS_DSCHED_CONTINUE_H 18 19 #include <condition_variable> 20 #include <mutex> 21 #include <thread> 22 #include <string> 23 24 #include "ability_manager_client.h" 25 #include "distributedWant/distributed_want.h" 26 #include "distributedWant/distributed_want_params.h" 27 #include "distributed_sched_interface.h" 28 #include "distributed_sched_utils.h" 29 #include "dsched_data_buffer.h" 30 #include "dsched_continue_event.h" 31 #include "dsched_continue_event_handler.h" 32 #include "dsched_continue_state_machine.h" 33 #include "mission/distributed_bm_storage.h" 34 #include "event_handler.h" 35 36 namespace OHOS { 37 namespace DistributedSchedule { 38 39 using AccountInfo = IDistributedSched::AccountInfo; 40 41 class DSchedContinueInfo { 42 public: 43 DSchedContinueInfo() = default; DSchedContinueInfo(const std::string & sourceDeviceId,const std::string & sourceBundleName,const std::string & sinkDeviceId,const std::string & sinkBundleName,const std::string & continueType)44 DSchedContinueInfo(const std::string& sourceDeviceId, const std::string& sourceBundleName, 45 const std::string& sinkDeviceId, const std::string& sinkBundleName, const std::string& continueType) 46 : sourceDeviceId_(sourceDeviceId), sourceBundleName_(sourceBundleName), sinkDeviceId_(sinkDeviceId), 47 sinkBundleName_(sinkBundleName), continueType_(continueType) {} 48 DSchedContinueInfo(const std::string & sourceDeviceId,const std::string & sinkDeviceId,int32_t missionId)49 DSchedContinueInfo(const std::string& sourceDeviceId, const std::string& sinkDeviceId, int32_t missionId) 50 : sourceDeviceId_(sourceDeviceId), sinkDeviceId_(sinkDeviceId), missionId_(missionId) {} 51 ~DSchedContinueInfo() = default; 52 53 bool operator == (const DSchedContinueInfo &index) const 54 { 55 std::string compareInfo = this->sourceDeviceId_ + this->sourceBundleName_ + this->sinkDeviceId_ + 56 this->sinkBundleName_; 57 std::string otherCompareInfo = index.sourceDeviceId_ + index.sourceBundleName_ + index.sinkDeviceId_ + 58 index.sinkBundleName_; 59 return compareInfo.compare(otherCompareInfo) == 0; 60 } 61 62 bool operator < (const DSchedContinueInfo &index) const 63 { 64 std::string compareInfo = this->sourceDeviceId_ + this->sourceBundleName_ + this->sinkDeviceId_ + 65 this->sinkBundleName_; 66 std::string otherCompareInfo = index.sourceDeviceId_ + index.sourceBundleName_ + index.sinkDeviceId_ + 67 index.sinkBundleName_; 68 return compareInfo < otherCompareInfo; 69 } 70 ToStringIgnoreMissionId()71 std::string ToStringIgnoreMissionId() const 72 { 73 return "SrcDevId: " + GetAnonymStr(this->sourceDeviceId_) + " " + 74 "SrcBundle: " + this->sourceBundleName_ + " " + 75 "DstDevId: "+ GetAnonymStr(this->sinkDeviceId_) + " " + 76 "DstBundle: " + this->sinkBundleName_ + " " + 77 "ContiType: " + this->continueType_; 78 } 79 ToString()80 std::string ToString() const 81 { 82 return "SrcDevId: " + GetAnonymStr(this->sourceDeviceId_) + " " + 83 "SrcBundle: " + this->sourceBundleName_ + " " + 84 "DstDevId: "+ GetAnonymStr(this->sinkDeviceId_) + " " + 85 "DstBundle: " + this->sinkBundleName_ + " " + 86 "ContiType: " + this->continueType_ + " " + 87 "MissionId: " + std::to_string(this->missionId_); 88 } 89 90 std::string sourceDeviceId_; 91 std::string sourceBundleName_; 92 std::string sinkDeviceId_; 93 std::string sinkBundleName_; 94 std::string continueType_; 95 std::string sinkAbilityName_; 96 int32_t missionId_ = 0; 97 std::string continueSessionId_; 98 int32_t sinkMissionId_ = 0; 99 }; 100 101 typedef enum { 102 CONTINUE_SOURCE = 0, 103 CONTINUE_SINK = 1 104 } DSchedContinueDirection; 105 106 typedef enum { 107 CONTINUE_PULL = 0, 108 CONTINUE_PUSH = 1 109 } DSchedContinueSubType; 110 111 struct ContinueAbilityData { 112 OHOS::AAFwk::Want want; 113 int32_t callerUid; 114 uint32_t accessToken; 115 }; 116 117 struct ContinueEventData { 118 std::string moduleName; 119 std::string abilityName; 120 }; 121 122 struct StateCallbackInfo { 123 int32_t missionId = -1; 124 std::string bundleName; 125 std::string moduleName; 126 std::string abilityName; 127 StateCallbackInfoStateCallbackInfo128 StateCallbackInfo() {}; 129 StateCallbackInfoStateCallbackInfo130 StateCallbackInfo(const int32_t &missionId, const std::string &bundleName, const std::string &moduleName, 131 const std::string &abilityName) : missionId(missionId), bundleName(bundleName), 132 moduleName(moduleName), abilityName(abilityName) {} 133 134 bool operator==(const StateCallbackInfo &rhs) const 135 { 136 return missionId == rhs.missionId && 137 bundleName == rhs.bundleName && 138 moduleName == rhs.moduleName && 139 abilityName == rhs.abilityName; 140 } 141 142 friend bool operator<(const StateCallbackInfo &lhs, const StateCallbackInfo &rhs) 143 { 144 if (lhs.missionId < rhs.missionId) 145 return true; 146 if (rhs.missionId < lhs.missionId) 147 return false; 148 if (lhs.bundleName < rhs.bundleName) 149 return true; 150 if (rhs.bundleName < lhs.bundleName) 151 return false; 152 if (lhs.moduleName < rhs.moduleName) 153 return true; 154 if (rhs.moduleName < lhs.moduleName) 155 return false; 156 return lhs.abilityName < rhs.abilityName; 157 } 158 }; 159 160 class StateCallbackIpcDiedListener : public IRemoteObject::DeathRecipient { 161 public: 162 void OnRemoteDied(const wptr<IRemoteObject> &object) override; 163 164 public: 165 StateCallbackInfo stateCallbackInfo_; 166 }; 167 168 class StateCallbackData { 169 public: 170 sptr<IRemoteObject> remoteObject; 171 sptr<StateCallbackIpcDiedListener> diedListener; 172 int32_t state = -1; 173 std::string message; 174 StateCallbackData()175 StateCallbackData() {}; 176 }; 177 178 class DSchedContinue : public std::enable_shared_from_this<DSchedContinue> { 179 friend class DSchedContinueManager; 180 friend class DSchedContinueEventHandler; 181 friend class DSchedContinueSourceStartState; 182 friend class DSchedContinueAbilityState; 183 friend class DSchedContinueWaitEndState; 184 friend class DSchedContinueEndState; 185 friend class DSchedContinueSinkStartState; 186 friend class DSchedContinueDataState; 187 friend class DSchedContinueSinkWaitEndState; 188 friend class DSchedContinueSinkEndState; 189 190 public: 191 DSchedContinue(int32_t subServiceType, int32_t direction, const sptr<IRemoteObject>& callback, 192 const DSchedContinueInfo& continueInfo, int32_t accountId = INVALID_ACCOUNT_ID); 193 DSchedContinue(std::shared_ptr<DSchedContinueStartCmd> startCmd, int32_t sessionId, 194 int32_t accountId = INVALID_ACCOUNT_ID); 195 ~DSchedContinue(); 196 197 private: 198 int32_t Init(); 199 void StartEventHandler(); 200 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer& event); 201 202 int32_t PostStartTask(const OHOS::AAFwk::WantParams& wantParams); 203 int32_t PostReplyTask(std::shared_ptr<DSchedContinueReplyCmd> cmd); 204 int32_t PostCotinueAbilityTask(int32_t appVersion); 205 int32_t PostContinueSendTask(const OHOS::AAFwk::Want& want, int32_t callerUid, int32_t status, 206 uint32_t accessToken); 207 int32_t PostContinueDataTask(std::shared_ptr<DSchedContinueDataCmd> cmd); 208 int32_t PostNotifyCompleteTask(int32_t result); 209 int32_t PostContinueEndTask(int32_t result); 210 211 int32_t ExecuteContinueReq(std::shared_ptr<DistributedWantParams> wantParams); 212 int32_t ExecuteContinueAbility(int32_t appVersion); 213 int32_t ExecuteContinueReply(); 214 int32_t ExecuteContinueSend(std::shared_ptr<ContinueAbilityData> data); 215 int32_t ExecuteContinueData(std::shared_ptr<DSchedContinueDataCmd> cmd); 216 int32_t UpdateElementInfo(std::shared_ptr<DSchedContinueDataCmd> cmd); 217 void FindSinkContinueAbilityInfo(const std::string &srcModuleName, const std::string &srcContinueType, 218 std::vector<DmsAbilityInfo> &dmsAbilityInfos, std::vector<DmsAbilityInfo> &result); 219 void ContinueTypeFormat(std::string &continueType); 220 int32_t ExecuteNotifyComplete(int32_t result); 221 int32_t ExecuteContinueEnd(int32_t result); 222 int32_t ExecuteContinueError(int32_t result); 223 int32_t ExecuteQuickStartSuccess(); 224 int32_t ExecuteQuickStartFailed(int32_t result); 225 226 int32_t OnContinueMission(const OHOS::AAFwk::WantParams& wantParams); 227 int32_t OnStartCmd(int32_t appVersion); 228 int32_t OnReplyCmd(std::shared_ptr<DSchedContinueReplyCmd> cmd); 229 int32_t OnStartContinuation(const OHOS::AAFwk::Want& want, int32_t callerUid, int32_t status, 230 uint32_t accessToken); 231 int32_t OnContinueDataCmd(std::shared_ptr<DSchedContinueDataCmd> cmd); 232 int32_t OnNotifyComplete(int32_t missionId, bool isSuccess); 233 int32_t OnContinueEndCmd(std::shared_ptr<DSchedContinueEndCmd> cmd); 234 int32_t OnContinueEnd(int32_t result); 235 236 void OnDataRecv(int32_t command, std::shared_ptr<DSchedDataBuffer> dataBuffer); 237 void OnShutDown(); 238 void OnBind(); 239 240 int32_t GetSessionId(); 241 DSchedContinueInfo GetContinueInfo(); 242 243 int32_t PackStartCmd(std::shared_ptr<DSchedContinueStartCmd>& cmd, 244 std::shared_ptr<DistributedWantParams> wantParams); 245 int32_t PackDataCmd(std::shared_ptr<DSchedContinueDataCmd>& cmd, const OHOS::AAFwk::Want& want, 246 const AppExecFwk::AbilityInfo& abilityInfo, const CallerInfo& callerInfo, 247 const AccountInfo& accountInfo); 248 int32_t CheckStartPermission(std::shared_ptr<DSchedContinueDataCmd> cmd); 249 int32_t PackEndCmd(std::shared_ptr<DSchedContinueEndCmd> cmd, int32_t result); 250 int32_t PackReplyCmd(std::shared_ptr<DSchedContinueReplyCmd> cmd, int32_t replyCmd, int32_t appVersion, 251 int32_t result, const std::string reason); 252 int32_t SendCommand(std::shared_ptr<DSchedContinueCmdBase> cmd); 253 254 int32_t SetWantForContinuation(AAFwk::Want& newWant); 255 void SetCleanMissionFlag(const OHOS::AAFwk::Want& want); 256 int32_t ConvertToDmsSdkErr(int32_t result); 257 void NotifyContinuationCallbackResult(int32_t result); 258 bool GetLocalDeviceId(std::string& localDeviceId); 259 bool CheckDeviceIdFromRemote(const std::string& localDevId, const std::string& destDevId, 260 const std::string& srcDevId); 261 int32_t GetMissionIdByBundleName(); 262 int32_t CheckContinueAbilityPermission(); 263 void DurationDumperStart(); 264 void DurationDumperBeforeStartRemoteAbility(); 265 void DurationDumperBeforeStartAbility(std::shared_ptr<DSchedContinueDataCmd> cmd); 266 void DurationDumperComplete(int32_t result); 267 void NotifyDSchedEventResult(int32_t result); 268 bool WaitAbilityStateInitial(int32_t persistentId); 269 int32_t StartAbility(OHOS::AAFwk::Want& want, int32_t requestCode); 270 std::string QuerySinkAbilityName(); 271 int32_t QuickStartAbility(); 272 int32_t UpdateWantForContinueType(OHOS::AAFwk::Want& want); 273 bool CheckQuickStartConfiguration(); 274 std::string GetAbilityNameByContinueType(); 275 void SetEventData(); 276 void UpdateState(DSchedContinueStateType stateType); 277 278 private: 279 static constexpr int32_t INVALID_SESSION_ID = -1; 280 static constexpr int32_t INVALID_ACCOUNT_ID = -1; 281 static constexpr int32_t ERROR_BASE_DSOFTBUS_WIFI = -200000; 282 static constexpr int32_t ERROR_PEER_THREE_VAP_CONFLICT = ERROR_BASE_DSOFTBUS_WIFI - 6604; 283 static const std::map<int32_t, int32_t> DMS_CONVERT_TO_SDK_ERR_MAP; 284 285 std::shared_ptr<DSchedContinueStateMachine> stateMachine_; 286 std::shared_ptr<DSchedContinueEventHandler> eventHandler_; 287 std::condition_variable eventCon_; 288 std::thread eventThread_; 289 std::mutex eventMutex_; 290 291 int32_t version_ = 0; 292 int32_t subServiceType_ = 0; 293 int32_t continueByType_ = 0; 294 int32_t direction_ = 0; 295 DSchedContinueInfo continueInfo_; 296 bool isSourceExit_ = true; 297 int32_t softbusSessionId_ = INVALID_SESSION_ID; 298 sptr<IRemoteObject> callback_ = nullptr; 299 EventNotify eventData_; 300 int32_t accountId_ = INVALID_ACCOUNT_ID; 301 bool hasResult_ = false; 302 }; 303 } // namespace DistributedSchedule 304 } // namespace OHOS 305 #endif // OHOS_DSCHED_CONTINUE_H