DRM 1.1: Add VINTF doc
[android/platform-hardware-interfaces.git] / bluetooth / 1.0 / default / async_fd_watcher.cc
1 //
2 // Copyright 2016 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 //
17 #define LOG_TAG "android.hardware.bluetooth@1.0-impl"
19 #include "async_fd_watcher.h"
21 #include <algorithm>
22 #include <atomic>
23 #include <condition_variable>
24 #include <map>
25 #include <mutex>
26 #include <thread>
27 #include <log/log.h>
28 #include <vector>
29 #include "fcntl.h"
30 #include "sys/select.h"
31 #include "unistd.h"
33 static const int INVALID_FD = -1;
35 static const int BT_RT_PRIORITY = 1;
37 namespace android {
38 namespace hardware {
39 namespace bluetooth {
40 namespace async {
42 int AsyncFdWatcher::WatchFdForNonBlockingReads(
43     int file_descriptor, const ReadCallback& on_read_fd_ready_callback) {
44   // Add file descriptor and callback
45   {
46     std::unique_lock<std::mutex> guard(internal_mutex_);
47     watched_fds_[file_descriptor] = on_read_fd_ready_callback;
48   }
50   // Start the thread if not started yet
51   return tryStartThread();
52 }
54 int AsyncFdWatcher::ConfigureTimeout(
55     const std::chrono::milliseconds timeout,
56     const TimeoutCallback& on_timeout_callback) {
57   // Add timeout and callback
58   {
59     std::unique_lock<std::mutex> guard(timeout_mutex_);
60     timeout_cb_ = on_timeout_callback;
61     timeout_ms_ = timeout;
62   }
64   notifyThread();
65   return 0;
66 }
68 void AsyncFdWatcher::StopWatchingFileDescriptors() { stopThread(); }
70 AsyncFdWatcher::~AsyncFdWatcher() {}
72 // Make sure to call this with at least one file descriptor ready to be
73 // watched upon or the thread routine will return immediately
74 int AsyncFdWatcher::tryStartThread() {
75   if (std::atomic_exchange(&running_, true)) return 0;
77   // Set up the communication channel
78   int pipe_fds[2];
79   if (pipe2(pipe_fds, O_NONBLOCK)) return -1;
81   notification_listen_fd_ = pipe_fds[0];
82   notification_write_fd_ = pipe_fds[1];
84   thread_ = std::thread([this]() { ThreadRoutine(); });
85   if (!thread_.joinable()) return -1;
87   return 0;
88 }
90 int AsyncFdWatcher::stopThread() {
91   if (!std::atomic_exchange(&running_, false)) return 0;
93   notifyThread();
94   if (std::this_thread::get_id() != thread_.get_id()) {
95     thread_.join();
96   }
98   {
99     std::unique_lock<std::mutex> guard(internal_mutex_);
100     watched_fds_.clear();
101   }
103   {
104     std::unique_lock<std::mutex> guard(timeout_mutex_);
105     timeout_cb_ = nullptr;
106   }
108   close(notification_listen_fd_);
109   close(notification_write_fd_);
111   return 0;
114 int AsyncFdWatcher::notifyThread() {
115   uint8_t buffer[] = {0};
116   if (TEMP_FAILURE_RETRY(write(notification_write_fd_, &buffer, 1)) < 0) {
117     return -1;
118   }
119   return 0;
122 void AsyncFdWatcher::ThreadRoutine() {
123   // Make watching thread RT.
124   struct sched_param rt_params;
125   rt_params.sched_priority = BT_RT_PRIORITY;
126   if (sched_setscheduler(gettid(), SCHED_FIFO, &rt_params)) {
127     ALOGE("%s unable to set SCHED_FIFO for pid %d, tid %d, error %s", __func__,
128           getpid(), gettid(), strerror(errno));
129   }
131   while (running_) {
132     fd_set read_fds;
133     FD_ZERO(&read_fds);
134     FD_SET(notification_listen_fd_, &read_fds);
135     int max_read_fd = INVALID_FD;
136     for (auto& it : watched_fds_) {
137       FD_SET(it.first, &read_fds);
138       max_read_fd = std::max(max_read_fd, it.first);
139     }
141     struct timeval timeout;
142     struct timeval* timeout_ptr = NULL;
143     if (timeout_ms_ > std::chrono::milliseconds(0)) {
144       timeout.tv_sec = timeout_ms_.count() / 1000;
145       timeout.tv_usec = (timeout_ms_.count() % 1000) * 1000;
146       timeout_ptr = &timeout;
147     }
149     // Wait until there is data available to read on some FD.
150     int nfds = std::max(notification_listen_fd_, max_read_fd);
151     int retval = select(nfds + 1, &read_fds, NULL, NULL, timeout_ptr);
153     // There was some error.
154     if (retval < 0) continue;
156     // Timeout.
157     if (retval == 0) {
158       // Allow the timeout callback to modify the timeout.
159       TimeoutCallback saved_cb;
160       {
161         std::unique_lock<std::mutex> guard(timeout_mutex_);
162         if (timeout_ms_ > std::chrono::milliseconds(0))
163           saved_cb = timeout_cb_;
164       }
165       if (saved_cb != nullptr)
166         saved_cb();
167       continue;
168     }
170     // Read data from the notification FD.
171     if (FD_ISSET(notification_listen_fd_, &read_fds)) {
172       char buffer[] = {0};
173       TEMP_FAILURE_RETRY(read(notification_listen_fd_, buffer, 1));
174       continue;
175     }
177     // Invoke the data ready callbacks if appropriate.
178     {
179       // Hold the mutex to make sure that the callbacks are still valid.
180       std::unique_lock<std::mutex> guard(internal_mutex_);
181       for (auto& it : watched_fds_) {
182         if (FD_ISSET(it.first, &read_fds)) {
183         it.second(it.first);
184         }
185       }
186     }
187   }
190 } // namespace async
191 } // namespace bluetooth
192 } // namespace hardware
193 } // namespace android