looper_backed_event_loop.cpp

   1 /*
   2  * Copyright (C) 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  */
  16
  17 #include "wificond/looper_backed_event_loop.h"
  18
  19 #include <android-base/logging.h>
  20 #include <utils/Looper.h>
  21 #include <utils/Timers.h>
  22
  23 namespace {
  24
  25 class EventLoopCallback : public android::MessageHandler {
  26  public:
  27   explicit EventLoopCallback(const std::function<void()>& callback)
  28       : callback_(callback) {
  29   }
  30
  31   ~EventLoopCallback() override = default;
  32
  33   virtual void handleMessage(const android::Message& message) {
  34     callback_();
  35   }
  36
  37  private:
  38   const std::function<void()> callback_;
  39
  40   DISALLOW_COPY_AND_ASSIGN(EventLoopCallback);
  41 };
  42
  43 class WatchFdCallback : public android::LooperCallback {
  44  public:
  45   explicit WatchFdCallback(const std::function<void(int)>& callback)
  46       : callback_(callback) {
  47   }
  48
  49   ~WatchFdCallback() override = default;
  50
  51   virtual int handleEvent(int fd, int events, void* data) {
  52     callback_(fd);
  53     // Returning 1 means Looper keeps watching this file descriptor after
  54     // callback is called.
  55     // See Looper.h for details.
  56     return 1;
  57   }
  58
  59  private:
  60   const std::function<void(int)> callback_;
  61
  62   DISALLOW_COPY_AND_ASSIGN(WatchFdCallback);
  63 };
  64
  65 }  // namespace
  66
  67 namespace android {
  68 namespace wificond {
  69
  70
  71 LooperBackedEventLoop::LooperBackedEventLoop()
  72     : should_continue_(true) {
  73   looper_ = android::Looper::prepare(Looper::PREPARE_ALLOW_NON_CALLBACKS);
  74 }
  75
  76 LooperBackedEventLoop::~LooperBackedEventLoop() {
  77 }
  78
  79 void LooperBackedEventLoop::PostTask(const std::function<void()>& callback) {
  80   sp<android::MessageHandler> event_loop_callback =
  81       new EventLoopCallback(callback);
  82   looper_->sendMessage(event_loop_callback, NULL);
  83 }
  84
  85 void LooperBackedEventLoop::PostDelayedTask(
  86     const std::function<void()>& callback,
  87     int64_t delay_ms) {
  88   sp<android::MessageHandler> looper_callback = new EventLoopCallback(callback);
  89   looper_->sendMessageDelayed(ms2ns(delay_ms), looper_callback, NULL);
  90 }
  91
  92 bool LooperBackedEventLoop::WatchFileDescriptor(
  93     int fd,
  94     ReadyMode mode,
  95     const std::function<void(int)>& callback) {
  96   sp<android::LooperCallback>  watch_fd_callback = new WatchFdCallback(callback);
  97   int event;
  98   if (mode == kModeInput) {
  99     event = Looper::EVENT_INPUT;
 100   } else if (mode == kModeOutput) {
 101     event = Looper::EVENT_OUTPUT;
 102   } else {
 103     LOG(ERROR) << "Invalid mode for WatchFileDescriptor().";
 104     return false;
 105   }
 106   // addFd() returns 1 if descriptor was added, 0 if arguments were invalid.
 107   // Since we are using non-NULL callback, the second parameter 'ident' will
 108   // always be ignored. It is OK to use 0 for 'ident'.
 109   // See Looper.h for more details.
 110   if (looper_->addFd(fd, 0, event, watch_fd_callback, NULL) == 0) {
 111     LOG(ERROR) << "Invalid arguments for Looper::addFd().";
 112     return false;
 113   }
 114   return true;
 115 }
 116
 117 bool LooperBackedEventLoop::StopWatchFileDescriptor(int fd) {
 118   if (looper_->removeFd(fd) == 1) {
 119     return true;
 120   }
 121   return false;
 122 }
 123
 124 void LooperBackedEventLoop::Poll() {
 125   while (should_continue_) {
 126     looper_->pollOnce(-1);
 127   }
 128 }
 129
 130 void LooperBackedEventLoop::PollForOne(int timeout_millis) {
 131   looper_->pollOnce(timeout_millis);
 132 }
 133
 134 void LooperBackedEventLoop::TriggerExit() {
 135   PostTask([this](){ should_continue_ = false; });
 136 }
 137
 138 }  // namespace wificond
 139 }  // namespace android