ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "Move libbinderwrapper to update_engine"

Browse source
This commit is contained in:
Kelvin Zhang 2023-07-06 02:45:14 +00:00 • committed by Gerrit Code Review
commit 314e70966a
9 changed files with 0 additions and 682 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
libbinderwrapper/Android.bp
View file

@ -1,63 +0,0 @@
//
// Copyright (C) 2015 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.
//
package {
default_applicable_licenses: ["Android-Apache-2.0"],
}
cc_defaults {
name: "libbinderwrapper_defaults",
cflags: [
"-Wall",
"-Werror",
"-Wno-unused-parameter",
],
export_include_dirs: ["include"],
shared_libs: [
"libbinder",
"libutils",
],
}
// libbinderwrapper shared library
// ========================================================
cc_library_shared {
name: "libbinderwrapper",
defaults: ["libbinderwrapper_defaults"],
vendor_available: true,
srcs: [
"binder_wrapper.cc",
"real_binder_wrapper.cc",
],
}
// libbinderwrapper_test_support static library
// ========================================================
cc_library_static {
name: "libbinderwrapper_test_support",
defaults: ["libbinderwrapper_defaults"],
static_libs: ["libgtest"],
shared_libs: ["libbinderwrapper"],
srcs: [
"binder_test_base.cc",
"stub_binder_wrapper.cc",
],
}

33
libbinderwrapper/binder_test_base.cc
View file

@ -1,33 +0,0 @@
/*
* Copyright (C) 2015 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 <binderwrapper/binder_test_base.h>
#include <binderwrapper/binder_wrapper.h>
#include <binderwrapper/stub_binder_wrapper.h>
namespace android {
BinderTestBase::BinderTestBase() : binder_wrapper_(new StubBinderWrapper()) {
// Pass ownership.
BinderWrapper::InitForTesting(binder_wrapper_);
}
BinderTestBase::~BinderTestBase() {
BinderWrapper::Destroy();
}
} // namespace android

60
libbinderwrapper/binder_wrapper.cc
View file

@ -1,60 +0,0 @@
/*
* Copyright (C) 2015 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 <binderwrapper/binder_wrapper.h>
#include <android-base/logging.h>
#include "real_binder_wrapper.h"
namespace android {
// Singleton instance.
BinderWrapper* BinderWrapper::instance_ = nullptr;
// static
void BinderWrapper::Create() {
CHECK(!instance_) << "Already initialized; missing call to Destroy()?";
instance_ = new RealBinderWrapper();
}
// static
void BinderWrapper::InitForTesting(BinderWrapper* wrapper) {
CHECK(!instance_) << "Already initialized; missing call to Destroy()?";
instance_ = wrapper;
}
// static
void BinderWrapper::Destroy() {
CHECK(instance_) << "Not initialized; missing call to Create()?";
delete instance_;
instance_ = nullptr;
}
// static
BinderWrapper* BinderWrapper::Get() {
CHECK(instance_) << "Not initialized; missing call to Create()?";
return instance_;
}
// static
BinderWrapper* BinderWrapper::GetOrCreateInstance() {
if (!instance_)
instance_ = new RealBinderWrapper();
return instance_;
}
} // namespace android

44
libbinderwrapper/include/binderwrapper/binder_test_base.h
View file

@ -1,44 +0,0 @@
/*
* Copyright (C) 2015 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.
*/
#ifndef SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_
#define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_
#include <gtest/gtest.h>
namespace android {
class StubBinderWrapper;
// Class that can be inherited from (or aliased via typedef/using) when writing
// tests that use StubBinderManager.
class BinderTestBase : public ::testing::Test {
public:
BinderTestBase();
~BinderTestBase() override;
StubBinderWrapper* binder_wrapper() { return binder_wrapper_; }
protected:
StubBinderWrapper* binder_wrapper_; // Not owned.
private:
BinderTestBase(const BinderTestBase&) = delete;
};
} // namespace android
#endif // SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_

87
libbinderwrapper/include/binderwrapper/binder_wrapper.h
View file

