blob: a6f640917bf2232f5497fd053f27381c18a1782e [file] [log] [blame]
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "binder/iiorap_impl.h"
#include "binder/iiorap_def.h"
#include "common/macros.h"
#include "manager/event_manager.h"
#include <android-base/logging.h>
#include <android-base/properties.h>
#include <binder/BinderService.h>
#include <binder/IPCThreadState.h>
#include <include/binder/request_id.h>
/*
* Definitions for the IIorap binder native service implementation.
* See also IIorap.aidl.
*/
using Status = ::android::binder::Status;
using ITaskListener = ::com::google::android::startop::iorap::ITaskListener;
namespace iorap {
namespace binder {
namespace {
// Forward declarations.
template<typename ... Args>
Status Send(const char* function_name, Args&& ... args);
}
// Join all parameter declarations by splitting each parameter with a comma.
// Types are used fully.
#define IIORAP_IMPL_ARG_DECLARATIONS(...) \
IORAP_PP_MAP_SEP(IORAP_BINDER_PARAM_JOIN_ALL, IORAP_PP_COMMA, __VA_ARGS__)
#define IIORAP_IMPL_ARG_NAMES(...) \
IORAP_PP_MAP_SEP(IORAP_BINDER_PARAM_JOIN_NAMES, IORAP_PP_COMMA, __VA_ARGS__)
#define IIORAP_IMPL_BODY(name, ...) \
::android::binder::Status IIorapImpl::name(IIORAP_IMPL_ARG_DECLARATIONS(__VA_ARGS__)) { \
return Send(#name, impl_.get(), IIORAP_IMPL_ARG_NAMES(__VA_ARGS__)); \
}
IIORAP_IFACE_DEF(/*begin*/IORAP_PP_NOP, IIORAP_IMPL_BODY, /*end*/IORAP_PP_NOP);
#undef IIORAP_IMPL_BODY
#undef IIORAP_IMPL_ARG_NAMES
#undef IIORAP_IMPL_ARGS
namespace {
struct ServiceParams {
bool fake_{false};
std::shared_ptr<manager::EventManager> event_manager_;
};
static std::atomic<bool> s_service_started_{false};
static std::atomic<bool> s_service_params_ready_{false};
// TODO: BinderService constructs IIorapImpl,
// but how do I get a pointer to it afterwards?
//
// This is a workaround for that, by using a global.
static ServiceParams s_service_params_;
static std::atomic<ServiceParams*> s_service_params_atomic_;
} // namespace anonymous
class IIorapImpl::Impl {
public:
void SetTaskListener(const ::android::sp<ITaskListener>& listener) {
::android::sp<ITaskListener> old_listener = listener_;
if (old_listener != nullptr && listener != nullptr) {
LOG(WARNING) << "IIorap::setTaskListener: already had a task listener set";
}
listener_ = listener;
}
void ReplyWithResult(const RequestId& request_id, TaskResult::State result_state) {
::android::sp<ITaskListener> listener = listener_;
if (listener == nullptr) {
// No listener. Cannot send anything back to the client.
// This could be normal, e.g. client had set listener to null before disconnecting.
LOG(WARNING) << "Drop result, no listener registered.";
// TODO: print the result with ostream operator<<
return;
}
TaskResult result;
result.state = result_state;
// TODO: verbose, not info.
if (result_state == TaskResult::State::kCompleted) {
LOG(VERBOSE) << "ITaskListener::onComplete (request_id=" << request_id.request_id << ")";
listener->onComplete(request_id, result);
} else {
LOG(VERBOSE) << "ITaskListener::onProgress (request_id=" << request_id.request_id << ")";
listener->onProgress(request_id, result);
}
}
bool OnAppLaunchEvent(const RequestId& request_id,
const AppLaunchEvent& event) {
if (MaybeHandleFakeBehavior(request_id)) {
return true;
}
return service_params_.event_manager_->OnAppLaunchEvent(request_id, event);
}
void HandleFakeBehavior(const RequestId& request_id) {
DCHECK(service_params_.fake_);
// Send these dummy callbacks for testing only.
ReplyWithResult(request_id, TaskResult::State::kBegan);
ReplyWithResult(request_id, TaskResult::State::kOngoing);
ReplyWithResult(request_id, TaskResult::State::kCompleted);
}
// TODO: Subclass IIorap with a separate fake implementation.
bool MaybeHandleFakeBehavior(const RequestId& request_id) {
if (service_params_.fake_) {
HandleFakeBehavior(request_id);
return true;
}
return false;
}
::android::sp<ITaskListener> listener_;
Impl(ServiceParams p) : service_params_{std::move(p)} {
CHECK(service_params_.event_manager_ != nullptr);
}
ServiceParams service_params_;
};
using Impl = IIorapImpl::Impl;
IIorapImpl::IIorapImpl() {
// Acquire edge of synchronizes-with IIorapImpl::Start().
CHECK(s_service_params_ready_.load());
// Do not turn this into a DCHECK, the above atomic load
// must happen-before the read of s_service_params_ready_.
impl_.reset(new Impl(std::move(s_service_params_)));
}
namespace {
static bool started_ = false;
}
bool IIorapImpl::Start(std::shared_ptr<manager::EventManager> event_manager) {
if (s_service_started_.load()) { // Acquire-edge (see bottom of function).
// Note: Not meant to be idempotent. Two threads could race, and the second
// one would likely fail the publish.
LOG(ERROR) << "service was already started";
return false; // Already started
}
CHECK(event_manager != nullptr);
{
// This block of code needs to happen-before IIorapImpl::IIorapImpl.
// TODO: There should be a simpler way of passing down
// this data which doesn't involve globals and memory synchronization.
ServiceParams* p = &s_service_params_;
// TODO: move all property reads to a dedicated Config class.
p->fake_ = ::android::base::GetBoolProperty("iorapd.binder.fake", /*default*/false);
p->event_manager_ = std::move(event_manager);
// Release edge of synchronizes-with IIorapImpl::IIorapImpl.
s_service_params_ready_.store(true);
}
::android::IPCThreadState::self()->disableBackgroundScheduling(/*disable*/true);
::android::status_t ret = android::BinderService<IIorapImpl>::publish();
if (ret != android::OK) {
LOG(ERROR) << "BinderService::publish failed with error code: " << ret;
return false;
}
android::sp<android::ProcessState> ps = android::ProcessState::self();
// Reduce thread consumption by only using 1 thread.
// We should also be able to leverage this by avoiding locks, etc.
ps->setThreadPoolMaxThreadCount(/*maxThreads*/1);
ps->startThreadPool();
ps->giveThreadPoolName();
// Release edge synchronizes-with the top of this function.
s_service_started_.store(true);
return true;
}
namespace {
#define MAYBE_HAVE_FAKE_BEHAVIOR(self, request_id) \
if (self->MaybeHandleFakeBehavior(request_id)) { return ::android::binder::Status::ok(); }
template <typename ... Args>
Status SendArgs(const char* function_name,
Impl* self,
const RequestId& request_id,
Args&&... /*rest*/) {
LOG(VERBOSE) << "IIorap::" << function_name << " (request_id = " << request_id.request_id << ")";
MAYBE_HAVE_FAKE_BEHAVIOR(self, request_id);
// TODO: implementation.
LOG(ERROR) << "IIorap::" << function_name << " -- not implemented for real code";
return Status::fromStatusT(::android::INVALID_OPERATION);
}
template <typename ... Args>
Status SendArgs(const char* function_name, Impl* self, Args&&... rest) {
DCHECK_EQ(std::string(function_name), "setTaskListener");
LOG(VERBOSE) << "IIorap::setTaskListener";
self->SetTaskListener(std::forward<Args&&>(rest)...);
return Status::ok();
}
template <typename ... Args>
Status SendArgs(const char* function_name,
Impl* self,
const RequestId& request_id,
const AppLaunchEvent& app_launch_event) {
DCHECK_EQ(std::string(function_name), "onAppLaunchEvent");
LOG(VERBOSE) << "IIorap::onAppLaunchEvent";
MAYBE_HAVE_FAKE_BEHAVIOR(self, request_id);
if (self->OnAppLaunchEvent(request_id, app_launch_event)) {
return Status::ok();
} else {
// TODO: I suppose this should write out an exception back,
// like a service-specific error or something.
//
// It depends on whether or not we even have any synchronous
// errors.
//
// Most of the work here is done async, so it should handle
// async callbacks.
return Status::fromStatusT(::android::BAD_VALUE);
}
}
template <typename ... Args>
Status Send(const char* function_name, Args&&... args) {
LOG(VERBOSE) << "IIorap::Send(" << function_name << ")";
return SendArgs(function_name, std::forward<Args>(args)...);
}
} // namespace <anonymous>
} // namespace binder
} // namespace iorap