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 <condition_variable>
18 #include <chrono>
19 #include <functional>
20 #include <mutex>
21 #include <thread>
22
23 #include <hidl/Status.h>
24
25 namespace android {
26 namespace lshal {
27
28 static constexpr std::chrono::milliseconds IPC_CALL_WAIT{500};
29
30 class BackgroundTaskState {
31 public:
BackgroundTaskState(std::function<void (void)> && func)32 explicit BackgroundTaskState(std::function<void(void)> &&func)
33 : mFunc(std::forward<decltype(func)>(func)) {}
notify()34 void notify() {
35 std::unique_lock<std::mutex> lock(mMutex);
36 mFinished = true;
37 lock.unlock();
38 mCondVar.notify_all();
39 }
40 template<class C, class D>
wait(std::chrono::time_point<C,D> end)41 bool wait(std::chrono::time_point<C, D> end) {
42 std::unique_lock<std::mutex> lock(mMutex);
43 mCondVar.wait_until(lock, end, [this](){ return this->mFinished; });
44 return mFinished;
45 }
operator()46 void operator()() {
47 mFunc();
48 }
49 private:
50 std::mutex mMutex;
51 std::condition_variable mCondVar;
52 bool mFinished = false;
53 std::function<void(void)> mFunc;
54 };
55
callAndNotify(void * data)56 void *callAndNotify(void *data) {
57 BackgroundTaskState &state = *static_cast<BackgroundTaskState *>(data);
58 state();
59 state.notify();
60 return nullptr;
61 }
62
63 template<class R, class P>
timeout(std::chrono::duration<R,P> delay,std::function<void (void)> && func)64 bool timeout(std::chrono::duration<R, P> delay, std::function<void(void)> &&func) {
65 auto now = std::chrono::system_clock::now();
66 BackgroundTaskState state{std::forward<decltype(func)>(func)};
67 pthread_t thread;
68 if (pthread_create(&thread, nullptr, callAndNotify, &state)) {
69 std::cerr << "FATAL: could not create background thread." << std::endl;
70 return false;
71 }
72 bool success = state.wait(now + delay);
73 if (!success) {
74 pthread_kill(thread, SIGINT);
75 }
76 pthread_join(thread, nullptr);
77 return success;
78 }
79
80 template<class R, class P, class Function, class I, class... Args>
81 typename std::result_of<Function(I *, Args...)>::type
timeoutIPC(std::chrono::duration<R,P> wait,const sp<I> & interfaceObject,Function && func,Args &&...args)82 timeoutIPC(std::chrono::duration<R, P> wait, const sp<I> &interfaceObject, Function &&func,
83 Args &&... args) {
84 using ::android::hardware::Status;
85 typename std::result_of<Function(I *, Args...)>::type ret{Status::ok()};
86 auto boundFunc = std::bind(std::forward<Function>(func),
87 interfaceObject.get(), std::forward<Args>(args)...);
88 bool success = timeout(wait, [&ret, &boundFunc] {
89 ret = std::move(boundFunc());
90 });
91 if (!success) {
92 return Status::fromStatusT(TIMED_OUT);
93 }
94 return ret;
95 }
96
97 template<class Function, class I, class... Args>
98 typename std::result_of<Function(I *, Args...)>::type
timeoutIPC(const sp<I> & interfaceObject,Function && func,Args &&...args)99 timeoutIPC(const sp<I> &interfaceObject, Function &&func, Args &&... args) {
100 return timeoutIPC(IPC_CALL_WAIT, interfaceObject, func, args...);
101 }
102
103
104 } // namespace lshal
105 } // namespace android
106