@ -1,87 +0,0 @@
/*
* Copyright (C) 2015 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.
*/
#ifndef SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_WRAPPER_H_
#define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_WRAPPER_H_
#include <sys/types.h>
#include <functional>
#include <string>
#include <utils/StrongPointer.h>
namespace android {
class BBinder;
class IBinder;
// Wraps libbinder to make it testable.
// NOTE: Static methods of this class are not thread-safe.
class BinderWrapper {
public:
virtual ~BinderWrapper() {}
// Creates and initializes the singleton (using a wrapper that communicates
// with the real binder system).
static void Create();
// Initializes |wrapper| as the singleton, taking ownership of it. Tests that
// want to inject their own wrappers should call this instead of Create().
static void InitForTesting(BinderWrapper* wrapper);
// Destroys the singleton. Must be called before calling Create() or
// InitForTesting() a second time.
static void Destroy();
// Returns the singleton instance previously created by Create() or set by
// InitForTesting().
static BinderWrapper* Get();
// Returns the singleton instance if it was previously created by Create() or
// set by InitForTesting(), or creates a new one by calling Create().
static BinderWrapper* GetOrCreateInstance();
// Gets the binder for communicating with the service identified by
// |service_name|, returning null immediately if it doesn't exist.
virtual sp<IBinder> GetService(const std::string& service_name) = 0;
// Registers |binder| as |service_name| with the service manager.
virtual bool RegisterService(const std::string& service_name,
const sp<IBinder>& binder) = 0;
// Creates a local binder object.
virtual sp<BBinder> CreateLocalBinder() = 0;
// Registers |callback| to be invoked when |binder| dies. If another callback
// is currently registered for |binder|, it will be replaced.
virtual bool RegisterForDeathNotifications(const sp<IBinder>& binder,
const std::function<void()>&) = 0;
// Unregisters the callback, if any, for |binder|.
virtual bool UnregisterForDeathNotifications(const sp<IBinder>& binder) = 0;
// When called while in a transaction, returns the caller's UID or PID.
virtual uid_t GetCallingUid() = 0;
virtual pid_t GetCallingPid() = 0;
private:
static BinderWrapper* instance_;
};
} // namespace android
#endif // SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_WRAPPER_H_

132
libbinderwrapper/include/binderwrapper/stub_binder_wrapper.h
View file

@ -1,132 +0,0 @@
/*
* Copyright (C) 2015 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.
*/
#ifndef SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
#define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
#include <map>
#include <string>
#include <vector>
#include <binder/Binder.h>
#include <binder/IBinder.h>
#include <binderwrapper/binder_wrapper.h>
namespace android {
// Stub implementation of BinderWrapper for testing.
//
// Example usage:
//
// First, assuming a base IFoo binder interface, create a stub class that
// derives from BnFoo to implement the receiver side of the communication:
//
// class StubFoo : public BnFoo {
// public:
// ...
// status_t doSomething(int arg) override {
// // e.g. save passed-in value for later inspection by tests.
// return OK;
// }
// };
//
// Next, from your test code, inject a StubBinderManager either directly or by
// inheriting from the BinderTestBase class:
//
// StubBinderWrapper* wrapper = new StubBinderWrapper();
// BinderWrapper::InitForTesting(wrapper); // Takes ownership.
//
// Also from your test, create a StubFoo and register it with the wrapper:
//
// StubFoo* foo = new StubFoo();
// sp<IBinder> binder(foo);
// wrapper->SetBinderForService("foo", binder);
//
// The code being tested can now use the wrapper to get the stub and call it:
//
// sp<IBinder> binder = BinderWrapper::Get()->GetService("foo");
// CHECK(binder.get());
// sp<IFoo> foo = interface_cast<IFoo>(binder);
// CHECK_EQ(foo->doSomething(3), OK);
//
// To create a local BBinder object, production code can call
// CreateLocalBinder(). Then, a test can get the BBinder's address via
// local_binders() to check that they're passed as expected in binder calls.
//
class StubBinderWrapper : public BinderWrapper {
public:
StubBinderWrapper();
~StubBinderWrapper() override;
const std::vector<sp<BBinder>>& local_binders() const {
return local_binders_;
}
void clear_local_binders() { local_binders_.clear(); }
void set_calling_uid(uid_t uid) { calling_uid_ = uid; }
void set_calling_pid(pid_t pid) { calling_pid_ = pid; }
// Sets the binder to return when |service_name| is passed to GetService() or
// WaitForService().
void SetBinderForService(const std::string& service_name,
const sp<IBinder>& binder);
// Returns the binder previously registered for |service_name| via
// RegisterService(), or null if the service hasn't been registered.
sp<IBinder> GetRegisteredService(const std::string& service_name) const;
// Run the calback in |death_callbacks_| corresponding to |binder|.
void NotifyAboutBinderDeath(const sp<IBinder>& binder);
// BinderWrapper:
sp<IBinder> GetService(const std::string& service_name) override;
bool RegisterService(const std::string& service_name,
const sp<IBinder>& binder) override;
sp<BBinder> CreateLocalBinder() override;
bool RegisterForDeathNotifications(const sp<IBinder>& binder,
const std::function<void()>& callback) override;
bool UnregisterForDeathNotifications(const sp<IBinder>& binder) override;
uid_t GetCallingUid() override;
pid_t GetCallingPid() override;
private:
using ServiceMap = std::map<std::string, sp<IBinder>>;
// Map from service name to associated binder handle. Used by GetService() and
// WaitForService().
ServiceMap services_to_return_;
// Map from service name to associated binder handle. Updated by
// RegisterService().
ServiceMap registered_services_;
// Local binders returned by CreateLocalBinder().
std::vector<sp<BBinder>> local_binders_;
// Map from binder handle to the callback that should be invoked on binder
// death.
std::map<sp<IBinder>, std::function<void()>> death_callbacks_;
// Values to return from GetCallingUid() and GetCallingPid();
uid_t calling_uid_;
pid_t calling_pid_;
StubBinderWrapper(const StubBinderWrapper&) = delete;
};
} // namespace android
#endif // SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_

