1 /* 2 * Copyright (C) 2023-2023 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 * Description: implement the cast source connect 15 * Author: zhangge 16 * Create: 2022-08-23 17 */ 18 19 #ifndef CONNECTION_MANAGER_H 20 #define CONNECTION_MANAGER_H 21 22 #include <map> 23 #include <mutex> 24 #include <optional> 25 #include <string> 26 27 #include "cast_device_data_manager.h" 28 #include "cast_engine_common.h" 29 #include "cast_engine_log.h" 30 #include "cast_service_common.h" 31 #include "connection_manager_listener.h" 32 #include "device_manager.h" 33 #include "dm_device_info.h" 34 #include "device_manager_callback.h" 35 #include "session.h" 36 #include "json.hpp" 37 38 namespace OHOS { 39 namespace CastEngine { 40 namespace CastEngineService { 41 using OHOS::DistributedHardware::BindTargetCallback; 42 using OHOS::DistributedHardware::UnbindTargetCallback; 43 using OHOS::DistributedHardware::DeviceStateCallback; 44 using OHOS::DistributedHardware::DmDeviceInfo; 45 using OHOS::DistributedHardware::PeerTargetId; 46 using nlohmann::json; 47 48 class CastBindTargetCallback : public BindTargetCallback { 49 public: 50 void OnBindResult(const PeerTargetId &targetId, int32_t result, int32_t status, std::string content) override; 51 private: 52 void HandleBindAction(const PeerTargetId &targetId, int action, const json &authInfo); 53 void HandleConnectDeviceAction(const PeerTargetId &targetId, const json &authInfo); 54 bool GetSessionKey(const json &authInfo, uint8_t *sessionkey); 55 void HandleQueryIpAction(const PeerTargetId &targetId, const json &authInfo); 56 static const std::map<int32_t, EventCode> EVENT_CODE_MAP; 57 }; 58 59 class CastUnBindTargetCallback : public UnbindTargetCallback { 60 public: 61 void OnUnbindResult(const PeerTargetId &targetId, int32_t result, std::string content) override; 62 }; 63 64 class IConnectionManagerListener { 65 public: 66 IConnectionManagerListener() = default; 67 virtual ~IConnectionManagerListener() = default; 68 69 virtual int NotifySessionIsReady() = 0; 70 virtual void NotifyDeviceIsOffline(const std::string &deviceId) = 0; 71 virtual bool NotifyRemoteDeviceIsReady(int castSessionId, const CastInnerRemoteDevice &device) = 0; 72 virtual void OnEvent(const std::string &deviceId, EventCode currentEventCode) = 0; 73 virtual void GrabDevice(int32_t sessionId) = 0; 74 virtual int32_t GetSessionProtocolType(int sessionId, ProtocolType &protocolType) = 0; 75 virtual int32_t SetSessionProtocolType(int sessionId, ProtocolType protocolType) = 0; 76 }; 77 78 class ConnectionManager { 79 public: 80 static ConnectionManager &GetInstance(); 81 82 void Init(std::shared_ptr<IConnectionManagerListener> listener); 83 void Deinit(); 84 85 bool IsDeviceTrusted(const std::string &deviceId, std::string &networkId); 86 DmDeviceInfo GetDmDeviceInfo(const std::string &deviceId); 87 bool EnableDiscoverable(); 88 bool DisableDiscoverable(); 89 void GrabDevice(); 90 91 bool OpenConsultSession(const std::string &deviceId); 92 void OnConsultDataReceived(int transportId, const void *data, unsigned int dataLen); 93 void OnConsultSessionOpened(int transportId, bool isSource); 94 95 bool ConnectDevice(const CastInnerRemoteDevice &dev); 96 void DisconnectDevice(const std::string &deviceId); 97 98 bool UpdateDeviceState(const std::string &deviceId, RemoteDeviceState state); 99 100 int GetProtocolType() const; 101 void SetProtocolType(int protocols); 102 103 std::unique_ptr<CastLocalDevice> GetLocalDeviceInfo(); 104 void NotifySessionIsReady(int transportId); 105 void NotifyDeviceIsOffline(const std::string &deviceId); 106 bool NotifySessionEvent(const std::string &deviceId, int result); 107 void ReportErrorByListener(const std::string &deviceId, EventCode currentEventCode); 108 void UpdateGrabState(bool changeState, int32_t sessionId); 109 void SetSessionListener(std::shared_ptr<IConnectManagerSessionListener> listener); 110 int32_t GetSessionProtocolType(int sessionId, ProtocolType &protocolType); 111 int32_t SetSessionProtocolType(int sessionId, ProtocolType protocolType); 112 void SetRTSPPort(int port); 113 bool IsSingle(const CastInnerRemoteDevice &device); 114 void SendConsultInfo(const std::string &deviceId, int port); 115 116 std::map<std::string, bool> isBindTargetMap_; 117 118 private: 119 bool BindTarget(const CastInnerRemoteDevice &dev); 120 bool BuildBindParam(const CastInnerRemoteDevice &device, std::map<std::string, std::string> &bindParam); 121 std::string GetAuthVersion(const CastInnerRemoteDevice &device); 122 void SendConsultData(const CastInnerRemoteDevice &device, int port); 123 bool QueryP2PIp(const CastInnerRemoteDevice &device); 124 bool IsHuaweiDevice(const CastInnerRemoteDevice &device); 125 bool IsThirdDevice(const CastInnerRemoteDevice &device); 126 127 std::string GetConsultationData(const CastInnerRemoteDevice &device, int port, json &body); 128 void EncryptPort(int port, const uint8_t *sessionKey, json &body); 129 std::string convLatin1ToUTF8(std::string &latin1); 130 void EncryptIp(const std::string &ip, const std::string &key, const uint8_t *sessionKey, json &body); 131 std::unique_ptr<uint8_t[]> intToByteArray(int32_t num); 132 133 void DestroyConsulationSession(const std::string &deviceId); 134 int GetCastSessionId(int transportId); 135 std::unique_ptr<CastInnerRemoteDevice> GetRemoteFromJsonData(const std::string &Data); 136 137 void SetListener(std::shared_ptr<IConnectionManagerListener> listener); 138 bool HasListener(); 139 void ResetListener(); 140 int GetRTSPPort(); 141 142 std::mutex mutex_; 143 int protocolType_ = 0; 144 std::shared_ptr<IConnectionManagerListener> listener_; 145 std::shared_ptr<IConnectManagerSessionListener> sessionListener_; 146 std::map<int, int> transIdToCastSessionIdMap_; 147 bool isDiscoverable_{ false }; 148 DeviceGrabState grabState_{ DeviceGrabState::NO_GRAB }; 149 int32_t sessionId_{ -1 }; 150 int rtspPort_{ INVALID_PORT }; 151 }; 152 153 class CastDeviceStateCallback : public DeviceStateCallback { 154 public: 155 void OnDeviceOnline(const DmDeviceInfo &deviceInfo) override; 156 void OnDeviceOffline(const DmDeviceInfo &deviceInfo) override; 157 void OnDeviceChanged(const DmDeviceInfo &deviceInfo) override; 158 void OnDeviceReady(const DmDeviceInfo &deviceInfo) override; 159 }; 160 } // namespace CastEngineService 161 } // namespace CastEngine 162 } // namespace OHOS 163 164 #endif // CONNECTION_MANAGER_H