Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2019 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 17 | #include "hal/facade.h" |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 18 | |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 19 | #include <condition_variable> |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 20 | #include <memory> |
| 21 | #include <mutex> |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 22 | |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 23 | #include "common/blocking_queue.h" |
| 24 | #include "grpc/grpc_event_stream.h" |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 25 | #include "hal/facade.grpc.pb.h" |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 26 | #include "hal/hci_hal.h" |
Myles Watson | badfc33 | 2019-09-04 15:37:23 -0700 | [diff] [blame] | 27 | #include "hal/serialize_packet.h" |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 28 | #include "hci/hci_packets.h" |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 29 | |
| 30 | using ::grpc::ServerAsyncResponseWriter; |
| 31 | using ::grpc::ServerAsyncWriter; |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 32 | using ::grpc::ServerContext; |
| 33 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 34 | using ::bluetooth::facade::EventStreamRequest; |
| 35 | |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 36 | namespace bluetooth { |
| 37 | namespace hal { |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 38 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 39 | class HciHalFacadeService |
| 40 | : public HciHalFacade::Service, |
Zach Johnson | b45ecd2 | 2019-04-29 12:07:23 -0700 | [diff] [blame] | 41 | public ::bluetooth::hal::HciHalCallbacks { |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 42 | public: |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 43 | HciHalFacadeService(HciHal* hal) |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 44 | : hal_(hal), hci_event_stream_(&hci_event_stream_callback_), hci_acl_stream_(&hci_acl_stream_callback_), |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 45 | hci_sco_stream_(&hci_sco_stream_callback_) { |
| 46 | hal->registerIncomingPacketCallback(this); |
| 47 | } |
Zach Johnson | e0e158c | 2019-04-26 11:57:05 -0700 | [diff] [blame] | 48 | |
Hansong Zhang | 116cb56 | 2019-07-24 15:33:35 -0700 | [diff] [blame] | 49 | ~HciHalFacadeService() { |
| 50 | hal_->unregisterIncomingPacketCallback(); |
| 51 | } |
| 52 | |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 53 | ::grpc::Status SendHciResetCommand(::grpc::ServerContext* context, const ::google::protobuf::Empty* request, |
| 54 | ::google::protobuf::Empty* response) override { |
| 55 | std::unique_lock<std::mutex> lock(mutex_); |
| 56 | can_send_hci_command_ = false; |
Myles Watson | badfc33 | 2019-09-04 15:37:23 -0700 | [diff] [blame] | 57 | hal_->sendHciCommand(SerializePacket(hci::ResetBuilder::Create())); |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 58 | while (!can_send_hci_command_) { |
| 59 | cv_.wait(lock); |
| 60 | } |
| 61 | return ::grpc::Status::OK; |
| 62 | } |
| 63 | |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 64 | ::grpc::Status SetLoopbackMode(::grpc::ServerContext* context, |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 65 | const ::bluetooth::hal::LoopbackModeSettings* request, |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 66 | ::google::protobuf::Empty* response) override { |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 67 | std::unique_lock<std::mutex> lock(mutex_); |
| 68 | can_send_hci_command_ = false; |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 69 | bool enable = request->enable(); |
Myles Watson | badfc33 | 2019-09-04 15:37:23 -0700 | [diff] [blame] | 70 | hal_->sendHciCommand(SerializePacket(hci::WriteLoopbackModeBuilder::Create( |
| 71 | enable ? hci::LoopbackMode::ENABLE_LOCAL : hci::LoopbackMode::NO_LOOPBACK))); |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 72 | while (!can_send_hci_command_) { |
| 73 | cv_.wait(lock); |
| 74 | } |
| 75 | return ::grpc::Status::OK; |
| 76 | } |
| 77 | |
| 78 | ::grpc::Status SetInquiry(::grpc::ServerContext* context, const ::bluetooth::hal::InquirySettings* request, |
| 79 | ::google::protobuf::Empty* response) override { |
| 80 | std::unique_lock<std::mutex> lock(mutex_); |
| 81 | can_send_hci_command_ = false; |
Chris Manton | b365084 | 2019-10-03 17:31:12 -0700 | [diff] [blame] | 82 | hci::Lap lap; |
| 83 | lap.lap_ = 0x33; |
| 84 | |
| 85 | hal_->sendHciCommand(SerializePacket(hci::InquiryBuilder::Create(lap, static_cast<uint8_t>(request->length()), |
| 86 | static_cast<uint8_t>(request->num_responses())))); |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 87 | while (!can_send_hci_command_) { |
| 88 | cv_.wait(lock); |
| 89 | } |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 90 | return ::grpc::Status::OK; |
| 91 | } |
| 92 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 93 | ::grpc::Status SendHciCommand(::grpc::ServerContext* context, const ::bluetooth::hal::HciCommandPacket* request, |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 94 | ::google::protobuf::Empty* response) override { |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 95 | std::unique_lock<std::mutex> lock(mutex_); |
| 96 | can_send_hci_command_ = false; |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 97 | std::string req_string = request->payload(); |
Zach Johnson | e0e158c | 2019-04-26 11:57:05 -0700 | [diff] [blame] | 98 | hal_->sendHciCommand(std::vector<uint8_t>(req_string.begin(), req_string.end())); |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 99 | while (!can_send_hci_command_) { |
| 100 | cv_.wait(lock); |
| 101 | } |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 102 | return ::grpc::Status::OK; |
| 103 | } |
| 104 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 105 | ::grpc::Status SendHciAcl(::grpc::ServerContext* context, const ::bluetooth::hal::HciAclPacket* request, |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 106 | ::google::protobuf::Empty* response) override { |
| 107 | std::string req_string = request->payload(); |
Zach Johnson | e0e158c | 2019-04-26 11:57:05 -0700 | [diff] [blame] | 108 | hal_->sendAclData(std::vector<uint8_t>(req_string.begin(), req_string.end())); |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 109 | return ::grpc::Status::OK; |
| 110 | } |
| 111 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 112 | ::grpc::Status SendHciSco(::grpc::ServerContext* context, const ::bluetooth::hal::HciScoPacket* request, |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 113 | ::google::protobuf::Empty* response) override { |
| 114 | std::string req_string = request->payload(); |
Zach Johnson | e0e158c | 2019-04-26 11:57:05 -0700 | [diff] [blame] | 115 | hal_->sendScoData(std::vector<uint8_t>(req_string.begin(), req_string.end())); |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 116 | return ::grpc::Status::OK; |
| 117 | } |
| 118 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 119 | ::grpc::Status FetchHciEvent(::grpc::ServerContext* context, const EventStreamRequest* request, |
| 120 | ::grpc::ServerWriter<HciEventPacket>* writer) override { |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 121 | return hci_event_stream_.HandleRequest(context, request, writer); |
| 122 | }; |
| 123 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 124 | ::grpc::Status FetchHciAcl(::grpc::ServerContext* context, const EventStreamRequest* request, |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 125 | ::grpc::ServerWriter<HciAclPacket>* writer) override { |
| 126 | return hci_acl_stream_.HandleRequest(context, request, writer); |
| 127 | }; |
| 128 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 129 | ::grpc::Status FetchHciSco(::grpc::ServerContext* context, const EventStreamRequest* request, |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 130 | ::grpc::ServerWriter<HciScoPacket>* writer) override { |
| 131 | return hci_sco_stream_.HandleRequest(context, request, writer); |
| 132 | }; |
| 133 | |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 134 | void hciEventReceived(bluetooth::hal::HciPacket event) override { |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 135 | std::string response_str = std::string(event.begin(), event.end()); |
| 136 | hci_event_stream_.OnIncomingEvent(event); |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 137 | can_send_hci_command_ = true; |
| 138 | cv_.notify_one(); |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 139 | } |
| 140 | |
| 141 | void aclDataReceived(bluetooth::hal::HciPacket data) override { |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 142 | hci_acl_stream_.OnIncomingEvent(data); |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | void scoDataReceived(bluetooth::hal::HciPacket data) override { |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 146 | hci_sco_stream_.OnIncomingEvent(data); |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 147 | } |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 148 | |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 149 | private: |
Zach Johnson | b45ecd2 | 2019-04-29 12:07:23 -0700 | [diff] [blame] | 150 | HciHal* hal_; |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 151 | bool can_send_hci_command_ = true; |
| 152 | mutable std::mutex mutex_; |
| 153 | std::condition_variable cv_; |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 154 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 155 | class HciEventStreamCallback : public ::bluetooth::grpc::GrpcEventStreamCallback<HciEventPacket, HciPacket> { |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 156 | public: |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 157 | void OnWriteResponse(HciEventPacket* response, const HciPacket& event) override { |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 158 | std::string response_str = std::string(event.begin(), event.end()); |
| 159 | response->set_payload(std::string(event.begin(), event.end())); |
| 160 | } |
| 161 | } hci_event_stream_callback_; |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 162 | ::bluetooth::grpc::GrpcEventStream<HciEventPacket, HciPacket> hci_event_stream_; |
Chienyuan | 4adb042 | 2019-04-25 15:11:54 -0700 | [diff] [blame] | 163 | |
| 164 | class HciAclStreamCallback : public ::bluetooth::grpc::GrpcEventStreamCallback<HciAclPacket, HciPacket> { |
| 165 | public: |
| 166 | void OnWriteResponse(HciAclPacket* response, const HciPacket& event) override { |
| 167 | response->set_payload(std::string(event.begin(), event.end())); |
| 168 | } |
| 169 | } hci_acl_stream_callback_; |
| 170 | ::bluetooth::grpc::GrpcEventStream<HciAclPacket, HciPacket> hci_acl_stream_; |
| 171 | |
| 172 | class HciScoStreamCallback : public ::bluetooth::grpc::GrpcEventStreamCallback<HciScoPacket, HciPacket> { |
| 173 | public: |
| 174 | void OnWriteResponse(HciScoPacket* response, const HciPacket& event) override { |
| 175 | response->set_payload(std::string(event.begin(), event.end())); |
| 176 | } |
| 177 | } hci_sco_stream_callback_; |
| 178 | ::bluetooth::grpc::GrpcEventStream<HciScoPacket, HciPacket> hci_sco_stream_; |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 179 | }; |
| 180 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 181 | void HciHalFacadeModule::ListDependencies(ModuleList* list) { |
Zach Johnson | e0e158c | 2019-04-26 11:57:05 -0700 | [diff] [blame] | 182 | ::bluetooth::grpc::GrpcFacadeModule::ListDependencies(list); |
Zach Johnson | b45ecd2 | 2019-04-29 12:07:23 -0700 | [diff] [blame] | 183 | list->add<HciHal>(); |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 184 | } |
| 185 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 186 | void HciHalFacadeModule::Start() { |
Zach Johnson | 84b448b | 2019-04-29 15:34:55 -0700 | [diff] [blame] | 187 | ::bluetooth::grpc::GrpcFacadeModule::Start(); |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 188 | service_ = new HciHalFacadeService(GetDependency<HciHal>()); |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 189 | } |
| 190 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 191 | void HciHalFacadeModule::Stop() { |
Zach Johnson | e0e158c | 2019-04-26 11:57:05 -0700 | [diff] [blame] | 192 | delete service_; |
Hansong Zhang | 90ec740 | 2019-04-29 16:04:07 -0700 | [diff] [blame] | 193 | ::bluetooth::grpc::GrpcFacadeModule::Stop(); |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 194 | } |
| 195 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 196 | ::grpc::Service* HciHalFacadeModule::GetService() const { |
Zach Johnson | e0e158c | 2019-04-26 11:57:05 -0700 | [diff] [blame] | 197 | return service_; |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 198 | } |
| 199 | |
Zach Johnson | 3470360 | 2019-04-29 16:45:21 -0700 | [diff] [blame] | 200 | const ModuleFactory HciHalFacadeModule::Factory = ::bluetooth::ModuleFactory([]() { |
| 201 | return new HciHalFacadeModule(); |
Zach Johnson | e0e158c | 2019-04-26 11:57:05 -0700 | [diff] [blame] | 202 | }); |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 203 | |
Hansong Zhang | 29f9900 | 2019-04-24 17:25:42 +0000 | [diff] [blame] | 204 | } // namespace hal |
| 205 | } // namespace bluetooth |