121
libbinderwrapper/real_binder_wrapper.cc
View file

@ -1,121 +0,0 @@
/*
* Copyright (C) 2015 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 "real_binder_wrapper.h"
#include <android-base/logging.h>
#include <binder/Binder.h>
#include <binder/IBinder.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
namespace android {
// Class that handles binder death notifications. libbinder wants the recipient
// to be wrapped in sp<>, so registering RealBinderWrapper as a recipient would
// be awkward.
class RealBinderWrapper::DeathRecipient : public IBinder::DeathRecipient {
public:
explicit DeathRecipient(const std::function<void()>& callback)
: callback_(std::move(callback)) {}
~DeathRecipient() = default;
// IBinder::DeathRecipient:
void binderDied(const wp<IBinder>& who) override { callback_(); }
private:
// Callback to run in response to binder death.
std::function<void()> callback_;
DISALLOW_COPY_AND_ASSIGN(DeathRecipient);
};
RealBinderWrapper::RealBinderWrapper() = default;
RealBinderWrapper::~RealBinderWrapper() = default;
sp<IBinder> RealBinderWrapper::GetService(const std::string& service_name) {
sp<IServiceManager> service_manager = defaultServiceManager();
if (!service_manager.get()) {
LOG(ERROR) << "Unable to get service manager";
return sp<IBinder>();
}
sp<IBinder> binder =
service_manager->checkService(String16(service_name.c_str()));
if (!binder.get())
LOG(ERROR) << "Unable to get \"" << service_name << "\" service";
return binder;
}
bool RealBinderWrapper::RegisterService(const std::string& service_name,
const sp<IBinder>& binder) {
sp<IServiceManager> service_manager = defaultServiceManager();
if (!service_manager.get()) {
LOG(ERROR) << "Unable to get service manager";
return false;
}
status_t status = defaultServiceManager()->addService(
String16(service_name.c_str()), binder);
if (status != OK) {
LOG(ERROR) << "Failed to register \"" << service_name << "\" with service "
<< "manager";
return false;
}
return true;
}
sp<BBinder> RealBinderWrapper::CreateLocalBinder() {
return sp<BBinder>(new BBinder());
}
bool RealBinderWrapper::RegisterForDeathNotifications(const sp<IBinder>& binder,
const std::function<void()>& callback) {
sp<DeathRecipient> recipient(new DeathRecipient(callback));
if (binder->linkToDeath(recipient) != OK) {
LOG(ERROR) << "Failed to register for death notifications on "
<< binder.get();
return false;
}
death_recipients_[binder] = recipient;
return true;
}
bool RealBinderWrapper::UnregisterForDeathNotifications(
const sp<IBinder>& binder) {
auto it = death_recipients_.find(binder);
if (it == death_recipients_.end()) {
LOG(ERROR) << "Not registered for death notifications on " << binder.get();
return false;
}
if (binder->unlinkToDeath(it->second) != OK) {
LOG(ERROR) << "Failed to unregister for death notifications on "
<< binder.get();
return false;
}
death_recipients_.erase(it);
return true;
}
uid_t RealBinderWrapper::GetCallingUid() {
return IPCThreadState::self()->getCallingUid();
}
pid_t RealBinderWrapper::GetCallingPid() {
return IPCThreadState::self()->getCallingPid();
}
} // namespace android

57
libbinderwrapper/real_binder_wrapper.h
View file

@ -1,57 +0,0 @@
/*
* Copyright (C) 2015 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.
*/
#ifndef SYSTEM_CORE_LIBBINDERWRAPPER_REAL_BINDER_WRAPPER_H_
#define SYSTEM_CORE_LIBBINDERWRAPPER_REAL_BINDER_WRAPPER_H_
#include <map>
#include <binderwrapper/binder_wrapper.h>
namespace android {
class IBinder;
// Real implementation of BinderWrapper.
class RealBinderWrapper : public BinderWrapper {
public:
RealBinderWrapper();
~RealBinderWrapper() override;
// BinderWrapper:
sp<IBinder> GetService(const std::string& service_name) override;
bool RegisterService(const std::string& service_name,
const sp<IBinder>& binder) override;
sp<BBinder> CreateLocalBinder() override;
bool RegisterForDeathNotifications(const sp<IBinder>& binder,
const std::function<void()>& callback) override;
bool UnregisterForDeathNotifications(const sp<IBinder>& binder) override;
uid_t GetCallingUid() override;
pid_t GetCallingPid() override;
private:
class DeathRecipient;
// Map from binder handle to object that should be notified of the binder's
// death.
std::map<sp<IBinder>, sp<DeathRecipient>> death_recipients_;
RealBinderWrapper(const RealBinderWrapper&) = delete;
};
} // namespace android
#endif // SYSTEM_CORE_LIBBINDER_WRAPPER_REAL_BINDER_WRAPPER_H_

85
libbinderwrapper/stub_binder_wrapper.cc
View file

@ -1,85 +0,0 @@
/*
* Copyright (C) 2015 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 <binderwrapper/stub_binder_wrapper.h>
#include <android-base/logging.h>
#include <binder/Binder.h>
#include <binder/IBinder.h>
namespace android {
StubBinderWrapper::StubBinderWrapper()
: calling_uid_(-1),
calling_pid_(-1) {}
StubBinderWrapper::~StubBinderWrapper() = default;
void StubBinderWrapper::SetBinderForService(const std::string& service_name,
const sp<IBinder>& binder) {
services_to_return_[service_name] = binder;
}
sp<IBinder> StubBinderWrapper::GetRegisteredService(
const std::string& service_name) const {
const auto it = registered_services_.find(service_name);
return it != registered_services_.end() ? it->second : sp<IBinder>();
}
void StubBinderWrapper::NotifyAboutBinderDeath(const sp<IBinder>& binder) {
const auto it = death_callbacks_.find(binder);
if (it != death_callbacks_.end()) it->second();
}
sp<IBinder> StubBinderWrapper::GetService(const std::string& service_name) {
const auto it = services_to_return_.find(service_name);
return it != services_to_return_.end() ? it->second : sp<IBinder>();
}
bool StubBinderWrapper::RegisterService(const std::string& service_name,
const sp<IBinder>& binder) {
registered_services_[service_name] = binder;
return true;
}
sp<BBinder> StubBinderWrapper::CreateLocalBinder() {
sp<BBinder> binder(new BBinder());
local_binders_.push_back(binder);
return binder;
}
bool StubBinderWrapper::RegisterForDeathNotifications(const sp<IBinder>& binder,
const std::function<void()>& callback) {
death_callbacks_[binder] = callback;
return true;
}
bool StubBinderWrapper::UnregisterForDeathNotifications(
const sp<IBinder>& binder) {
death_callbacks_.erase(binder);
return true;
}
uid_t StubBinderWrapper::GetCallingUid() {
return calling_uid_;
}
pid_t StubBinderWrapper::GetCallingPid() {
return calling_pid_;
}
} // namespace android