libbinder: support exporting fewer symbols
This commit explicitly marks symbols in the code with default visibility
if they should be part of the libbinder ABI. Later, we'll set the
default symbol visibility to hidden and so any symbols not explicitly
marked as exported will be hidden.
We are still overexporting symbols a bit. When `LIBBINDER_EXPORTED` is
applied to a class, it exports all of that class's symbols. I've tried
to only export class members, but in a few cases it didn't seem worth
the trouble, e.g. where all the members need to be exported.
Additionally, we are exporting some symbols only needed by binder test
binaries. Since those tests run against the standard libbinder.so, we
need to include the symbols as part of the ABI.
On aarch64, this reduces the size of libbinder_on_trusty_mock.so by
10.7% and libbinder.so by 7.5%, primarily in the .text, .dynstr, and
.dynsym sections (but none of this takes effect until we actually
enabled it in a later commit).
Bug: 338458975
Test: TH
Change-Id: Idc348c2b12124a8bbcebeea49920267a995367b6
diff --git a/include/binder/Common.h b/include/binder/Common.h
new file mode 120000
index 0000000..940f89d
--- /dev/null
+++ b/include/binder/Common.h
@@ -0,0 +1 @@
+../../libs/binder/include/binder/Common.h
\ No newline at end of file
diff --git a/libs/binder/BufferedTextOutput.h b/libs/binder/BufferedTextOutput.h
index 57e03cb..1c074e6 100644
--- a/libs/binder/BufferedTextOutput.h
+++ b/libs/binder/BufferedTextOutput.h
@@ -24,8 +24,7 @@
// ---------------------------------------------------------------------------
namespace android {
-class BufferedTextOutput : public TextOutput
-{
+class LIBBINDER_INTERNAL_EXPORTED BufferedTextOutput : public TextOutput {
public:
//** Flags for constructor */
enum {
diff --git a/libs/binder/Debug.h b/libs/binder/Debug.h
index 262dfba..c3d03f8 100644
--- a/libs/binder/Debug.h
+++ b/libs/binder/Debug.h
@@ -20,6 +20,8 @@
#include <sys/types.h>
#include <string>
+#include <binder/Common.h>
+
namespace android {
// ---------------------------------------------------------------------------
@@ -35,7 +37,8 @@
size_t alignment=0, bool cArrayStyle=false,
debugPrintFunc func = nullptr, void* cookie = nullptr);
-extern "C" ssize_t getBinderKernelReferences(size_t count, uintptr_t* buf);
+// Used by libmemunreachable.
+extern "C" LIBBINDER_EXPORTED ssize_t getBinderKernelReferences(size_t count, uintptr_t* buf);
// ---------------------------------------------------------------------------
} // namespace android
diff --git a/libs/binder/FdTrigger.h b/libs/binder/FdTrigger.h
index e4a0283..78cdaaa 100644
--- a/libs/binder/FdTrigger.h
+++ b/libs/binder/FdTrigger.h
@@ -25,7 +25,7 @@
namespace android {
/** This is not a pipe. */
-class FdTrigger {
+class LIBBINDER_INTERNAL_EXPORTED FdTrigger {
public:
/** Returns nullptr for error case */
static std::unique_ptr<FdTrigger> make();
diff --git a/libs/binder/OS.h b/libs/binder/OS.h
index 0035aeb..5703eb7 100644
--- a/libs/binder/OS.h
+++ b/libs/binder/OS.h
@@ -24,8 +24,8 @@
namespace android::binder::os {
-void trace_begin(uint64_t tag, const char* name);
-void trace_end(uint64_t tag);
+LIBBINDER_EXPORTED void trace_begin(uint64_t tag, const char* name);
+LIBBINDER_EXPORTED void trace_end(uint64_t tag);
status_t setNonBlocking(borrowed_fd fd);
@@ -35,11 +35,13 @@
std::unique_ptr<RpcTransportCtxFactory> makeDefaultRpcTransportCtxFactory();
-ssize_t sendMessageOnSocket(const RpcTransportFd& socket, iovec* iovs, int niovs,
- const std::vector<std::variant<unique_fd, borrowed_fd>>* ancillaryFds);
+LIBBINDER_INTERNAL_EXPORTED ssize_t
+sendMessageOnSocket(const RpcTransportFd& socket, iovec* iovs, int niovs,
+ const std::vector<std::variant<unique_fd, borrowed_fd>>* ancillaryFds);
-ssize_t receiveMessageFromSocket(const RpcTransportFd& socket, iovec* iovs, int niovs,
- std::vector<std::variant<unique_fd, borrowed_fd>>* ancillaryFds);
+LIBBINDER_INTERNAL_EXPORTED ssize_t
+receiveMessageFromSocket(const RpcTransportFd& socket, iovec* iovs, int niovs,
+ std::vector<std::variant<unique_fd, borrowed_fd>>* ancillaryFds);
uint64_t GetThreadId();
diff --git a/libs/binder/OS_non_android_linux.cpp b/libs/binder/OS_non_android_linux.cpp
index b525d1a..01f3fe0 100644
--- a/libs/binder/OS_non_android_linux.cpp
+++ b/libs/binder/OS_non_android_linux.cpp
@@ -21,6 +21,8 @@
#include <syscall.h>
#include <cstdarg>
+#include <binder/Common.h>
+
#ifdef __ANDROID__
#error "This module is not intended for Android, just bare Linux"
#endif
@@ -47,7 +49,8 @@
} // namespace android::binder::os
-int __android_log_print(int /*prio*/, const char* /*tag*/, const char* fmt, ...) {
+LIBBINDER_EXPORTED int __android_log_print(int /*prio*/, const char* /*tag*/, const char* fmt,
+ ...) {
va_list args;
va_start(args, fmt);
vfprintf(stderr, fmt, args);
diff --git a/libs/binder/RpcState.h b/libs/binder/RpcState.h
index 8b84602..94013cc 100644
--- a/libs/binder/RpcState.h
+++ b/libs/binder/RpcState.h
@@ -149,8 +149,8 @@
*/
[[nodiscard]] status_t sendObituaries(const sp<RpcSession>& session);
- size_t countBinders();
- void dump();
+ LIBBINDER_INTERNAL_EXPORTED size_t countBinders();
+ LIBBINDER_INTERNAL_EXPORTED void dump();
/**
* Called when reading or writing data to a session fails to clean up
diff --git a/libs/binder/Utils.h b/libs/binder/Utils.h
index eec09eb..df8a4ce 100644
--- a/libs/binder/Utils.h
+++ b/libs/binder/Utils.h
@@ -21,6 +21,7 @@
#include <cstdint>
#include <optional>
+#include <binder/Common.h>
#include <log/log.h>
#include <utils/Errors.h>
@@ -111,6 +112,6 @@
//
// Hex values are printed in order, e.g. 0xDEAD will result in 'adde' because
// Android is little-endian.
-std::string HexString(const void* bytes, size_t len);
+LIBBINDER_INTERNAL_EXPORTED std::string HexString(const void* bytes, size_t len);
} // namespace android
diff --git a/libs/binder/UtilsHost.h b/libs/binder/UtilsHost.h
index d6fe9fa..03af1e7 100644
--- a/libs/binder/UtilsHost.h
+++ b/libs/binder/UtilsHost.h
@@ -24,6 +24,7 @@
#include <vector>
#include <android-base/macros.h>
+#include <binder/Common.h>
#include <binder/unique_fd.h>
#include <utils/Errors.h>
@@ -40,7 +41,7 @@
namespace android {
-struct CommandResult {
+struct LIBBINDER_EXPORTED CommandResult {
std::optional<int32_t> exitCode;
std::optional<int32_t> signal;
std::optional<pid_t> pid;
@@ -72,7 +73,7 @@
void operator=(const CommandResult&) = delete;
};
-std::ostream& operator<<(std::ostream& os, const CommandResult& res);
+LIBBINDER_EXPORTED std::ostream& operator<<(std::ostream& os, const CommandResult& res);
// Execute a command using tokens specified in @a argStringVec.
//
@@ -96,6 +97,7 @@
//
// If the parent process has encountered any errors for system calls, return ExecuteError with
// the proper errno set.
-std::optional<CommandResult> execute(std::vector<std::string> argStringVec,
- const std::function<bool(const CommandResult&)>& end);
+LIBBINDER_EXPORTED std::optional<CommandResult> execute(
+ std::vector<std::string> argStringVec,
+ const std::function<bool(const CommandResult&)>& end);
} // namespace android
diff --git a/libs/binder/include/binder/Binder.h b/libs/binder/include/binder/Binder.h
index 7a65ff4..135be89 100644
--- a/libs/binder/include/binder/Binder.h
+++ b/libs/binder/include/binder/Binder.h
@@ -18,6 +18,7 @@
#include <atomic>
#include <stdint.h>
+#include <binder/Common.h>
#include <binder/IBinder.h>
// ---------------------------------------------------------------------------
@@ -27,50 +28,47 @@
class Stability;
}
-class BBinder : public IBinder
-{
+class BBinder : public IBinder {
public:
- BBinder();
+ LIBBINDER_EXPORTED BBinder();
- virtual const String16& getInterfaceDescriptor() const;
- virtual bool isBinderAlive() const;
- virtual status_t pingBinder();
- virtual status_t dump(int fd, const Vector<String16>& args);
+ LIBBINDER_EXPORTED virtual const String16& getInterfaceDescriptor() const;
+ LIBBINDER_EXPORTED virtual bool isBinderAlive() const;
+ LIBBINDER_EXPORTED virtual status_t pingBinder();
+ LIBBINDER_EXPORTED virtual status_t dump(int fd, const Vector<String16>& args);
// NOLINTNEXTLINE(google-default-arguments)
- virtual status_t transact( uint32_t code,
- const Parcel& data,
- Parcel* reply,
- uint32_t flags = 0) final;
+ LIBBINDER_EXPORTED virtual status_t transact(uint32_t code, const Parcel& data, Parcel* reply,
+ uint32_t flags = 0) final;
// NOLINTNEXTLINE(google-default-arguments)
- virtual status_t linkToDeath(const sp<DeathRecipient>& recipient,
- void* cookie = nullptr,
- uint32_t flags = 0);
+ LIBBINDER_EXPORTED virtual status_t linkToDeath(const sp<DeathRecipient>& recipient,
+ void* cookie = nullptr, uint32_t flags = 0);
// NOLINTNEXTLINE(google-default-arguments)
- virtual status_t unlinkToDeath( const wp<DeathRecipient>& recipient,
- void* cookie = nullptr,
- uint32_t flags = 0,
- wp<DeathRecipient>* outRecipient = nullptr);
+ LIBBINDER_EXPORTED virtual status_t unlinkToDeath(const wp<DeathRecipient>& recipient,
+ void* cookie = nullptr, uint32_t flags = 0,
+ wp<DeathRecipient>* outRecipient = nullptr);
- virtual void* attachObject(const void* objectID, void* object, void* cleanupCookie,
- object_cleanup_func func) final;
- virtual void* findObject(const void* objectID) const final;
- virtual void* detachObject(const void* objectID) final;
- void withLock(const std::function<void()>& doWithLock);
- sp<IBinder> lookupOrCreateWeak(const void* objectID, IBinder::object_make_func make,
- const void* makeArgs);
+ LIBBINDER_EXPORTED virtual void* attachObject(const void* objectID, void* object,
+ void* cleanupCookie,
+ object_cleanup_func func) final;
+ LIBBINDER_EXPORTED virtual void* findObject(const void* objectID) const final;
+ LIBBINDER_EXPORTED virtual void* detachObject(const void* objectID) final;
+ LIBBINDER_EXPORTED void withLock(const std::function<void()>& doWithLock);
+ LIBBINDER_EXPORTED sp<IBinder> lookupOrCreateWeak(const void* objectID,
+ IBinder::object_make_func make,
+ const void* makeArgs);
- virtual BBinder* localBinder();
+ LIBBINDER_EXPORTED virtual BBinder* localBinder();
- bool isRequestingSid();
+ LIBBINDER_EXPORTED bool isRequestingSid();
// This must be called before the object is sent to another process. Not thread safe.
- void setRequestingSid(bool requestSid);
+ LIBBINDER_EXPORTED void setRequestingSid(bool requestSid);
- sp<IBinder> getExtension();
+ LIBBINDER_EXPORTED sp<IBinder> getExtension();
// This must be called before the object is sent to another process. Not thread safe.
- void setExtension(const sp<IBinder>& extension);
+ LIBBINDER_EXPORTED void setExtension(const sp<IBinder>& extension);
// This must be called before the object is sent to another process. Not thread safe.
//
@@ -84,35 +82,33 @@
// Appropriate values are:
// SCHED_NORMAL: -20 <= priority <= 19
// SCHED_RR/SCHED_FIFO: 1 <= priority <= 99
- void setMinSchedulerPolicy(int policy, int priority);
- int getMinSchedulerPolicy();
- int getMinSchedulerPriority();
+ LIBBINDER_EXPORTED void setMinSchedulerPolicy(int policy, int priority);
+ LIBBINDER_EXPORTED int getMinSchedulerPolicy();
+ LIBBINDER_EXPORTED int getMinSchedulerPriority();
// Whether realtime scheduling policies are inherited.
- bool isInheritRt();
+ LIBBINDER_EXPORTED bool isInheritRt();
// This must be called before the object is sent to another process. Not thread safe.
- void setInheritRt(bool inheritRt);
+ LIBBINDER_EXPORTED void setInheritRt(bool inheritRt);
- pid_t getDebugPid();
+ LIBBINDER_EXPORTED pid_t getDebugPid();
// Whether this binder has been sent to another process.
- bool wasParceled();
+ LIBBINDER_EXPORTED bool wasParceled();
// Consider this binder as parceled (setup/init-related calls should no
// longer by called. This is automatically set by when this binder is sent
// to another process.
- void setParceled();
+ LIBBINDER_EXPORTED void setParceled();
- [[nodiscard]] status_t setRpcClientDebug(binder::unique_fd clientFd,
- const sp<IBinder>& keepAliveBinder);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t setRpcClientDebug(binder::unique_fd clientFd,
+ const sp<IBinder>& keepAliveBinder);
protected:
- virtual ~BBinder();
+ LIBBINDER_EXPORTED virtual ~BBinder();
// NOLINTNEXTLINE(google-default-arguments)
- virtual status_t onTransact( uint32_t code,
- const Parcel& data,
- Parcel* reply,
- uint32_t flags = 0);
+ LIBBINDER_EXPORTED virtual status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply,
+ uint32_t flags = 0);
private:
BBinder(const BBinder& o);
@@ -142,17 +138,18 @@
// ---------------------------------------------------------------------------
-class BpRefBase : public virtual RefBase
-{
+class BpRefBase : public virtual RefBase {
protected:
- explicit BpRefBase(const sp<IBinder>& o);
- virtual ~BpRefBase();
- virtual void onFirstRef();
- virtual void onLastStrongRef(const void* id);
- virtual bool onIncStrongAttempted(uint32_t flags, const void* id);
+ LIBBINDER_EXPORTED explicit BpRefBase(const sp<IBinder>& o);
+ LIBBINDER_EXPORTED virtual ~BpRefBase();
+ LIBBINDER_EXPORTED virtual void onFirstRef();
+ LIBBINDER_EXPORTED virtual void onLastStrongRef(const void* id);
+ LIBBINDER_EXPORTED virtual bool onIncStrongAttempted(uint32_t flags, const void* id);
- inline IBinder* remote() const { return mRemote; }
- inline sp<IBinder> remoteStrong() const { return sp<IBinder>::fromExisting(mRemote); }
+ LIBBINDER_EXPORTED inline IBinder* remote() const { return mRemote; }
+ LIBBINDER_EXPORTED inline sp<IBinder> remoteStrong() const {
+ return sp<IBinder>::fromExisting(mRemote);
+ }
private:
BpRefBase(const BpRefBase& o);
diff --git a/libs/binder/include/binder/BpBinder.h b/libs/binder/include/binder/BpBinder.h
index 9f03907..8ac30ba 100644
--- a/libs/binder/include/binder/BpBinder.h
+++ b/libs/binder/include/binder/BpBinder.h
@@ -16,6 +16,7 @@
#pragma once
+#include <binder/Common.h>
#include <binder/IBinder.h>
#include <binder/RpcThreads.h>
#include <binder/unique_fd.h>
@@ -38,67 +39,64 @@
using binder_proxy_limit_callback = std::function<void(int)>;
using binder_proxy_warning_callback = std::function<void(int)>;
-class BpBinder : public IBinder
-{
+class BpBinder : public IBinder {
public:
/**
* Return value:
* true - this is associated with a socket RpcSession
* false - (usual) binder over e.g. /dev/binder
*/
- bool isRpcBinder() const;
+ LIBBINDER_EXPORTED bool isRpcBinder() const;
- virtual const String16& getInterfaceDescriptor() const;
- virtual bool isBinderAlive() const;
- virtual status_t pingBinder();
- virtual status_t dump(int fd, const Vector<String16>& args);
+ LIBBINDER_EXPORTED virtual const String16& getInterfaceDescriptor() const;
+ LIBBINDER_EXPORTED virtual bool isBinderAlive() const;
+ LIBBINDER_EXPORTED virtual status_t pingBinder();
+ LIBBINDER_EXPORTED virtual status_t dump(int fd, const Vector<String16>& args);
// NOLINTNEXTLINE(google-default-arguments)
- virtual status_t transact( uint32_t code,
- const Parcel& data,
- Parcel* reply,
- uint32_t flags = 0) final;
+ LIBBINDER_EXPORTED virtual status_t transact(uint32_t code, const Parcel& data, Parcel* reply,
+ uint32_t flags = 0) final;
// NOLINTNEXTLINE(google-default-arguments)
- virtual status_t linkToDeath(const sp<DeathRecipient>& recipient,
- void* cookie = nullptr,
- uint32_t flags = 0);
+ LIBBINDER_EXPORTED virtual status_t linkToDeath(const sp<DeathRecipient>& recipient,
+ void* cookie = nullptr, uint32_t flags = 0);
// NOLINTNEXTLINE(google-default-arguments)
- virtual status_t unlinkToDeath( const wp<DeathRecipient>& recipient,
- void* cookie = nullptr,
- uint32_t flags = 0,
- wp<DeathRecipient>* outRecipient = nullptr);
+ LIBBINDER_EXPORTED virtual status_t unlinkToDeath(const wp<DeathRecipient>& recipient,
+ void* cookie = nullptr, uint32_t flags = 0,
+ wp<DeathRecipient>* outRecipient = nullptr);
- virtual void* attachObject(const void* objectID, void* object, void* cleanupCookie,
- object_cleanup_func func) final;
- virtual void* findObject(const void* objectID) const final;
- virtual void* detachObject(const void* objectID) final;
- void withLock(const std::function<void()>& doWithLock);
- sp<IBinder> lookupOrCreateWeak(const void* objectID, IBinder::object_make_func make,
- const void* makeArgs);
+ LIBBINDER_EXPORTED virtual void* attachObject(const void* objectID, void* object,
+ void* cleanupCookie,
+ object_cleanup_func func) final;
+ LIBBINDER_EXPORTED virtual void* findObject(const void* objectID) const final;
+ LIBBINDER_EXPORTED virtual void* detachObject(const void* objectID) final;
+ LIBBINDER_EXPORTED void withLock(const std::function<void()>& doWithLock);
+ LIBBINDER_EXPORTED sp<IBinder> lookupOrCreateWeak(const void* objectID,
+ IBinder::object_make_func make,
+ const void* makeArgs);
- virtual BpBinder* remoteBinder();
+ LIBBINDER_EXPORTED virtual BpBinder* remoteBinder();
- void sendObituary();
+ LIBBINDER_EXPORTED void sendObituary();
- static uint32_t getBinderProxyCount(uint32_t uid);
- static void getCountByUid(Vector<uint32_t>& uids, Vector<uint32_t>& counts);
- static void enableCountByUid();
- static void disableCountByUid();
- static void setCountByUidEnabled(bool enable);
- static void setBinderProxyCountEventCallback(binder_proxy_limit_callback cbl,
- binder_proxy_warning_callback cbw);
- static void setBinderProxyCountWatermarks(int high, int low, int warning);
- static uint32_t getBinderProxyCount();
+ LIBBINDER_EXPORTED static uint32_t getBinderProxyCount(uint32_t uid);
+ LIBBINDER_EXPORTED static void getCountByUid(Vector<uint32_t>& uids, Vector<uint32_t>& counts);
+ LIBBINDER_EXPORTED static void enableCountByUid();
+ LIBBINDER_EXPORTED static void disableCountByUid();
+ LIBBINDER_EXPORTED static void setCountByUidEnabled(bool enable);
+ LIBBINDER_EXPORTED static void setBinderProxyCountEventCallback(
+ binder_proxy_limit_callback cbl, binder_proxy_warning_callback cbw);
+ LIBBINDER_EXPORTED static void setBinderProxyCountWatermarks(int high, int low, int warning);
+ LIBBINDER_EXPORTED static uint32_t getBinderProxyCount();
- std::optional<int32_t> getDebugBinderHandle() const;
+ LIBBINDER_EXPORTED std::optional<int32_t> getDebugBinderHandle() const;
// Start recording transactions to the unique_fd.
// See RecordedTransaction.h for more details.
- status_t startRecordingBinder(const binder::unique_fd& fd);
+ LIBBINDER_EXPORTED status_t startRecordingBinder(const binder::unique_fd& fd);
// Stop the current recording.
- status_t stopRecordingBinder();
+ LIBBINDER_EXPORTED status_t stopRecordingBinder();
class ObjectManager {
public:
@@ -150,7 +148,9 @@
const BpBinder* mBinder;
};
- const PrivateAccessor getPrivateAccessor() const { return PrivateAccessor(this); }
+ LIBBINDER_EXPORTED const PrivateAccessor getPrivateAccessor() const {
+ return PrivateAccessor(this);
+ }
private:
friend PrivateAccessor;
diff --git a/libs/binder/include/binder/Common.h b/libs/binder/include/binder/Common.h
new file mode 100644
index 0000000..ed10154
--- /dev/null
+++ b/libs/binder/include/binder/Common.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+#pragma once
+
+// libbinder is built with symbol hidden by default. To add a new symbol to the
+// ABI, you must annotate it with this LIBBINDER_EXPORTED macro. When not
+// building libbinder (e.g. when another binary includes a libbinder header),
+// this macro is a no-op.
+//
+// Examples:
+//
+// // Export a function.
+// LIBBINDER_EXPORTED void someFunction();
+//
+// // Export a subset of the symbols for a class.
+// class SomeClassA {
+// public:
+// LIBBINDER_EXPORTED SomeClassA();
+//
+// LIBBINDER_EXPORTED SomeMethod();
+// }
+//
+// // Export all the symbols for a class, even private symbols.
+// class LIBBINDER_EXPORTED SomeClassB {};
+//
+// For a more detailed explanation of this strategy, see
+// https://www.gnu.org/software/gnulib/manual/html_node/Exported-Symbols-of-Shared-Libraries.html
+#if BUILDING_LIBBINDER
+#define LIBBINDER_EXPORTED __attribute__((__visibility__("default")))
+#else
+#define LIBBINDER_EXPORTED
+#endif
+
+// For stuff that is exported but probably shouldn't be. It behaves the exact
+// same way as LIBBINDER_EXPORTED, only exists to help track what we want
+// eventually remove.
+//
+// Needed, at least in part, because the test binaries are using internal
+// headers and accessing these symbols directly.
+#define LIBBINDER_INTERNAL_EXPORTED LIBBINDER_EXPORTED
diff --git a/libs/binder/include/binder/Delegate.h b/libs/binder/include/binder/Delegate.h
index ad5a6a3..7aaa7a0 100644
--- a/libs/binder/include/binder/Delegate.h
+++ b/libs/binder/include/binder/Delegate.h
@@ -16,6 +16,7 @@
#pragma once
+#include <binder/Common.h>
#include <binder/IBinder.h>
#if !defined(__BIONIC__) && defined(BINDER_ENABLE_LIBLOG_ASSERT)
diff --git a/libs/binder/include/binder/IBinder.h b/libs/binder/include/binder/IBinder.h
index dad9a17..17248ce 100644
--- a/libs/binder/include/binder/IBinder.h
+++ b/libs/binder/include/binder/IBinder.h
@@ -16,6 +16,7 @@
#pragma once
+#include <binder/Common.h>
#include <binder/unique_fd.h>
#include <utils/Errors.h>
#include <utils/RefBase.h>
@@ -48,8 +49,7 @@
* (method calls, property get and set) is down through a low-level
* protocol implemented on top of the transact() API.
*/
-class [[clang::lto_visibility_public]] IBinder : public virtual RefBase
-{
+class [[clang::lto_visibility_public]] LIBBINDER_EXPORTED IBinder : public virtual RefBase {
public:
enum {
FIRST_CALL_TRANSACTION = 0x00000001,
diff --git a/libs/binder/include/binder/IInterface.h b/libs/binder/include/binder/IInterface.h
index ac845bc..30e005c 100644
--- a/libs/binder/include/binder/IInterface.h
+++ b/libs/binder/include/binder/IInterface.h
@@ -17,6 +17,7 @@
#pragma once
#include <binder/Binder.h>
+#include <binder/Common.h>
#include <assert.h>
@@ -24,8 +25,7 @@
// ----------------------------------------------------------------------
-class IInterface : public virtual RefBase
-{
+class LIBBINDER_EXPORTED IInterface : public virtual RefBase {
public:
IInterface();
static sp<IBinder> asBinder(const IInterface*);
@@ -66,9 +66,8 @@
// ----------------------------------------------------------------------
-template<typename INTERFACE>
-class BnInterface : public INTERFACE, public BBinder
-{
+template <typename INTERFACE>
+class LIBBINDER_EXPORTED BnInterface : public INTERFACE, public BBinder {
public:
virtual sp<IInterface> queryLocalInterface(const String16& _descriptor);
virtual const String16& getInterfaceDescriptor() const;
@@ -80,9 +79,8 @@
// ----------------------------------------------------------------------
-template<typename INTERFACE>
-class BpInterface : public INTERFACE, public BpRefBase
-{
+template <typename INTERFACE>
+class LIBBINDER_EXPORTED BpInterface : public INTERFACE, public BpRefBase {
public:
explicit BpInterface(const sp<IBinder>& remote);
typedef INTERFACE BaseInterface;
diff --git a/libs/binder/include/binder/IMemory.h b/libs/binder/include/binder/IMemory.h
index d8b7ec1..12c5c61 100644
--- a/libs/binder/include/binder/IMemory.h
+++ b/libs/binder/include/binder/IMemory.h
@@ -22,14 +22,14 @@
#include <utils/RefBase.h>
#include <utils/Errors.h>
+#include <binder/Common.h>
#include <binder/IInterface.h>
namespace android {
// ----------------------------------------------------------------------------
-class IMemoryHeap : public IInterface
-{
+class LIBBINDER_EXPORTED IMemoryHeap : public IInterface {
public:
DECLARE_META_INTERFACE(MemoryHeap)
@@ -50,8 +50,7 @@
size_t virtualSize() const { return getSize(); }
};
-class BnMemoryHeap : public BnInterface<IMemoryHeap>
-{
+class LIBBINDER_EXPORTED BnMemoryHeap : public BnInterface<IMemoryHeap> {
public:
// NOLINTNEXTLINE(google-default-arguments)
virtual status_t onTransact(
@@ -67,8 +66,7 @@
// ----------------------------------------------------------------------------
-class IMemory : public IInterface
-{
+class LIBBINDER_EXPORTED IMemory : public IInterface {
public:
DECLARE_META_INTERFACE(Memory)
@@ -105,8 +103,7 @@
void* fastPointer(const sp<IBinder>& heap, ssize_t offset) const;
};
-class BnMemory : public BnInterface<IMemory>
-{
+class LIBBINDER_EXPORTED BnMemory : public BnInterface<IMemory> {
public:
// NOLINTNEXTLINE(google-default-arguments)
virtual status_t onTransact(
diff --git a/libs/binder/include/binder/IPCThreadState.h b/libs/binder/include/binder/IPCThreadState.h
index dc5b1a1..09ab442 100644
--- a/libs/binder/include/binder/IPCThreadState.h
+++ b/libs/binder/include/binder/IPCThreadState.h
@@ -16,9 +16,10 @@
#pragma once
-#include <utils/Errors.h>
+#include <binder/Common.h>
#include <binder/Parcel.h>
#include <binder/ProcessState.h>
+#include <utils/Errors.h>
#include <utils/Vector.h>
#if defined(_WIN32)
@@ -32,13 +33,12 @@
* Kernel binder thread state. All operations here refer to kernel binder. This
* object is allocated per-thread.
*/
-class IPCThreadState
-{
+class IPCThreadState {
public:
using CallRestriction = ProcessState::CallRestriction;
- static IPCThreadState* self();
- static IPCThreadState* selfOrNull(); // self(), but won't instantiate
+ LIBBINDER_EXPORTED static IPCThreadState* self();
+ LIBBINDER_EXPORTED static IPCThreadState* selfOrNull(); // self(), but won't instantiate
// Freeze or unfreeze the binder interface to a specific process. When freezing, this method
// will block up to timeout_ms to process pending transactions directed to pid. Unfreeze
@@ -52,182 +52,175 @@
// binder transactions to be processed.
//
// returns: 0 in case of success, a value < 0 in case of error
- static status_t freeze(pid_t pid, bool enabled, uint32_t timeout_ms);
+ LIBBINDER_EXPORTED static status_t freeze(pid_t pid, bool enabled, uint32_t timeout_ms);
// Provide information about the state of a frozen process
- static status_t getProcessFreezeInfo(pid_t pid, uint32_t *sync_received,
- uint32_t *async_received);
+ LIBBINDER_EXPORTED static status_t getProcessFreezeInfo(pid_t pid, uint32_t* sync_received,
+ uint32_t* async_received);
- status_t clearLastError();
+ LIBBINDER_EXPORTED status_t clearLastError();
- /**
- * Returns the PID of the process which has made the current binder
- * call. If not in a binder call, this will return getpid.
- *
- * Warning: oneway transactions do not receive PID. Even if you expect
- * a transaction to be synchronous, a misbehaving client could send it
- * as an asynchronous call and result in a 0 PID here. Additionally, if
- * there is a race and the calling process dies, the PID may still be
- * 0 for a synchronous call.
- */
- [[nodiscard]] pid_t getCallingPid() const;
+ /**
+ * Returns the PID of the process which has made the current binder
+ * call. If not in a binder call, this will return getpid.
+ *
+ * Warning: oneway transactions do not receive PID. Even if you expect
+ * a transaction to be synchronous, a misbehaving client could send it
+ * as an asynchronous call and result in a 0 PID here. Additionally, if
+ * there is a race and the calling process dies, the PID may still be
+ * 0 for a synchronous call.
+ */
+ [[nodiscard]] LIBBINDER_EXPORTED pid_t getCallingPid() const;
- /**
- * Returns the SELinux security identifier of the process which has
- * made the current binder call. If not in a binder call this will
- * return nullptr. If this isn't requested with
- * Binder::setRequestingSid, it will also return nullptr.
- *
- * This can't be restored once it's cleared, and it does not return the
- * context of the current process when not in a binder call.
- */
- [[nodiscard]] const char* getCallingSid() const;
+ /**
+ * Returns the SELinux security identifier of the process which has
+ * made the current binder call. If not in a binder call this will
+ * return nullptr. If this isn't requested with
+ * Binder::setRequestingSid, it will also return nullptr.
+ *
+ * This can't be restored once it's cleared, and it does not return the
+ * context of the current process when not in a binder call.
+ */
+ [[nodiscard]] LIBBINDER_EXPORTED const char* getCallingSid() const;
- /**
- * Returns the UID of the process which has made the current binder
- * call. If not in a binder call, this will return 0.
- */
- [[nodiscard]] uid_t getCallingUid() const;
+ /**
+ * Returns the UID of the process which has made the current binder
+ * call. If not in a binder call, this will return 0.
+ */
+ [[nodiscard]] LIBBINDER_EXPORTED uid_t getCallingUid() const;
- /**
- * Make it an abort to rely on getCalling* for a section of
- * execution.
- *
- * Usage:
- * IPCThreadState::SpGuard guard {
- * .address = __builtin_frame_address(0),
- * .context = "...",
- * };
- * const auto* orig = pushGetCallingSpGuard(&guard);
- * {
- * // will abort if you call getCalling*, unless you are
- * // serving a nested binder transaction
- * }
- * restoreCallingSpGuard(orig);
- */
- struct SpGuard {
- const void* address;
- const char* context;
- };
- const SpGuard* pushGetCallingSpGuard(const SpGuard* guard);
- void restoreGetCallingSpGuard(const SpGuard* guard);
- /**
- * Used internally by getCalling*. Can also be used to assert that
- * you are in a binder context (getCalling* is valid). This is
- * intentionally not exposed as a boolean API since code should be
- * written to know its environment.
- */
- void checkContextIsBinderForUse(const char* use) const;
+ /**
+ * Make it an abort to rely on getCalling* for a section of
+ * execution.
+ *
+ * Usage:
+ * IPCThreadState::SpGuard guard {
+ * .address = __builtin_frame_address(0),
+ * .context = "...",
+ * };
+ * const auto* orig = pushGetCallingSpGuard(&guard);
+ * {
+ * // will abort if you call getCalling*, unless you are
+ * // serving a nested binder transaction
+ * }
+ * restoreCallingSpGuard(orig);
+ */
+ struct SpGuard {
+ const void* address;
+ const char* context;
+ };
+ LIBBINDER_EXPORTED const SpGuard* pushGetCallingSpGuard(const SpGuard* guard);
+ LIBBINDER_EXPORTED void restoreGetCallingSpGuard(const SpGuard* guard);
+ /**
+ * Used internally by getCalling*. Can also be used to assert that
+ * you are in a binder context (getCalling* is valid). This is
+ * intentionally not exposed as a boolean API since code should be
+ * written to know its environment.
+ */
+ LIBBINDER_EXPORTED void checkContextIsBinderForUse(const char* use) const;
- void setStrictModePolicy(int32_t policy);
- int32_t getStrictModePolicy() const;
+ LIBBINDER_EXPORTED void setStrictModePolicy(int32_t policy);
+ LIBBINDER_EXPORTED int32_t getStrictModePolicy() const;
- // See Binder#setCallingWorkSourceUid in Binder.java.
- int64_t setCallingWorkSourceUid(uid_t uid);
- // Internal only. Use setCallingWorkSourceUid(uid) instead.
- int64_t setCallingWorkSourceUidWithoutPropagation(uid_t uid);
- // See Binder#getCallingWorkSourceUid in Binder.java.
- uid_t getCallingWorkSourceUid() const;
- // See Binder#clearCallingWorkSource in Binder.java.
- int64_t clearCallingWorkSource();
- // See Binder#restoreCallingWorkSource in Binder.java.
- void restoreCallingWorkSource(int64_t token);
- void clearPropagateWorkSource();
- bool shouldPropagateWorkSource() const;
+ // See Binder#setCallingWorkSourceUid in Binder.java.
+ LIBBINDER_EXPORTED int64_t setCallingWorkSourceUid(uid_t uid);
+ // Internal only. Use setCallingWorkSourceUid(uid) instead.
+ LIBBINDER_EXPORTED int64_t setCallingWorkSourceUidWithoutPropagation(uid_t uid);
+ // See Binder#getCallingWorkSourceUid in Binder.java.
+ LIBBINDER_EXPORTED uid_t getCallingWorkSourceUid() const;
+ // See Binder#clearCallingWorkSource in Binder.java.
+ LIBBINDER_EXPORTED int64_t clearCallingWorkSource();
+ // See Binder#restoreCallingWorkSource in Binder.java.
+ LIBBINDER_EXPORTED void restoreCallingWorkSource(int64_t token);
+ LIBBINDER_EXPORTED void clearPropagateWorkSource();
+ LIBBINDER_EXPORTED bool shouldPropagateWorkSource() const;
- void setLastTransactionBinderFlags(int32_t flags);
- int32_t getLastTransactionBinderFlags() const;
+ LIBBINDER_EXPORTED void setLastTransactionBinderFlags(int32_t flags);
+ LIBBINDER_EXPORTED int32_t getLastTransactionBinderFlags() const;
- void setCallRestriction(CallRestriction restriction);
- CallRestriction getCallRestriction() const;
+ LIBBINDER_EXPORTED void setCallRestriction(CallRestriction restriction);
+ LIBBINDER_EXPORTED CallRestriction getCallRestriction() const;
- int64_t clearCallingIdentity();
- // Restores PID/UID (not SID)
- void restoreCallingIdentity(int64_t token);
- bool hasExplicitIdentity();
+ LIBBINDER_EXPORTED int64_t clearCallingIdentity();
+ // Restores PID/UID (not SID)
+ LIBBINDER_EXPORTED void restoreCallingIdentity(int64_t token);
+ LIBBINDER_EXPORTED bool hasExplicitIdentity();
- // For main functions - dangerous for libraries to use
- status_t setupPolling(int* fd);
- status_t handlePolledCommands();
- void flushCommands();
- bool flushIfNeeded();
+ // For main functions - dangerous for libraries to use
+ LIBBINDER_EXPORTED status_t setupPolling(int* fd);
+ LIBBINDER_EXPORTED status_t handlePolledCommands();
+ LIBBINDER_EXPORTED void flushCommands();
+ LIBBINDER_EXPORTED bool flushIfNeeded();
- // Adds the current thread into the binder threadpool.
- //
- // This is in addition to any threads which are started
- // with startThreadPool. Libraries should not call this
- // function, as they may be loaded into processes which
- // try to configure the threadpool differently.
- void joinThreadPool(bool isMain = true);
-
- // Stop the local process.
- void stopProcess(bool immediate = true);
-
- status_t transact(int32_t handle,
- uint32_t code, const Parcel& data,
+ // Adds the current thread into the binder threadpool.
+ //
+ // This is in addition to any threads which are started
+ // with startThreadPool. Libraries should not call this
+ // function, as they may be loaded into processes which
+ // try to configure the threadpool differently.
+ LIBBINDER_EXPORTED void joinThreadPool(bool isMain = true);
+
+ // Stop the local process.
+ LIBBINDER_EXPORTED void stopProcess(bool immediate = true);
+
+ LIBBINDER_EXPORTED status_t transact(int32_t handle, uint32_t code, const Parcel& data,
Parcel* reply, uint32_t flags);
- void incStrongHandle(int32_t handle, BpBinder *proxy);
- void decStrongHandle(int32_t handle);
- void incWeakHandle(int32_t handle, BpBinder *proxy);
- void decWeakHandle(int32_t handle);
- status_t attemptIncStrongHandle(int32_t handle);
- static void expungeHandle(int32_t handle, IBinder* binder);
- status_t requestDeathNotification( int32_t handle,
- BpBinder* proxy);
- status_t clearDeathNotification( int32_t handle,
- BpBinder* proxy);
+ LIBBINDER_EXPORTED void incStrongHandle(int32_t handle, BpBinder* proxy);
+ LIBBINDER_EXPORTED void decStrongHandle(int32_t handle);
+ LIBBINDER_EXPORTED void incWeakHandle(int32_t handle, BpBinder* proxy);
+ LIBBINDER_EXPORTED void decWeakHandle(int32_t handle);
+ LIBBINDER_EXPORTED status_t attemptIncStrongHandle(int32_t handle);
+ LIBBINDER_EXPORTED static void expungeHandle(int32_t handle, IBinder* binder);
+ LIBBINDER_EXPORTED status_t requestDeathNotification(int32_t handle, BpBinder* proxy);
+ LIBBINDER_EXPORTED status_t clearDeathNotification(int32_t handle, BpBinder* proxy);
- static void shutdown();
+ LIBBINDER_EXPORTED static void shutdown();
// Call this to disable switching threads to background scheduling when
// receiving incoming IPC calls. This is specifically here for the
// Android system process, since it expects to have background apps calling
// in to it but doesn't want to acquire locks in its services while in
// the background.
- static void disableBackgroundScheduling(bool disable);
- bool backgroundSchedulingDisabled();
+ LIBBINDER_EXPORTED static void disableBackgroundScheduling(bool disable);
+ LIBBINDER_EXPORTED bool backgroundSchedulingDisabled();
- // Call blocks until the number of executing binder threads is less than
- // the maximum number of binder threads threads allowed for this process.
- void blockUntilThreadAvailable();
+ // Call blocks until the number of executing binder threads is less than
+ // the maximum number of binder threads threads allowed for this process.
+ LIBBINDER_EXPORTED void blockUntilThreadAvailable();
- // Service manager registration
- void setTheContextObject(const sp<BBinder>& obj);
+ // Service manager registration
+ LIBBINDER_EXPORTED void setTheContextObject(const sp<BBinder>& obj);
- // WARNING: DO NOT USE THIS API
- //
- // Returns a pointer to the stack from the last time a transaction
- // was initiated by the kernel. Used to compare when making nested
- // calls between multiple different transports.
- const void* getServingStackPointer() const;
+ // WARNING: DO NOT USE THIS API
+ //
+ // Returns a pointer to the stack from the last time a transaction
+ // was initiated by the kernel. Used to compare when making nested
+ // calls between multiple different transports.
+ LIBBINDER_EXPORTED const void* getServingStackPointer() const;
- // The work source represents the UID of the process we should attribute the transaction
- // to. We use -1 to specify that the work source was not set using #setWorkSource.
- //
- // This constant needs to be kept in sync with Binder.UNSET_WORKSOURCE from the Java
- // side.
- static const int32_t kUnsetWorkSource = -1;
+ // The work source represents the UID of the process we should attribute the transaction
+ // to. We use -1 to specify that the work source was not set using #setWorkSource.
+ //
+ // This constant needs to be kept in sync with Binder.UNSET_WORKSOURCE from the Java
+ // side.
+ LIBBINDER_EXPORTED static const int32_t kUnsetWorkSource = -1;
+
private:
- IPCThreadState();
- ~IPCThreadState();
+ IPCThreadState();
+ ~IPCThreadState();
- status_t sendReply(const Parcel& reply, uint32_t flags);
- status_t waitForResponse(Parcel *reply,
- status_t *acquireResult=nullptr);
- status_t talkWithDriver(bool doReceive=true);
- status_t writeTransactionData(int32_t cmd,
- uint32_t binderFlags,
- int32_t handle,
- uint32_t code,
- const Parcel& data,
- status_t* statusBuffer);
- status_t getAndExecuteCommand();
- status_t executeCommand(int32_t command);
- void processPendingDerefs();
- void processPostWriteDerefs();
+ status_t sendReply(const Parcel& reply, uint32_t flags);
+ status_t waitForResponse(Parcel* reply, status_t* acquireResult = nullptr);
+ status_t talkWithDriver(bool doReceive = true);
+ status_t writeTransactionData(int32_t cmd, uint32_t binderFlags, int32_t handle, uint32_t code,
+ const Parcel& data, status_t* statusBuffer);
+ status_t getAndExecuteCommand();
+ status_t executeCommand(int32_t command);
+ void processPendingDerefs();
+ void processPostWriteDerefs();
- void clearCaller();
+ void clearCaller();
static void threadDestructor(void *st);
static void freeBuffer(const uint8_t* data, size_t dataSize, const binder_size_t* objects,
diff --git a/libs/binder/include/binder/IPermissionController.h b/libs/binder/include/binder/IPermissionController.h
index a4f93d9..2bf9e71 100644
--- a/libs/binder/include/binder/IPermissionController.h
+++ b/libs/binder/include/binder/IPermissionController.h
@@ -18,6 +18,7 @@
#ifndef __ANDROID_VNDK__
+#include <binder/Common.h>
#include <binder/IInterface.h>
#include <stdlib.h>
@@ -25,8 +26,7 @@
// ----------------------------------------------------------------------
-class IPermissionController : public IInterface
-{
+class LIBBINDER_EXPORTED IPermissionController : public IInterface {
public:
DECLARE_META_INTERFACE(PermissionController)
@@ -51,8 +51,7 @@
// ----------------------------------------------------------------------
-class BnPermissionController : public BnInterface<IPermissionController>
-{
+class LIBBINDER_EXPORTED BnPermissionController : public BnInterface<IPermissionController> {
public:
// NOLINTNEXTLINE(google-default-arguments)
virtual status_t onTransact( uint32_t code,
diff --git a/libs/binder/include/binder/IResultReceiver.h b/libs/binder/include/binder/IResultReceiver.h
index 5434445..b72cf11 100644
--- a/libs/binder/include/binder/IResultReceiver.h
+++ b/libs/binder/include/binder/IResultReceiver.h
@@ -16,14 +16,14 @@
#pragma once
+#include <binder/Common.h>
#include <binder/IInterface.h>
namespace android {
// ----------------------------------------------------------------------
-class IResultReceiver : public IInterface
-{
+class LIBBINDER_EXPORTED IResultReceiver : public IInterface {
public:
DECLARE_META_INTERFACE(ResultReceiver)
@@ -36,8 +36,7 @@
// ----------------------------------------------------------------------
-class BnResultReceiver : public BnInterface<IResultReceiver>
-{
+class LIBBINDER_EXPORTED BnResultReceiver : public BnInterface<IResultReceiver> {
public:
// NOLINTNEXTLINE(google-default-arguments)
virtual status_t onTransact( uint32_t code,
diff --git a/libs/binder/include/binder/IServiceManager.h b/libs/binder/include/binder/IServiceManager.h
index 486bdfb..5fb7307 100644
--- a/libs/binder/include/binder/IServiceManager.h
+++ b/libs/binder/include/binder/IServiceManager.h
@@ -15,6 +15,7 @@
*/
#pragma once
+#include <binder/Common.h>
#include <binder/IInterface.h>
#include <utils/Vector.h>
#include <utils/String16.h>
@@ -29,8 +30,7 @@
*
* IInterface is only for legacy ABI compatibility
*/
-class IServiceManager : public IInterface
-{
+class LIBBINDER_EXPORTED IServiceManager : public IInterface {
public:
// for ABI compatibility
virtual const String16& getInterfaceDescriptor() const;
@@ -149,7 +149,7 @@
virtual std::vector<ServiceDebugInfo> getServiceDebugInfo() = 0;
};
-sp<IServiceManager> defaultServiceManager();
+LIBBINDER_EXPORTED sp<IServiceManager> defaultServiceManager();
/**
* Directly set the default service manager. Only used for testing.
@@ -157,7 +157,7 @@
* *before* any call to defaultServiceManager(); if the latter is
* called first, setDefaultServiceManager() will abort.
*/
-void setDefaultServiceManager(const sp<IServiceManager>& sm);
+LIBBINDER_EXPORTED void setDefaultServiceManager(const sp<IServiceManager>& sm);
template<typename INTERFACE>
sp<INTERFACE> waitForService(const String16& name) {
@@ -207,13 +207,14 @@
return NAME_NOT_FOUND;
}
-void* openDeclaredPassthroughHal(const String16& interface, const String16& instance, int flag);
+LIBBINDER_EXPORTED void* openDeclaredPassthroughHal(const String16& interface,
+ const String16& instance, int flag);
-bool checkCallingPermission(const String16& permission);
-bool checkCallingPermission(const String16& permission,
- int32_t* outPid, int32_t* outUid);
-bool checkPermission(const String16& permission, pid_t pid, uid_t uid,
- bool logPermissionFailure = true);
+LIBBINDER_EXPORTED bool checkCallingPermission(const String16& permission);
+LIBBINDER_EXPORTED bool checkCallingPermission(const String16& permission, int32_t* outPid,
+ int32_t* outUid);
+LIBBINDER_EXPORTED bool checkPermission(const String16& permission, pid_t pid, uid_t uid,
+ bool logPermissionFailure = true);
#ifndef __ANDROID__
// Create an IServiceManager that delegates the service manager on the device via adb.
@@ -233,7 +234,7 @@
struct RpcDelegateServiceManagerOptions {
std::optional<size_t> maxOutgoingConnections;
};
-sp<IServiceManager> createRpcDelegateServiceManager(
+LIBBINDER_EXPORTED sp<IServiceManager> createRpcDelegateServiceManager(
const RpcDelegateServiceManagerOptions& options);
#endif
diff --git a/libs/binder/include/binder/IShellCallback.h b/libs/binder/include/binder/IShellCallback.h
index 6d3fe4a..4324afc 100644
--- a/libs/binder/include/binder/IShellCallback.h
+++ b/libs/binder/include/binder/IShellCallback.h
@@ -16,14 +16,14 @@
#pragma once
+#include <binder/Common.h>
#include <binder/IInterface.h>
namespace android {
// ----------------------------------------------------------------------
-class IShellCallback : public IInterface
-{
+class LIBBINDER_EXPORTED IShellCallback : public IInterface {
public:
DECLARE_META_INTERFACE(ShellCallback)
@@ -37,8 +37,7 @@
// ----------------------------------------------------------------------
-class BnShellCallback : public BnInterface<IShellCallback>
-{
+class LIBBINDER_EXPORTED BnShellCallback : public BnInterface<IShellCallback> {
public:
// NOLINTNEXTLINE(google-default-arguments)
virtual status_t onTransact( uint32_t code,
diff --git a/libs/binder/include/binder/LazyServiceRegistrar.h b/libs/binder/include/binder/LazyServiceRegistrar.h
index bda3d19..3436b11 100644
--- a/libs/binder/include/binder/LazyServiceRegistrar.h
+++ b/libs/binder/include/binder/LazyServiceRegistrar.h
@@ -18,6 +18,7 @@
#include <functional>
+#include <binder/Common.h>
#include <binder/IServiceManager.h>
#include <binder/Status.h>
#include <utils/StrongPointer.h>
@@ -42,70 +43,71 @@
* For more information on init .rc configuration, see system/core/init/README.md
**/
class LazyServiceRegistrar {
- public:
- static LazyServiceRegistrar& getInstance();
- status_t registerService(const sp<IBinder>& service,
- const std::string& name = "default",
- bool allowIsolated = false,
- int dumpFlags = IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT);
- /**
- * Force the service to persist, even when it has 0 clients.
- * If setting this flag from the server side, make sure to do so before calling
- * registerService, or there may be a race with the default dynamic shutdown.
- *
- * This should only be used if it is every eventually set to false. If a
- * service needs to persist but doesn't need to dynamically shut down,
- * prefer to control it with another mechanism such as ctl.start.
- */
- void forcePersist(bool persist);
+public:
+ LIBBINDER_EXPORTED static LazyServiceRegistrar& getInstance();
+ LIBBINDER_EXPORTED status_t
+ registerService(const sp<IBinder>& service, const std::string& name = "default",
+ bool allowIsolated = false,
+ int dumpFlags = IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT);
+ /**
+ * Force the service to persist, even when it has 0 clients.
+ * If setting this flag from the server side, make sure to do so before calling
+ * registerService, or there may be a race with the default dynamic shutdown.
+ *
+ * This should only be used if it is every eventually set to false. If a
+ * service needs to persist but doesn't need to dynamically shut down,
+ * prefer to control it with another mechanism such as ctl.start.
+ */
+ LIBBINDER_EXPORTED void forcePersist(bool persist);
- /**
- * Set a callback that is invoked when the active service count (i.e. services with clients)
- * registered with this process drops to zero (or becomes nonzero).
- * The callback takes a boolean argument, which is 'true' if there is
- * at least one service with clients.
- *
- * Callback return value:
- * - false: Default behavior for lazy services (shut down the process if there
- * are no clients).
- * - true: Don't shut down the process even if there are no clients.
- *
- * This callback gives a chance to:
- * 1 - Perform some additional operations before exiting;
- * 2 - Prevent the process from exiting by returning "true" from the
- * callback.
- *
- * This method should be called before 'registerService' to avoid races.
- */
- void setActiveServicesCallback(const std::function<bool(bool)>& activeServicesCallback);
+ /**
+ * Set a callback that is invoked when the active service count (i.e. services with clients)
+ * registered with this process drops to zero (or becomes nonzero).
+ * The callback takes a boolean argument, which is 'true' if there is
+ * at least one service with clients.
+ *
+ * Callback return value:
+ * - false: Default behavior for lazy services (shut down the process if there
+ * are no clients).
+ * - true: Don't shut down the process even if there are no clients.
+ *
+ * This callback gives a chance to:
+ * 1 - Perform some additional operations before exiting;
+ * 2 - Prevent the process from exiting by returning "true" from the
+ * callback.
+ *
+ * This method should be called before 'registerService' to avoid races.
+ */
+ LIBBINDER_EXPORTED void setActiveServicesCallback(
+ const std::function<bool(bool)>& activeServicesCallback);
- /**
- * Try to unregister all services previously registered with 'registerService'.
- * Returns 'true' if successful. This should only be called within the callback registered by
- * setActiveServicesCallback.
- */
- bool tryUnregister();
+ /**
+ * Try to unregister all services previously registered with 'registerService'.
+ * Returns 'true' if successful. This should only be called within the callback registered by
+ * setActiveServicesCallback.
+ */
+ LIBBINDER_EXPORTED bool tryUnregister();
- /**
- * Re-register services that were unregistered by 'tryUnregister'.
- * This method should be called in the case 'tryUnregister' fails
- * (and should be called on the same thread).
- */
- void reRegister();
+ /**
+ * Re-register services that were unregistered by 'tryUnregister'.
+ * This method should be called in the case 'tryUnregister' fails
+ * (and should be called on the same thread).
+ */
+ LIBBINDER_EXPORTED void reRegister();
- /**
- * Create a second instance of lazy service registrar.
- *
- * WARNING: dangerous! DO NOT USE THIS - LazyServiceRegistrar
- * should be single-instanced, so that the service will only
- * shut down when all services are unused. A separate instance
- * is only used to test race conditions.
- */
- static LazyServiceRegistrar createExtraTestInstance();
+ /**
+ * Create a second instance of lazy service registrar.
+ *
+ * WARNING: dangerous! DO NOT USE THIS - LazyServiceRegistrar
+ * should be single-instanced, so that the service will only
+ * shut down when all services are unused. A separate instance
+ * is only used to test race conditions.
+ */
+ LIBBINDER_EXPORTED static LazyServiceRegistrar createExtraTestInstance();
- private:
- std::shared_ptr<internal::ClientCounterCallback> mClientCC;
- LazyServiceRegistrar();
+private:
+ std::shared_ptr<internal::ClientCounterCallback> mClientCC;
+ LazyServiceRegistrar();
};
} // namespace binder
diff --git a/libs/binder/include/binder/MemoryBase.h b/libs/binder/include/binder/MemoryBase.h
index 61a029c..04cd1a4 100644
--- a/libs/binder/include/binder/MemoryBase.h
+++ b/libs/binder/include/binder/MemoryBase.h
@@ -19,6 +19,7 @@
#include <stdlib.h>
#include <stdint.h>
+#include <binder/Common.h>
#include <binder/IMemory.h>
@@ -26,8 +27,7 @@
// ---------------------------------------------------------------------------
-class MemoryBase : public BnMemory
-{
+class LIBBINDER_EXPORTED MemoryBase : public BnMemory {
public:
MemoryBase(const sp<IMemoryHeap>& heap, ssize_t offset, size_t size);
virtual ~MemoryBase();
diff --git a/libs/binder/include/binder/MemoryDealer.h b/libs/binder/include/binder/MemoryDealer.h
index 3f7dd11..b979da5 100644
--- a/libs/binder/include/binder/MemoryDealer.h
+++ b/libs/binder/include/binder/MemoryDealer.h
@@ -19,6 +19,7 @@
#include <stdint.h>
#include <sys/types.h>
+#include <binder/Common.h>
#include <binder/IMemory.h>
#include <binder/MemoryHeapBase.h>
@@ -29,33 +30,32 @@
// ----------------------------------------------------------------------------
-class MemoryDealer : public RefBase
-{
+class MemoryDealer : public RefBase {
public:
- explicit MemoryDealer(size_t size, const char* name = nullptr,
- uint32_t flags = 0 /* or bits such as MemoryHeapBase::READ_ONLY */ );
+ LIBBINDER_EXPORTED explicit MemoryDealer(
+ size_t size, const char* name = nullptr,
+ uint32_t flags = 0 /* or bits such as MemoryHeapBase::READ_ONLY */);
- virtual sp<IMemory> allocate(size_t size);
- virtual void dump(const char* what) const;
+ LIBBINDER_EXPORTED virtual sp<IMemory> allocate(size_t size);
+ LIBBINDER_EXPORTED virtual void dump(const char* what) const;
// allocations are aligned to some value. return that value so clients can account for it.
- static size_t getAllocationAlignment();
+ LIBBINDER_EXPORTED static size_t getAllocationAlignment();
sp<IMemoryHeap> getMemoryHeap() const { return heap(); }
protected:
- virtual ~MemoryDealer();
+ LIBBINDER_EXPORTED virtual ~MemoryDealer();
private:
friend class Allocation;
virtual void deallocate(size_t offset);
- const sp<IMemoryHeap>& heap() const;
+ LIBBINDER_EXPORTED const sp<IMemoryHeap>& heap() const;
SimpleBestFitAllocator* allocator() const;
sp<IMemoryHeap> mHeap;
SimpleBestFitAllocator* mAllocator;
};
-
// ----------------------------------------------------------------------------
} // namespace android
diff --git a/libs/binder/include/binder/MemoryHeapBase.h b/libs/binder/include/binder/MemoryHeapBase.h
index c7177bd..ff2d09f 100644
--- a/libs/binder/include/binder/MemoryHeapBase.h
+++ b/libs/binder/include/binder/MemoryHeapBase.h
@@ -19,6 +19,7 @@
#include <stdlib.h>
#include <stdint.h>
+#include <binder/Common.h>
#include <binder/IMemory.h>
@@ -26,8 +27,7 @@
// ---------------------------------------------------------------------------
-class MemoryHeapBase : public BnMemoryHeap
-{
+class MemoryHeapBase : public BnMemoryHeap {
public:
static constexpr auto MEMFD_ALLOW_SEALING_FLAG = 0x00000800;
enum {
@@ -56,42 +56,44 @@
* maps the memory referenced by fd. but DOESN'T take ownership
* of the filedescriptor (it makes a copy with dup()
*/
- MemoryHeapBase(int fd, size_t size, uint32_t flags = 0, off_t offset = 0);
+ LIBBINDER_EXPORTED MemoryHeapBase(int fd, size_t size, uint32_t flags = 0, off_t offset = 0);
/*
* maps memory from the given device
*/
- explicit MemoryHeapBase(const char* device, size_t size = 0, uint32_t flags = 0);
+ LIBBINDER_EXPORTED explicit MemoryHeapBase(const char* device, size_t size = 0,
+ uint32_t flags = 0);
/*
* maps memory from ashmem, with the given name for debugging
* if the READ_ONLY flag is set, the memory will be writeable by the calling process,
* but not by others. this is NOT the case with the other ctors.
*/
- explicit MemoryHeapBase(size_t size, uint32_t flags = 0, char const* name = nullptr);
+ LIBBINDER_EXPORTED explicit MemoryHeapBase(size_t size, uint32_t flags = 0,
+ char const* name = nullptr);
- virtual ~MemoryHeapBase();
+ LIBBINDER_EXPORTED virtual ~MemoryHeapBase();
/* implement IMemoryHeap interface */
- int getHeapID() const override;
+ LIBBINDER_EXPORTED int getHeapID() const override;
/* virtual address of the heap. returns MAP_FAILED in case of error */
- void* getBase() const override;
+ LIBBINDER_EXPORTED void* getBase() const override;
- size_t getSize() const override;
- uint32_t getFlags() const override;
- off_t getOffset() const override;
+ LIBBINDER_EXPORTED size_t getSize() const override;
+ LIBBINDER_EXPORTED uint32_t getFlags() const override;
+ LIBBINDER_EXPORTED off_t getOffset() const override;
- const char* getDevice() const;
+ LIBBINDER_EXPORTED const char* getDevice() const;
/* this closes this heap -- use carefully */
- void dispose();
+ LIBBINDER_EXPORTED void dispose();
protected:
- MemoryHeapBase();
+ LIBBINDER_EXPORTED MemoryHeapBase();
// init() takes ownership of fd
- status_t init(int fd, void *base, size_t size,
- int flags = 0, const char* device = nullptr);
+ LIBBINDER_EXPORTED status_t init(int fd, void* base, size_t size, int flags = 0,
+ const char* device = nullptr);
private:
status_t mapfd(int fd, bool writeableByCaller, size_t size, off_t offset = 0);
diff --git a/libs/binder/include/binder/Parcel.h b/libs/binder/include/binder/Parcel.h
index 5e18b91..298b2f4 100644
--- a/libs/binder/include/binder/Parcel.h
+++ b/libs/binder/include/binder/Parcel.h
@@ -34,6 +34,7 @@
#include <utils/String16.h>
#include <utils/Vector.h>
+#include <binder/Common.h>
#include <binder/IInterface.h>
#include <binder/Parcelable.h>
@@ -68,73 +69,74 @@
class ReadableBlob;
class WritableBlob;
- Parcel();
- ~Parcel();
-
- const uint8_t* data() const;
- size_t dataSize() const;
- size_t dataAvail() const;
- size_t dataPosition() const;
- size_t dataCapacity() const;
- size_t dataBufferSize() const;
+ LIBBINDER_EXPORTED Parcel();
+ LIBBINDER_EXPORTED ~Parcel();
- status_t setDataSize(size_t size);
+ LIBBINDER_EXPORTED const uint8_t* data() const;
+ LIBBINDER_EXPORTED size_t dataSize() const;
+ LIBBINDER_EXPORTED size_t dataAvail() const;
+ LIBBINDER_EXPORTED size_t dataPosition() const;
+ LIBBINDER_EXPORTED size_t dataCapacity() const;
+ LIBBINDER_EXPORTED size_t dataBufferSize() const;
+
+ LIBBINDER_EXPORTED status_t setDataSize(size_t size);
// this must only be used to set a data position that was previously returned from
// dataPosition(). If writes are made, the exact same types of writes must be made (e.g.
// auto i = p.dataPosition(); p.writeInt32(0); p.setDataPosition(i); p.writeInt32(1);).
// Writing over objects, such as file descriptors and binders, is not supported.
- void setDataPosition(size_t pos) const;
- status_t setDataCapacity(size_t size);
+ LIBBINDER_EXPORTED void setDataPosition(size_t pos) const;
+ LIBBINDER_EXPORTED status_t setDataCapacity(size_t size);
- status_t setData(const uint8_t* buffer, size_t len);
+ LIBBINDER_EXPORTED status_t setData(const uint8_t* buffer, size_t len);
- status_t appendFrom(const Parcel *parcel,
- size_t start, size_t len);
+ LIBBINDER_EXPORTED status_t appendFrom(const Parcel* parcel, size_t start, size_t len);
- int compareData(const Parcel& other);
- status_t compareDataInRange(size_t thisOffset, const Parcel& other, size_t otherOffset,
- size_t length, int* result) const;
+ LIBBINDER_EXPORTED int compareData(const Parcel& other);
+ LIBBINDER_EXPORTED status_t compareDataInRange(size_t thisOffset, const Parcel& other,
+ size_t otherOffset, size_t length,
+ int* result) const;
- bool allowFds() const;
- bool pushAllowFds(bool allowFds);
- void restoreAllowFds(bool lastValue);
+ LIBBINDER_EXPORTED bool allowFds() const;
+ LIBBINDER_EXPORTED bool pushAllowFds(bool allowFds);
+ LIBBINDER_EXPORTED void restoreAllowFds(bool lastValue);
- bool hasFileDescriptors() const;
- status_t hasBinders(bool* result) const;
- status_t hasFileDescriptorsInRange(size_t offset, size_t length, bool* result) const;
- status_t hasBindersInRange(size_t offset, size_t length, bool* result) const;
+ LIBBINDER_EXPORTED bool hasFileDescriptors() const;
+ LIBBINDER_EXPORTED status_t hasBinders(bool* result) const;
+ LIBBINDER_EXPORTED status_t hasFileDescriptorsInRange(size_t offset, size_t length,
+ bool* result) const;
+ LIBBINDER_EXPORTED status_t hasBindersInRange(size_t offset, size_t length, bool* result) const;
// returns all binder objects in the Parcel
- std::vector<sp<IBinder>> debugReadAllStrongBinders() const;
+ LIBBINDER_EXPORTED std::vector<sp<IBinder>> debugReadAllStrongBinders() const;
// returns all file descriptors in the Parcel
// does not dup
- std::vector<int> debugReadAllFileDescriptors() const;
+ LIBBINDER_EXPORTED std::vector<int> debugReadAllFileDescriptors() const;
// Zeros data when reallocating. Other mitigations may be added
// in the future.
//
// WARNING: some read methods may make additional copies of data.
// In order to verify this, heap dumps should be used.
- void markSensitive() const;
+ LIBBINDER_EXPORTED void markSensitive() const;
// For a 'data' Parcel, this should mark the Parcel as being prepared for a
// transaction on this specific binder object. Based on this, the format of
// the wire binder protocol may change (data is written differently when it
// is for an RPC transaction).
- void markForBinder(const sp<IBinder>& binder);
+ LIBBINDER_EXPORTED void markForBinder(const sp<IBinder>& binder);
// Whenever possible, markForBinder should be preferred. This method is
// called automatically on reply Parcels for RPC transactions.
- void markForRpc(const sp<RpcSession>& session);
+ LIBBINDER_EXPORTED void markForRpc(const sp<RpcSession>& session);
// Whether this Parcel is written for RPC transactions (after calls to
// markForBinder or markForRpc).
- bool isForRpc() const;
+ LIBBINDER_EXPORTED bool isForRpc() const;
// Writes the IPC/RPC header.
- status_t writeInterfaceToken(const String16& interface);
- status_t writeInterfaceToken(const char16_t* str, size_t len);
+ LIBBINDER_EXPORTED status_t writeInterfaceToken(const String16& interface);
+ LIBBINDER_EXPORTED status_t writeInterfaceToken(const char16_t* str, size_t len);
// Parses the RPC header, returning true if the interface name
// in the header matches the expected interface from the caller.
@@ -143,101 +145,116 @@
// propagating the StrictMode policy mask, populating the current
// IPCThreadState, which as an optimization may optionally be
// passed in.
- bool enforceInterface(const String16& interface,
- IPCThreadState* threadState = nullptr) const;
- bool enforceInterface(const char16_t* interface,
- size_t len,
- IPCThreadState* threadState = nullptr) const;
- bool checkInterface(IBinder*) const;
+ LIBBINDER_EXPORTED bool enforceInterface(const String16& interface,
+ IPCThreadState* threadState = nullptr) const;
+ LIBBINDER_EXPORTED bool enforceInterface(const char16_t* interface, size_t len,
+ IPCThreadState* threadState = nullptr) const;
+ LIBBINDER_EXPORTED bool checkInterface(IBinder*) const;
// Verify there are no bytes left to be read on the Parcel.
// Returns Status(EX_BAD_PARCELABLE) when the Parcel is not consumed.
- binder::Status enforceNoDataAvail() const;
+ LIBBINDER_EXPORTED binder::Status enforceNoDataAvail() const;
// This Api is used by fuzzers to skip dataAvail checks.
- void setEnforceNoDataAvail(bool enforceNoDataAvail);
+ LIBBINDER_EXPORTED void setEnforceNoDataAvail(bool enforceNoDataAvail);
// When fuzzing, we want to remove certain ABI checks that cause significant
// lost coverage, and we also want to avoid logs that cost too much to write.
- void setServiceFuzzing();
- bool isServiceFuzzing() const;
+ LIBBINDER_EXPORTED void setServiceFuzzing();
+ LIBBINDER_EXPORTED bool isServiceFuzzing() const;
- void freeData();
+ LIBBINDER_EXPORTED void freeData();
- size_t objectsCount() const;
-
- status_t errorCheck() const;
- void setError(status_t err);
-
- status_t write(const void* data, size_t len);
- void* writeInplace(size_t len);
- status_t writeUnpadded(const void* data, size_t len);
- status_t writeInt32(int32_t val);
- status_t writeUint32(uint32_t val);
- status_t writeInt64(int64_t val);
- status_t writeUint64(uint64_t val);
- status_t writeFloat(float val);
- status_t writeDouble(double val);
- status_t writeCString(const char* str);
- status_t writeString8(const String8& str);
- status_t writeString8(const char* str, size_t len);
- status_t writeString16(const String16& str);
- status_t writeString16(const std::optional<String16>& str);
- status_t writeString16(const std::unique_ptr<String16>& str) __attribute__((deprecated("use std::optional version instead")));
- status_t writeString16(const char16_t* str, size_t len);
- status_t writeStrongBinder(const sp<IBinder>& val);
- status_t writeInt32Array(size_t len, const int32_t *val);
- status_t writeByteArray(size_t len, const uint8_t *val);
- status_t writeBool(bool val);
- status_t writeChar(char16_t val);
- status_t writeByte(int8_t val);
+ LIBBINDER_EXPORTED size_t objectsCount() const;
+
+ LIBBINDER_EXPORTED status_t errorCheck() const;
+ LIBBINDER_EXPORTED void setError(status_t err);
+
+ LIBBINDER_EXPORTED status_t write(const void* data, size_t len);
+ LIBBINDER_EXPORTED void* writeInplace(size_t len);
+ LIBBINDER_EXPORTED status_t writeUnpadded(const void* data, size_t len);
+ LIBBINDER_EXPORTED status_t writeInt32(int32_t val);
+ LIBBINDER_EXPORTED status_t writeUint32(uint32_t val);
+ LIBBINDER_EXPORTED status_t writeInt64(int64_t val);
+ LIBBINDER_EXPORTED status_t writeUint64(uint64_t val);
+ LIBBINDER_EXPORTED status_t writeFloat(float val);
+ LIBBINDER_EXPORTED status_t writeDouble(double val);
+ LIBBINDER_EXPORTED status_t writeCString(const char* str);
+ LIBBINDER_EXPORTED status_t writeString8(const String8& str);
+ LIBBINDER_EXPORTED status_t writeString8(const char* str, size_t len);
+ LIBBINDER_EXPORTED status_t writeString16(const String16& str);
+ LIBBINDER_EXPORTED status_t writeString16(const std::optional<String16>& str);
+ LIBBINDER_EXPORTED status_t writeString16(const std::unique_ptr<String16>& str)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeString16(const char16_t* str, size_t len);
+ LIBBINDER_EXPORTED status_t writeStrongBinder(const sp<IBinder>& val);
+ LIBBINDER_EXPORTED status_t writeInt32Array(size_t len, const int32_t* val);
+ LIBBINDER_EXPORTED status_t writeByteArray(size_t len, const uint8_t* val);
+ LIBBINDER_EXPORTED status_t writeBool(bool val);
+ LIBBINDER_EXPORTED status_t writeChar(char16_t val);
+ LIBBINDER_EXPORTED status_t writeByte(int8_t val);
// Take a UTF8 encoded string, convert to UTF16, write it to the parcel.
- status_t writeUtf8AsUtf16(const std::string& str);
- status_t writeUtf8AsUtf16(const std::optional<std::string>& str);
- status_t writeUtf8AsUtf16(const std::unique_ptr<std::string>& str) __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeUtf8AsUtf16(const std::string& str);
+ LIBBINDER_EXPORTED status_t writeUtf8AsUtf16(const std::optional<std::string>& str);
+ LIBBINDER_EXPORTED status_t writeUtf8AsUtf16(const std::unique_ptr<std::string>& str)
+ __attribute__((deprecated("use std::optional version instead")));
- status_t writeByteVector(const std::optional<std::vector<int8_t>>& val);
- status_t writeByteVector(const std::unique_ptr<std::vector<int8_t>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeByteVector(const std::vector<int8_t>& val);
- status_t writeByteVector(const std::optional<std::vector<uint8_t>>& val);
- status_t writeByteVector(const std::unique_ptr<std::vector<uint8_t>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeByteVector(const std::vector<uint8_t>& val);
- status_t writeInt32Vector(const std::optional<std::vector<int32_t>>& val);
- status_t writeInt32Vector(const std::unique_ptr<std::vector<int32_t>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeInt32Vector(const std::vector<int32_t>& val);
- status_t writeInt64Vector(const std::optional<std::vector<int64_t>>& val);
- status_t writeInt64Vector(const std::unique_ptr<std::vector<int64_t>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeInt64Vector(const std::vector<int64_t>& val);
- status_t writeUint64Vector(const std::optional<std::vector<uint64_t>>& val);
- status_t writeUint64Vector(const std::unique_ptr<std::vector<uint64_t>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeUint64Vector(const std::vector<uint64_t>& val);
- status_t writeFloatVector(const std::optional<std::vector<float>>& val);
- status_t writeFloatVector(const std::unique_ptr<std::vector<float>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeFloatVector(const std::vector<float>& val);
- status_t writeDoubleVector(const std::optional<std::vector<double>>& val);
- status_t writeDoubleVector(const std::unique_ptr<std::vector<double>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeDoubleVector(const std::vector<double>& val);
- status_t writeBoolVector(const std::optional<std::vector<bool>>& val);
- status_t writeBoolVector(const std::unique_ptr<std::vector<bool>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeBoolVector(const std::vector<bool>& val);
- status_t writeCharVector(const std::optional<std::vector<char16_t>>& val);
- status_t writeCharVector(const std::unique_ptr<std::vector<char16_t>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeCharVector(const std::vector<char16_t>& val);
- status_t writeString16Vector(
- const std::optional<std::vector<std::optional<String16>>>& val);
- status_t writeString16Vector(
- const std::unique_ptr<std::vector<std::unique_ptr<String16>>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeString16Vector(const std::vector<String16>& val);
- status_t writeUtf8VectorAsUtf16Vector(
- const std::optional<std::vector<std::optional<std::string>>>& val);
- status_t writeUtf8VectorAsUtf16Vector(
- const std::unique_ptr<std::vector<std::unique_ptr<std::string>>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeUtf8VectorAsUtf16Vector(const std::vector<std::string>& val);
+ LIBBINDER_EXPORTED status_t writeByteVector(const std::optional<std::vector<int8_t>>& val);
+ LIBBINDER_EXPORTED status_t writeByteVector(const std::unique_ptr<std::vector<int8_t>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeByteVector(const std::vector<int8_t>& val);
+ LIBBINDER_EXPORTED status_t writeByteVector(const std::optional<std::vector<uint8_t>>& val);
+ LIBBINDER_EXPORTED status_t writeByteVector(const std::unique_ptr<std::vector<uint8_t>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeByteVector(const std::vector<uint8_t>& val);
+ LIBBINDER_EXPORTED status_t writeInt32Vector(const std::optional<std::vector<int32_t>>& val);
+ LIBBINDER_EXPORTED status_t writeInt32Vector(const std::unique_ptr<std::vector<int32_t>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeInt32Vector(const std::vector<int32_t>& val);
+ LIBBINDER_EXPORTED status_t writeInt64Vector(const std::optional<std::vector<int64_t>>& val);
+ LIBBINDER_EXPORTED status_t writeInt64Vector(const std::unique_ptr<std::vector<int64_t>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeInt64Vector(const std::vector<int64_t>& val);
+ LIBBINDER_EXPORTED status_t writeUint64Vector(const std::optional<std::vector<uint64_t>>& val);
+ LIBBINDER_EXPORTED status_t writeUint64Vector(const std::unique_ptr<std::vector<uint64_t>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeUint64Vector(const std::vector<uint64_t>& val);
+ LIBBINDER_EXPORTED status_t writeFloatVector(const std::optional<std::vector<float>>& val);
+ LIBBINDER_EXPORTED status_t writeFloatVector(const std::unique_ptr<std::vector<float>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeFloatVector(const std::vector<float>& val);
+ LIBBINDER_EXPORTED status_t writeDoubleVector(const std::optional<std::vector<double>>& val);
+ LIBBINDER_EXPORTED status_t writeDoubleVector(const std::unique_ptr<std::vector<double>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeDoubleVector(const std::vector<double>& val);
+ LIBBINDER_EXPORTED status_t writeBoolVector(const std::optional<std::vector<bool>>& val);
+ LIBBINDER_EXPORTED status_t writeBoolVector(const std::unique_ptr<std::vector<bool>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeBoolVector(const std::vector<bool>& val);
+ LIBBINDER_EXPORTED status_t writeCharVector(const std::optional<std::vector<char16_t>>& val);
+ LIBBINDER_EXPORTED status_t writeCharVector(const std::unique_ptr<std::vector<char16_t>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeCharVector(const std::vector<char16_t>& val);
+ LIBBINDER_EXPORTED status_t
+ writeString16Vector(const std::optional<std::vector<std::optional<String16>>>& val);
+ LIBBINDER_EXPORTED status_t
+ writeString16Vector(const std::unique_ptr<std::vector<std::unique_ptr<String16>>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeString16Vector(const std::vector<String16>& val);
+ LIBBINDER_EXPORTED status_t
+ writeUtf8VectorAsUtf16Vector(const std::optional<std::vector<std::optional<std::string>>>& val);
+ LIBBINDER_EXPORTED status_t writeUtf8VectorAsUtf16Vector(
+ const std::unique_ptr<std::vector<std::unique_ptr<std::string>>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeUtf8VectorAsUtf16Vector(const std::vector<std::string>& val);
- status_t writeStrongBinderVector(const std::optional<std::vector<sp<IBinder>>>& val);
- status_t writeStrongBinderVector(const std::unique_ptr<std::vector<sp<IBinder>>>& val) __attribute__((deprecated("use std::optional version instead")));
- status_t writeStrongBinderVector(const std::vector<sp<IBinder>>& val);
+ LIBBINDER_EXPORTED status_t
+ writeStrongBinderVector(const std::optional<std::vector<sp<IBinder>>>& val);
+ LIBBINDER_EXPORTED status_t
+ writeStrongBinderVector(const std::unique_ptr<std::vector<sp<IBinder>>>& val)
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t writeStrongBinderVector(const std::vector<sp<IBinder>>& val);
// Write an IInterface or a vector of IInterface's
template <typename T,
@@ -315,7 +332,7 @@
return writeData(parcelable);
}
- status_t writeParcelable(const Parcelable& parcelable);
+ LIBBINDER_EXPORTED status_t writeParcelable(const Parcelable& parcelable);
template<typename T>
status_t write(const Flattenable<T>& val);
@@ -335,40 +352,41 @@
// descriptors are dup'ed, so it is safe to delete the native_handle
// when this function returns).
// Doesn't take ownership of the native_handle.
- status_t writeNativeHandle(const native_handle* handle);
+ LIBBINDER_EXPORTED status_t writeNativeHandle(const native_handle* handle);
#endif
// Place a file descriptor into the parcel. The given fd must remain
// valid for the lifetime of the parcel.
// The Parcel does not take ownership of the given fd unless you ask it to.
- status_t writeFileDescriptor(int fd, bool takeOwnership = false);
+ LIBBINDER_EXPORTED status_t writeFileDescriptor(int fd, bool takeOwnership = false);
// Place a file descriptor into the parcel. A dup of the fd is made, which
// will be closed once the parcel is destroyed.
- status_t writeDupFileDescriptor(int fd);
+ LIBBINDER_EXPORTED status_t writeDupFileDescriptor(int fd);
// Place a Java "parcel file descriptor" into the parcel. The given fd must remain
// valid for the lifetime of the parcel.
// The Parcel does not take ownership of the given fd unless you ask it to.
- status_t writeParcelFileDescriptor(int fd, bool takeOwnership = false);
+ LIBBINDER_EXPORTED status_t writeParcelFileDescriptor(int fd, bool takeOwnership = false);
// Place a Java "parcel file descriptor" into the parcel. A dup of the fd is made, which will
// be closed once the parcel is destroyed.
- status_t writeDupParcelFileDescriptor(int fd);
+ LIBBINDER_EXPORTED status_t writeDupParcelFileDescriptor(int fd);
// Place a file descriptor into the parcel. This will not affect the
// semantics of the smart file descriptor. A new descriptor will be
// created, and will be closed when the parcel is destroyed.
- status_t writeUniqueFileDescriptor(const binder::unique_fd& fd);
+ LIBBINDER_EXPORTED status_t writeUniqueFileDescriptor(const binder::unique_fd& fd);
// Place a vector of file desciptors into the parcel. Each descriptor is
// dup'd as in writeDupFileDescriptor
- status_t writeUniqueFileDescriptorVector(
- const std::optional<std::vector<binder::unique_fd>>& val);
- status_t writeUniqueFileDescriptorVector(
- const std::unique_ptr<std::vector<binder::unique_fd>>& val)
+ LIBBINDER_EXPORTED status_t
+ writeUniqueFileDescriptorVector(const std::optional<std::vector<binder::unique_fd>>& val);
+ LIBBINDER_EXPORTED status_t
+ writeUniqueFileDescriptorVector(const std::unique_ptr<std::vector<binder::unique_fd>>& val)
__attribute__((deprecated("use std::optional version instead")));
- status_t writeUniqueFileDescriptorVector(const std::vector<binder::unique_fd>& val);
+ LIBBINDER_EXPORTED status_t
+ writeUniqueFileDescriptorVector(const std::vector<binder::unique_fd>& val);
// Writes a blob to the parcel.
// If the blob is small, then it is stored in-place, otherwise it is
@@ -376,58 +394,60 @@
// immutable blobs if possible since they may be subsequently transferred between
// processes without further copying whereas mutable blobs always need to be copied.
// The caller should call release() on the blob after writing its contents.
- status_t writeBlob(size_t len, bool mutableCopy, WritableBlob* outBlob);
+ LIBBINDER_EXPORTED status_t writeBlob(size_t len, bool mutableCopy, WritableBlob* outBlob);
// Write an existing immutable blob file descriptor to the parcel.
// This allows the client to send the same blob to multiple processes
// as long as it keeps a dup of the blob file descriptor handy for later.
- status_t writeDupImmutableBlobFileDescriptor(int fd);
+ LIBBINDER_EXPORTED status_t writeDupImmutableBlobFileDescriptor(int fd);
- status_t writeObject(const flat_binder_object& val, bool nullMetaData);
+ LIBBINDER_EXPORTED status_t writeObject(const flat_binder_object& val, bool nullMetaData);
// Like Parcel.java's writeNoException(). Just writes a zero int32.
// Currently the native implementation doesn't do any of the StrictMode
// stack gathering and serialization that the Java implementation does.
- status_t writeNoException();
-
- status_t read(void* outData, size_t len) const;
- const void* readInplace(size_t len) const;
- int32_t readInt32() const;
- status_t readInt32(int32_t *pArg) const;
- uint32_t readUint32() const;
- status_t readUint32(uint32_t *pArg) const;
- int64_t readInt64() const;
- status_t readInt64(int64_t *pArg) const;
- uint64_t readUint64() const;
- status_t readUint64(uint64_t *pArg) const;
- float readFloat() const;
- status_t readFloat(float *pArg) const;
- double readDouble() const;
- status_t readDouble(double *pArg) const;
- bool readBool() const;
- status_t readBool(bool *pArg) const;
- char16_t readChar() const;
- status_t readChar(char16_t *pArg) const;
- int8_t readByte() const;
- status_t readByte(int8_t *pArg) const;
+ LIBBINDER_EXPORTED status_t writeNoException();
+
+ LIBBINDER_EXPORTED status_t read(void* outData, size_t len) const;
+ LIBBINDER_EXPORTED const void* readInplace(size_t len) const;
+ LIBBINDER_EXPORTED int32_t readInt32() const;
+ LIBBINDER_EXPORTED status_t readInt32(int32_t* pArg) const;
+ LIBBINDER_EXPORTED uint32_t readUint32() const;
+ LIBBINDER_EXPORTED status_t readUint32(uint32_t* pArg) const;
+ LIBBINDER_EXPORTED int64_t readInt64() const;
+ LIBBINDER_EXPORTED status_t readInt64(int64_t* pArg) const;
+ LIBBINDER_EXPORTED uint64_t readUint64() const;
+ LIBBINDER_EXPORTED status_t readUint64(uint64_t* pArg) const;
+ LIBBINDER_EXPORTED float readFloat() const;
+ LIBBINDER_EXPORTED status_t readFloat(float* pArg) const;
+ LIBBINDER_EXPORTED double readDouble() const;
+ LIBBINDER_EXPORTED status_t readDouble(double* pArg) const;
+ LIBBINDER_EXPORTED bool readBool() const;
+ LIBBINDER_EXPORTED status_t readBool(bool* pArg) const;
+ LIBBINDER_EXPORTED char16_t readChar() const;
+ LIBBINDER_EXPORTED status_t readChar(char16_t* pArg) const;
+ LIBBINDER_EXPORTED int8_t readByte() const;
+ LIBBINDER_EXPORTED status_t readByte(int8_t* pArg) const;
// Read a UTF16 encoded string, convert to UTF8
- status_t readUtf8FromUtf16(std::string* str) const;
- status_t readUtf8FromUtf16(std::optional<std::string>* str) const;
- status_t readUtf8FromUtf16(std::unique_ptr<std::string>* str) const __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readUtf8FromUtf16(std::string* str) const;
+ LIBBINDER_EXPORTED status_t readUtf8FromUtf16(std::optional<std::string>* str) const;
+ LIBBINDER_EXPORTED status_t readUtf8FromUtf16(std::unique_ptr<std::string>* str) const
+ __attribute__((deprecated("use std::optional version instead")));
- const char* readCString() const;
- String8 readString8() const;
- status_t readString8(String8* pArg) const;
- const char* readString8Inplace(size_t* outLen) const;
- String16 readString16() const;
- status_t readString16(String16* pArg) const;
- status_t readString16(std::optional<String16>* pArg) const;
- status_t readString16(std::unique_ptr<String16>* pArg) const __attribute__((deprecated("use std::optional version instead")));
- const char16_t* readString16Inplace(size_t* outLen) const;
- sp<IBinder> readStrongBinder() const;
- status_t readStrongBinder(sp<IBinder>* val) const;
- status_t readNullableStrongBinder(sp<IBinder>* val) const;
+ LIBBINDER_EXPORTED const char* readCString() const;
+ LIBBINDER_EXPORTED String8 readString8() const;
+ LIBBINDER_EXPORTED status_t readString8(String8* pArg) const;
+ LIBBINDER_EXPORTED const char* readString8Inplace(size_t* outLen) const;
+ LIBBINDER_EXPORTED String16 readString16() const;
+ LIBBINDER_EXPORTED status_t readString16(String16* pArg) const;
+ LIBBINDER_EXPORTED status_t readString16(std::optional<String16>* pArg) const;
+ LIBBINDER_EXPORTED status_t readString16(std::unique_ptr<String16>* pArg) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED const char16_t* readString16Inplace(size_t* outLen) const;
+ LIBBINDER_EXPORTED sp<IBinder> readStrongBinder() const;
+ LIBBINDER_EXPORTED status_t readStrongBinder(sp<IBinder>* val) const;
+ LIBBINDER_EXPORTED status_t readNullableStrongBinder(sp<IBinder>* val) const;
// Read an Enum vector with underlying type int8_t.
// Does not use padding; each byte is contiguous.
@@ -466,7 +486,7 @@
status_t readParcelableVector(std::vector<T>* val) const
{ return readData(val); }
- status_t readParcelable(Parcelable* parcelable) const;
+ LIBBINDER_EXPORTED status_t readParcelable(Parcelable* parcelable) const;
template<typename T>
status_t readParcelable(std::optional<T>* parcelable) const
@@ -484,9 +504,12 @@
template<typename T>
status_t readNullableStrongBinder(sp<T>* val) const;
- status_t readStrongBinderVector(std::optional<std::vector<sp<IBinder>>>* val) const;
- status_t readStrongBinderVector(std::unique_ptr<std::vector<sp<IBinder>>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readStrongBinderVector(std::vector<sp<IBinder>>* val) const;
+ LIBBINDER_EXPORTED status_t
+ readStrongBinderVector(std::optional<std::vector<sp<IBinder>>>* val) const;
+ LIBBINDER_EXPORTED status_t
+ readStrongBinderVector(std::unique_ptr<std::vector<sp<IBinder>>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readStrongBinderVector(std::vector<sp<IBinder>>* val) const;
template <typename T,
std::enable_if_t<std::is_base_of_v<::android::IInterface, T>, bool> = true>
status_t readStrongBinderVector(std::vector<sp<T>>* val) const {
@@ -498,43 +521,54 @@
return readData(val);
}
- status_t readByteVector(std::optional<std::vector<int8_t>>* val) const;
- status_t readByteVector(std::unique_ptr<std::vector<int8_t>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readByteVector(std::vector<int8_t>* val) const;
- status_t readByteVector(std::optional<std::vector<uint8_t>>* val) const;
- status_t readByteVector(std::unique_ptr<std::vector<uint8_t>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readByteVector(std::vector<uint8_t>* val) const;
- status_t readInt32Vector(std::optional<std::vector<int32_t>>* val) const;
- status_t readInt32Vector(std::unique_ptr<std::vector<int32_t>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readInt32Vector(std::vector<int32_t>* val) const;
- status_t readInt64Vector(std::optional<std::vector<int64_t>>* val) const;
- status_t readInt64Vector(std::unique_ptr<std::vector<int64_t>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readInt64Vector(std::vector<int64_t>* val) const;
- status_t readUint64Vector(std::optional<std::vector<uint64_t>>* val) const;
- status_t readUint64Vector(std::unique_ptr<std::vector<uint64_t>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readUint64Vector(std::vector<uint64_t>* val) const;
- status_t readFloatVector(std::optional<std::vector<float>>* val) const;
- status_t readFloatVector(std::unique_ptr<std::vector<float>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readFloatVector(std::vector<float>* val) const;
- status_t readDoubleVector(std::optional<std::vector<double>>* val) const;
- status_t readDoubleVector(std::unique_ptr<std::vector<double>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readDoubleVector(std::vector<double>* val) const;
- status_t readBoolVector(std::optional<std::vector<bool>>* val) const;
- status_t readBoolVector(std::unique_ptr<std::vector<bool>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readBoolVector(std::vector<bool>* val) const;
- status_t readCharVector(std::optional<std::vector<char16_t>>* val) const;
- status_t readCharVector(std::unique_ptr<std::vector<char16_t>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readCharVector(std::vector<char16_t>* val) const;
- status_t readString16Vector(
- std::optional<std::vector<std::optional<String16>>>* val) const;
- status_t readString16Vector(
- std::unique_ptr<std::vector<std::unique_ptr<String16>>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readString16Vector(std::vector<String16>* val) const;
- status_t readUtf8VectorFromUtf16Vector(
- std::optional<std::vector<std::optional<std::string>>>* val) const;
- status_t readUtf8VectorFromUtf16Vector(
- std::unique_ptr<std::vector<std::unique_ptr<std::string>>>* val) const __attribute__((deprecated("use std::optional version instead")));
- status_t readUtf8VectorFromUtf16Vector(std::vector<std::string>* val) const;
+ LIBBINDER_EXPORTED status_t readByteVector(std::optional<std::vector<int8_t>>* val) const;
+ LIBBINDER_EXPORTED status_t readByteVector(std::unique_ptr<std::vector<int8_t>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readByteVector(std::vector<int8_t>* val) const;
+ LIBBINDER_EXPORTED status_t readByteVector(std::optional<std::vector<uint8_t>>* val) const;
+ LIBBINDER_EXPORTED status_t readByteVector(std::unique_ptr<std::vector<uint8_t>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readByteVector(std::vector<uint8_t>* val) const;
+ LIBBINDER_EXPORTED status_t readInt32Vector(std::optional<std::vector<int32_t>>* val) const;
+ LIBBINDER_EXPORTED status_t readInt32Vector(std::unique_ptr<std::vector<int32_t>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readInt32Vector(std::vector<int32_t>* val) const;
+ LIBBINDER_EXPORTED status_t readInt64Vector(std::optional<std::vector<int64_t>>* val) const;
+ LIBBINDER_EXPORTED status_t readInt64Vector(std::unique_ptr<std::vector<int64_t>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readInt64Vector(std::vector<int64_t>* val) const;
+ LIBBINDER_EXPORTED status_t readUint64Vector(std::optional<std::vector<uint64_t>>* val) const;
+ LIBBINDER_EXPORTED status_t readUint64Vector(std::unique_ptr<std::vector<uint64_t>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readUint64Vector(std::vector<uint64_t>* val) const;
+ LIBBINDER_EXPORTED status_t readFloatVector(std::optional<std::vector<float>>* val) const;
+ LIBBINDER_EXPORTED status_t readFloatVector(std::unique_ptr<std::vector<float>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readFloatVector(std::vector<float>* val) const;
+ LIBBINDER_EXPORTED status_t readDoubleVector(std::optional<std::vector<double>>* val) const;
+ LIBBINDER_EXPORTED status_t readDoubleVector(std::unique_ptr<std::vector<double>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readDoubleVector(std::vector<double>* val) const;
+ LIBBINDER_EXPORTED status_t readBoolVector(std::optional<std::vector<bool>>* val) const;
+ LIBBINDER_EXPORTED status_t readBoolVector(std::unique_ptr<std::vector<bool>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readBoolVector(std::vector<bool>* val) const;
+ LIBBINDER_EXPORTED status_t readCharVector(std::optional<std::vector<char16_t>>* val) const;
+ LIBBINDER_EXPORTED status_t readCharVector(std::unique_ptr<std::vector<char16_t>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readCharVector(std::vector<char16_t>* val) const;
+ LIBBINDER_EXPORTED status_t
+ readString16Vector(std::optional<std::vector<std::optional<String16>>>* val) const;
+ LIBBINDER_EXPORTED status_t
+ readString16Vector(std::unique_ptr<std::vector<std::unique_ptr<String16>>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readString16Vector(std::vector<String16>* val) const;
+ LIBBINDER_EXPORTED status_t readUtf8VectorFromUtf16Vector(
+ std::optional<std::vector<std::optional<std::string>>>* val) const;
+ LIBBINDER_EXPORTED status_t readUtf8VectorFromUtf16Vector(
+ std::unique_ptr<std::vector<std::unique_ptr<std::string>>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t readUtf8VectorFromUtf16Vector(std::vector<std::string>* val) const;
template <typename T, size_t N>
status_t readFixedArray(std::array<T, N>* val) const {
@@ -564,56 +598,58 @@
// code on exceptions, but also deals with skipping over rich
// response headers. Callers should use this to read & parse the
// response headers rather than doing it by hand.
- int32_t readExceptionCode() const;
+ LIBBINDER_EXPORTED int32_t readExceptionCode() const;
#ifndef BINDER_DISABLE_NATIVE_HANDLE
// Retrieve native_handle from the parcel. This returns a copy of the
// parcel's native_handle (the caller takes ownership). The caller
// must free the native_handle with native_handle_close() and
// native_handle_delete().
- native_handle* readNativeHandle() const;
+ LIBBINDER_EXPORTED native_handle* readNativeHandle() const;
#endif
// Retrieve a file descriptor from the parcel. This returns the raw fd
// in the parcel, which you do not own -- use dup() to get your own copy.
- int readFileDescriptor() const;
+ LIBBINDER_EXPORTED int readFileDescriptor() const;
// Retrieve a Java "parcel file descriptor" from the parcel. This returns the raw fd
// in the parcel, which you do not own -- use dup() to get your own copy.
- int readParcelFileDescriptor() const;
+ LIBBINDER_EXPORTED int readParcelFileDescriptor() const;
// Retrieve a smart file descriptor from the parcel.
- status_t readUniqueFileDescriptor(binder::unique_fd* val) const;
+ LIBBINDER_EXPORTED status_t readUniqueFileDescriptor(binder::unique_fd* val) const;
// Retrieve a Java "parcel file descriptor" from the parcel.
- status_t readUniqueParcelFileDescriptor(binder::unique_fd* val) const;
+ LIBBINDER_EXPORTED status_t readUniqueParcelFileDescriptor(binder::unique_fd* val) const;
// Retrieve a vector of smart file descriptors from the parcel.
- status_t readUniqueFileDescriptorVector(
- std::optional<std::vector<binder::unique_fd>>* val) const;
- status_t readUniqueFileDescriptorVector(std::unique_ptr<std::vector<binder::unique_fd>>* val)
- const __attribute__((deprecated("use std::optional version instead")));
- status_t readUniqueFileDescriptorVector(std::vector<binder::unique_fd>* val) const;
+ LIBBINDER_EXPORTED status_t
+ readUniqueFileDescriptorVector(std::optional<std::vector<binder::unique_fd>>* val) const;
+ LIBBINDER_EXPORTED status_t
+ readUniqueFileDescriptorVector(std::unique_ptr<std::vector<binder::unique_fd>>* val) const
+ __attribute__((deprecated("use std::optional version instead")));
+ LIBBINDER_EXPORTED status_t
+ readUniqueFileDescriptorVector(std::vector<binder::unique_fd>* val) const;
// Reads a blob from the parcel.
// The caller should call release() on the blob after reading its contents.
- status_t readBlob(size_t len, ReadableBlob* outBlob) const;
+ LIBBINDER_EXPORTED status_t readBlob(size_t len, ReadableBlob* outBlob) const;
- const flat_binder_object* readObject(bool nullMetaData) const;
+ LIBBINDER_EXPORTED const flat_binder_object* readObject(bool nullMetaData) const;
// Explicitly close all file descriptors in the parcel.
- void closeFileDescriptors();
+ LIBBINDER_EXPORTED void closeFileDescriptors();
// Debugging: get metrics on current allocations.
- static size_t getGlobalAllocSize();
- static size_t getGlobalAllocCount();
+ LIBBINDER_EXPORTED static size_t getGlobalAllocSize();
+ LIBBINDER_EXPORTED static size_t getGlobalAllocCount();
- bool replaceCallingWorkSourceUid(uid_t uid);
+ LIBBINDER_EXPORTED bool replaceCallingWorkSourceUid(uid_t uid);
// Returns the work source provided by the caller. This can only be trusted for trusted calling
// uid.
- uid_t readCallingWorkSourceUid() const;
+ LIBBINDER_EXPORTED uid_t readCallingWorkSourceUid() const;
- void print(std::ostream& to, uint32_t flags = 0) const;
+ LIBBINDER_EXPORTED void print(std::ostream& to, uint32_t flags = 0) const;
private:
// `objects` and `objectsSize` always 0 for RPC Parcels.
@@ -660,7 +696,7 @@
status_t flattenBinder(const sp<IBinder>& binder);
status_t unflattenBinder(sp<IBinder>* out) const;
- status_t readOutVectorSizeWithCheck(size_t elmSize, int32_t* size) const;
+ LIBBINDER_EXPORTED status_t readOutVectorSizeWithCheck(size_t elmSize, int32_t* size) const;
template<class T>
status_t readAligned(T *pArg) const;
@@ -1356,14 +1392,14 @@
class Blob {
public:
- Blob();
- ~Blob();
+ LIBBINDER_EXPORTED Blob();
+ LIBBINDER_EXPORTED ~Blob();
- void clear();
- void release();
- inline size_t size() const { return mSize; }
- inline int fd() const { return mFd; }
- inline bool isMutable() const { return mMutable; }
+ LIBBINDER_EXPORTED void clear();
+ LIBBINDER_EXPORTED void release();
+ LIBBINDER_EXPORTED inline size_t size() const { return mSize; }
+ LIBBINDER_EXPORTED inline int fd() const { return mFd; }
+ LIBBINDER_EXPORTED inline bool isMutable() const { return mMutable; }
protected:
void init(int fd, void* data, size_t size, bool isMutable);
@@ -1381,7 +1417,7 @@
// FlattenableHelperInterface and FlattenableHelper avoid generating a vtable entry in objects
// following Flattenable template/protocol.
- class FlattenableHelperInterface {
+ class LIBBINDER_EXPORTED FlattenableHelperInterface {
protected:
~FlattenableHelperInterface() { }
public:
@@ -1420,21 +1456,21 @@
return const_cast<Flattenable<T>&>(val).unflatten(buffer, size, fds, count);
}
};
- status_t write(const FlattenableHelperInterface& val);
- status_t read(FlattenableHelperInterface& val) const;
+ LIBBINDER_EXPORTED status_t write(const FlattenableHelperInterface& val);
+ LIBBINDER_EXPORTED status_t read(FlattenableHelperInterface& val) const;
public:
class ReadableBlob : public Blob {
friend class Parcel;
public:
- inline const void* data() const { return mData; }
- inline void* mutableData() { return isMutable() ? mData : nullptr; }
+ LIBBINDER_EXPORTED inline const void* data() const { return mData; }
+ LIBBINDER_EXPORTED inline void* mutableData() { return isMutable() ? mData : nullptr; }
};
class WritableBlob : public Blob {
friend class Parcel;
public:
- inline void* data() { return mData; }
+ LIBBINDER_EXPORTED inline void* data() { return mData; }
};
/**
@@ -1444,12 +1480,12 @@
* is referenced by this Parcel, but which this parcel doesn't own (e.g.
* writeFileDescriptor is called without 'takeOwnership' true).
*/
- size_t getOpenAshmemSize() const;
+ LIBBINDER_EXPORTED size_t getOpenAshmemSize() const;
private:
// TODO(b/202029388): Remove 'getBlobAshmemSize' once no prebuilts reference
// this
- size_t getBlobAshmemSize() const;
+ LIBBINDER_EXPORTED size_t getBlobAshmemSize() const;
// Needed so that we can save object metadata to the disk
friend class android::binder::debug::RecordedTransaction;
diff --git a/libs/binder/include/binder/ParcelFileDescriptor.h b/libs/binder/include/binder/ParcelFileDescriptor.h
index c4ef354..50a1d39 100644
--- a/libs/binder/include/binder/ParcelFileDescriptor.h
+++ b/libs/binder/include/binder/ParcelFileDescriptor.h
@@ -16,6 +16,7 @@
#pragma once
+#include <binder/Common.h>
#include <binder/Parcel.h>
#include <binder/Parcelable.h>
#include <binder/unique_fd.h>
@@ -26,7 +27,7 @@
/*
* C++ implementation of the Java class android.os.ParcelFileDescriptor
*/
-class ParcelFileDescriptor : public android::Parcelable {
+class LIBBINDER_EXPORTED ParcelFileDescriptor : public android::Parcelable {
public:
ParcelFileDescriptor();
explicit ParcelFileDescriptor(binder::unique_fd fd);
diff --git a/libs/binder/include/binder/Parcelable.h b/libs/binder/include/binder/Parcelable.h
index 2c652be..0b707b3 100644
--- a/libs/binder/include/binder/Parcelable.h
+++ b/libs/binder/include/binder/Parcelable.h
@@ -21,6 +21,8 @@
#include <utils/Errors.h>
#include <utils/String16.h>
+#include <binder/Common.h>
+
namespace android {
class Parcel;
@@ -31,7 +33,7 @@
#endif
// Abstract interface of all parcelables.
-class Parcelable {
+class LIBBINDER_EXPORTED Parcelable {
public:
virtual ~Parcelable() = default;
diff --git a/libs/binder/include/binder/ParcelableHolder.h b/libs/binder/include/binder/ParcelableHolder.h
index 40fd30a..965d097 100644
--- a/libs/binder/include/binder/ParcelableHolder.h
+++ b/libs/binder/include/binder/ParcelableHolder.h
@@ -16,6 +16,7 @@
#pragma once
+#include <binder/Common.h>
#include <binder/Parcel.h>
#include <binder/Parcelable.h>
#include <utils/String16.h>
@@ -28,7 +29,7 @@
/*
* C++ implementation of the Java class android.os.ParcelableHolder
*/
-class ParcelableHolder : public android::Parcelable {
+class LIBBINDER_EXPORTED ParcelableHolder : public android::Parcelable {
public:
ParcelableHolder() = delete;
explicit ParcelableHolder(Stability stability) : mStability(stability){}
diff --git a/libs/binder/include/binder/PermissionCache.h b/libs/binder/include/binder/PermissionCache.h
index 21aa705..9c08016 100644
--- a/libs/binder/include/binder/PermissionCache.h
+++ b/libs/binder/include/binder/PermissionCache.h
@@ -24,6 +24,7 @@
#include <utils/String16.h>
#include <utils/Singleton.h>
#include <utils/SortedVector.h>
+#include <binder/Common.h>
namespace android {
// ---------------------------------------------------------------------------
@@ -64,17 +65,17 @@
void cache(const String16& permission, uid_t uid, bool granted);
public:
- PermissionCache();
+ LIBBINDER_EXPORTED PermissionCache();
- static bool checkCallingPermission(const String16& permission);
+ LIBBINDER_EXPORTED static bool checkCallingPermission(const String16& permission);
- static bool checkCallingPermission(const String16& permission,
- int32_t* outPid, int32_t* outUid);
+ LIBBINDER_EXPORTED static bool checkCallingPermission(const String16& permission,
+ int32_t* outPid, int32_t* outUid);
- static bool checkPermission(const String16& permission,
- pid_t pid, uid_t uid);
+ LIBBINDER_EXPORTED static bool checkPermission(const String16& permission, pid_t pid,
+ uid_t uid);
- static void purgeCache();
+ LIBBINDER_EXPORTED static void purgeCache();
};
// ---------------------------------------------------------------------------
diff --git a/libs/binder/include/binder/PermissionController.h b/libs/binder/include/binder/PermissionController.h
index 6f9eb5e..0cf0b70 100644
--- a/libs/binder/include/binder/PermissionController.h
+++ b/libs/binder/include/binder/PermissionController.h
@@ -18,14 +18,14 @@
#ifndef __ANDROID_VNDK__
+#include <binder/Common.h>
#include <binder/IPermissionController.h>
#include <utils/Mutex.h>
// ---------------------------------------------------------------------------
namespace android {
-class PermissionController
-{
+class PermissionController {
public:
enum {
@@ -42,13 +42,13 @@
MODE_DEFAULT = 3,
};
- PermissionController();
+ LIBBINDER_EXPORTED PermissionController();
- bool checkPermission(const String16& permission, int32_t pid, int32_t uid);
- int32_t noteOp(const String16& op, int32_t uid, const String16& packageName);
- void getPackagesForUid(const uid_t uid, Vector<String16>& packages);
- bool isRuntimePermission(const String16& permission);
- int getPackageUid(const String16& package, int flags);
+ LIBBINDER_EXPORTED bool checkPermission(const String16& permission, int32_t pid, int32_t uid);
+ LIBBINDER_EXPORTED int32_t noteOp(const String16& op, int32_t uid, const String16& packageName);
+ LIBBINDER_EXPORTED void getPackagesForUid(const uid_t uid, Vector<String16>& packages);
+ LIBBINDER_EXPORTED bool isRuntimePermission(const String16& permission);
+ LIBBINDER_EXPORTED int getPackageUid(const String16& package, int flags);
private:
Mutex mLock;
diff --git a/libs/binder/include/binder/PersistableBundle.h b/libs/binder/include/binder/PersistableBundle.h
index 4517cf2..7c3b625 100644
--- a/libs/binder/include/binder/PersistableBundle.h
+++ b/libs/binder/include/binder/PersistableBundle.h
@@ -20,6 +20,7 @@
#include <set>
#include <vector>
+#include <binder/Common.h>
#include <binder/Parcelable.h>
#include <utils/String16.h>
#include <utils/StrongPointer.h>
@@ -32,7 +33,7 @@
* C++ implementation of PersistableBundle, a mapping from String values to
* various types that can be saved to persistent and later restored.
*/
-class PersistableBundle : public Parcelable {
+class LIBBINDER_EXPORTED PersistableBundle : public Parcelable {
public:
PersistableBundle() = default;
virtual ~PersistableBundle() = default;
diff --git a/libs/binder/include/binder/ProcessState.h b/libs/binder/include/binder/ProcessState.h
index 3672702..a466638 100644
--- a/libs/binder/include/binder/ProcessState.h
+++ b/libs/binder/include/binder/ProcessState.h
@@ -16,6 +16,7 @@
#pragma once
+#include <binder/Common.h>
#include <binder/IBinder.h>
#include <utils/String16.h>
#include <utils/String8.h>
@@ -35,10 +36,10 @@
*/
class ProcessState : public virtual RefBase {
public:
- static sp<ProcessState> self();
- static sp<ProcessState> selfOrNull();
+ LIBBINDER_EXPORTED static sp<ProcessState> self();
+ LIBBINDER_EXPORTED static sp<ProcessState> selfOrNull();
- static bool isVndservicemanagerEnabled();
+ LIBBINDER_EXPORTED static bool isVndservicemanagerEnabled();
/* initWithDriver() can be used to configure libbinder to use
* a different binder driver dev node. It must be called *before*
@@ -48,9 +49,9 @@
*
* If this is called with nullptr, the behavior is the same as selfOrNull.
*/
- static sp<ProcessState> initWithDriver(const char* driver);
+ LIBBINDER_EXPORTED static sp<ProcessState> initWithDriver(const char* driver);
- sp<IBinder> getContextObject(const sp<IBinder>& caller);
+ LIBBINDER_EXPORTED sp<IBinder> getContextObject(const sp<IBinder>& caller);
// This should be called before startThreadPool at the beginning
// of a program, and libraries should never call it because programs
@@ -60,7 +61,7 @@
// The 'maxThreads' value refers to the total number of threads
// that will be started by the kernel. This is in addition to any
// threads started by 'startThreadPool' or 'joinRpcThreadpool'.
- status_t setThreadPoolMaxThreadCount(size_t maxThreads);
+ LIBBINDER_EXPORTED status_t setThreadPoolMaxThreadCount(size_t maxThreads);
// Libraries should not call this, as processes should configure
// threadpools themselves. Should be called in the main function
@@ -72,27 +73,27 @@
// For instance, if setThreadPoolMaxCount(3) is called and
// startThreadpPool (+1 thread) and joinThreadPool (+1 thread)
// are all called, then up to 5 threads can be started.
- void startThreadPool();
+ LIBBINDER_EXPORTED void startThreadPool();
- [[nodiscard]] bool becomeContextManager();
+ [[nodiscard]] LIBBINDER_EXPORTED bool becomeContextManager();
- sp<IBinder> getStrongProxyForHandle(int32_t handle);
- void expungeHandle(int32_t handle, IBinder* binder);
+ LIBBINDER_EXPORTED sp<IBinder> getStrongProxyForHandle(int32_t handle);
+ LIBBINDER_EXPORTED void expungeHandle(int32_t handle, IBinder* binder);
// TODO: deprecate.
- void spawnPooledThread(bool isMain);
+ LIBBINDER_EXPORTED void spawnPooledThread(bool isMain);
- status_t enableOnewaySpamDetection(bool enable);
+ LIBBINDER_EXPORTED status_t enableOnewaySpamDetection(bool enable);
// Set the name of the current thread to look like a threadpool
// thread. Typically this is called before joinThreadPool.
//
// TODO: remove this API, and automatically set it intelligently.
- void giveThreadPoolName();
+ LIBBINDER_EXPORTED void giveThreadPoolName();
- String8 getDriverName();
+ LIBBINDER_EXPORTED String8 getDriverName();
- ssize_t getKernelReferences(size_t count, uintptr_t* buf);
+ LIBBINDER_EXPORTED ssize_t getKernelReferences(size_t count, uintptr_t* buf);
// Only usable by the context manager.
// This refcount includes:
@@ -100,7 +101,7 @@
// 2. Temporary strong references held by the kernel during a
// transaction on the node.
// It does NOT include local strong references to the node
- ssize_t getStrongRefCountForNode(const sp<BpBinder>& binder);
+ LIBBINDER_EXPORTED ssize_t getStrongRefCountForNode(const sp<BpBinder>& binder);
enum class CallRestriction {
// all calls okay
@@ -112,26 +113,26 @@
};
// Sets calling restrictions for all transactions in this process. This must be called
// before any threads are spawned.
- void setCallRestriction(CallRestriction restriction);
+ LIBBINDER_EXPORTED void setCallRestriction(CallRestriction restriction);
/**
* Get the max number of threads that have joined the thread pool.
* This includes kernel started threads, user joined threads and polling
* threads if used.
*/
- size_t getThreadPoolMaxTotalThreadCount() const;
+ LIBBINDER_EXPORTED size_t getThreadPoolMaxTotalThreadCount() const;
/**
* Check to see if the thread pool has started.
*/
- bool isThreadPoolStarted() const;
+ LIBBINDER_EXPORTED bool isThreadPoolStarted() const;
enum class DriverFeature {
ONEWAY_SPAM_DETECTION,
EXTENDED_ERROR,
};
// Determine whether a feature is supported by the binder driver.
- static bool isDriverFeatureEnabled(const DriverFeature feature);
+ LIBBINDER_EXPORTED static bool isDriverFeatureEnabled(const DriverFeature feature);
private:
static sp<ProcessState> init(const char* defaultDriver, bool requireDefault);
diff --git a/libs/binder/include/binder/RecordedTransaction.h b/libs/binder/include/binder/RecordedTransaction.h
index f0bee7f..ed75e43 100644
--- a/libs/binder/include/binder/RecordedTransaction.h
+++ b/libs/binder/include/binder/RecordedTransaction.h
@@ -16,6 +16,7 @@
#pragma once
+#include <binder/Common.h>
#include <binder/Parcel.h>
#include <binder/unique_fd.h>
#include <mutex>
@@ -32,25 +33,25 @@
public:
// Filled with the first transaction from fd.
- static std::optional<RecordedTransaction> fromFile(const binder::unique_fd& fd);
+ LIBBINDER_EXPORTED static std::optional<RecordedTransaction> fromFile(
+ const binder::unique_fd& fd);
// Filled with the arguments.
- static std::optional<RecordedTransaction> fromDetails(const String16& interfaceName,
- uint32_t code, uint32_t flags,
- timespec timestamp, const Parcel& data,
- const Parcel& reply, status_t err);
- RecordedTransaction(RecordedTransaction&& t) noexcept;
+ LIBBINDER_EXPORTED static std::optional<RecordedTransaction> fromDetails(
+ const String16& interfaceName, uint32_t code, uint32_t flags, timespec timestamp,
+ const Parcel& data, const Parcel& reply, status_t err);
+ LIBBINDER_EXPORTED RecordedTransaction(RecordedTransaction&& t) noexcept;
- [[nodiscard]] status_t dumpToFile(const binder::unique_fd& fd) const;
+ [[nodiscard]] LIBBINDER_EXPORTED status_t dumpToFile(const binder::unique_fd& fd) const;
- const std::string& getInterfaceName() const;
- uint32_t getCode() const;
- uint32_t getFlags() const;
- int32_t getReturnedStatus() const;
- timespec getTimestamp() const;
- uint32_t getVersion() const;
- const Parcel& getDataParcel() const;
- const Parcel& getReplyParcel() const;
- const std::vector<uint64_t>& getObjectOffsets() const;
+ LIBBINDER_EXPORTED const std::string& getInterfaceName() const;
+ LIBBINDER_EXPORTED uint32_t getCode() const;
+ LIBBINDER_EXPORTED uint32_t getFlags() const;
+ LIBBINDER_EXPORTED int32_t getReturnedStatus() const;
+ LIBBINDER_EXPORTED timespec getTimestamp() const;
+ LIBBINDER_EXPORTED uint32_t getVersion() const;
+ LIBBINDER_EXPORTED const Parcel& getDataParcel() const;
+ LIBBINDER_EXPORTED const Parcel& getReplyParcel() const;
+ LIBBINDER_EXPORTED const std::vector<uint64_t>& getObjectOffsets() const;
private:
RecordedTransaction() = default;
diff --git a/libs/binder/include/binder/RpcServer.h b/libs/binder/include/binder/RpcServer.h
index a07880d..abea0fb 100644
--- a/libs/binder/include/binder/RpcServer.h
+++ b/libs/binder/include/binder/RpcServer.h
@@ -15,6 +15,7 @@
*/
#pragma once
+#include <binder/Common.h>
#include <binder/IBinder.h>
#include <binder/RpcSession.h>
#include <binder/RpcThreads.h>
@@ -47,7 +48,7 @@
*/
class RpcServer final : public virtual RefBase, private RpcSession::EventListener {
public:
- static sp<RpcServer> make(
+ LIBBINDER_EXPORTED static sp<RpcServer> make(
std::unique_ptr<RpcTransportCtxFactory> rpcTransportCtxFactory = nullptr);
/**
@@ -59,7 +60,8 @@
* to RpcSession::setupUnixDomainSocketBootstrapClient. Multiple client
* session can be created from the client end of the pair.
*/
- [[nodiscard]] status_t setupUnixDomainSocketBootstrapServer(binder::unique_fd serverFd);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t
+ setupUnixDomainSocketBootstrapServer(binder::unique_fd serverFd);
/**
* This represents a session for responses, e.g.:
@@ -69,7 +71,7 @@
* process B makes binder b and sends it to A
* A uses this 'back session' to send things back to B
*/
- [[nodiscard]] status_t setupUnixDomainServer(const char* path);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t setupUnixDomainServer(const char* path);
/**
* Sets up an RPC server with a raw socket file descriptor.
@@ -79,12 +81,13 @@
* This method is used in the libbinder_rpc_unstable API
* RunInitUnixDomainRpcServer().
*/
- [[nodiscard]] status_t setupRawSocketServer(binder::unique_fd socket_fd);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t setupRawSocketServer(binder::unique_fd socket_fd);
/**
* Creates an RPC server binding to the given CID at the given port.
*/
- [[nodiscard]] status_t setupVsockServer(unsigned int bindCid, unsigned int port);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t setupVsockServer(unsigned int bindCid,
+ unsigned int port);
/**
* Creates an RPC server at the current port using IPv4.
@@ -100,24 +103,25 @@
* "0.0.0.0" allows for connections on any IP address that the device may
* have
*/
- [[nodiscard]] status_t setupInetServer(const char* address, unsigned int port,
- unsigned int* assignedPort = nullptr);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t setupInetServer(const char* address,
+ unsigned int port,
+ unsigned int* assignedPort = nullptr);
/**
* If setup*Server has been successful, return true. Otherwise return false.
*/
- [[nodiscard]] bool hasServer();
+ [[nodiscard]] LIBBINDER_EXPORTED bool hasServer();
/**
* If hasServer(), return the server FD. Otherwise return invalid FD.
*/
- [[nodiscard]] binder::unique_fd releaseServer();
+ [[nodiscard]] LIBBINDER_EXPORTED binder::unique_fd releaseServer();
/**
* Set up server using an external FD previously set up by releaseServer().
* Return false if there's already a server.
*/
- [[nodiscard]] status_t setupExternalServer(binder::unique_fd serverFd);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t setupExternalServer(binder::unique_fd serverFd);
/**
* This must be called before adding a client session. This corresponds
@@ -130,15 +134,15 @@
* TODO(b/167966510): these are currently created per client, but these
* should be shared.
*/
- void setMaxThreads(size_t threads);
- size_t getMaxThreads();
+ LIBBINDER_EXPORTED void setMaxThreads(size_t threads);
+ LIBBINDER_EXPORTED size_t getMaxThreads();
/**
* By default, the latest protocol version which is supported by a client is
* used. However, this can be used in order to prevent newer protocol
* versions from ever being used. This is expected to be useful for testing.
*/
- [[nodiscard]] bool setProtocolVersion(uint32_t version);
+ [[nodiscard]] LIBBINDER_EXPORTED bool setProtocolVersion(uint32_t version);
/**
* Set the supported transports for sending and receiving file descriptors.
@@ -146,7 +150,7 @@
* Clients will propose a mode when connecting. If the mode is not in the
* provided list, the connection will be rejected.
*/
- void setSupportedFileDescriptorTransportModes(
+ LIBBINDER_EXPORTED void setSupportedFileDescriptorTransportModes(
const std::vector<RpcSession::FileDescriptorTransportMode>& modes);
/**
@@ -155,11 +159,11 @@
*
* Holds a strong reference to the root object.
*/
- void setRootObject(const sp<IBinder>& binder);
+ LIBBINDER_EXPORTED void setRootObject(const sp<IBinder>& binder);
/**
* Holds a weak reference to the root object.
*/
- void setRootObjectWeak(const wp<IBinder>& binder);
+ LIBBINDER_EXPORTED void setRootObjectWeak(const wp<IBinder>& binder);
/**
* Allows a root object to be created for each session.
*
@@ -174,9 +178,9 @@
* validate the size, then cast the type-erased pointer to a pointer to the actual type of the
* address, e.g., const void* to const sockaddr_vm*.
*/
- void setPerSessionRootObject(
+ LIBBINDER_EXPORTED void setPerSessionRootObject(
std::function<sp<IBinder>(wp<RpcSession> session, const void*, size_t)>&& object);
- sp<IBinder> getRootObject();
+ LIBBINDER_EXPORTED sp<IBinder> getRootObject();
/**
* Set optional filter of incoming connections based on the peer's address.
@@ -186,24 +190,25 @@
* See the description of setPerSessionRootObject() for details about
* the callable's arguments.
*/
- void setConnectionFilter(std::function<bool(const void*, size_t)>&& filter);
+ LIBBINDER_EXPORTED void setConnectionFilter(std::function<bool(const void*, size_t)>&& filter);
/**
* Set optional modifier of each newly created server socket.
*
* The only argument is a successfully created file descriptor, not bound to an address yet.
*/
- void setServerSocketModifier(std::function<void(binder::borrowed_fd)>&& modifier);
+ LIBBINDER_EXPORTED void setServerSocketModifier(
+ std::function<void(binder::borrowed_fd)>&& modifier);
/**
* See RpcTransportCtx::getCertificate
*/
- std::vector<uint8_t> getCertificate(RpcCertificateFormat);
+ LIBBINDER_EXPORTED std::vector<uint8_t> getCertificate(RpcCertificateFormat);
/**
* Runs join() in a background thread. Immediately returns.
*/
- void start();
+ LIBBINDER_EXPORTED void start();
/**
* You must have at least one client session before calling this.
@@ -216,7 +221,7 @@
* still occurring. To ensure that the service is fully shutdown, you might
* want to call shutdown after 'join' returns.
*/
- void join();
+ LIBBINDER_EXPORTED void join();
/**
* Shut down any existing join(). Return true if successfully shut down, false otherwise
@@ -225,20 +230,20 @@
*
* Warning: this will hang if it is called from its own thread.
*/
- [[nodiscard]] bool shutdown();
+ [[nodiscard]] LIBBINDER_EXPORTED bool shutdown();
/**
* For debugging!
*/
- std::vector<sp<RpcSession>> listSessions();
- size_t numUninitializedSessions();
+ LIBBINDER_EXPORTED std::vector<sp<RpcSession>> listSessions();
+ LIBBINDER_EXPORTED size_t numUninitializedSessions();
/**
* Whether any requests are currently being processed.
*/
- bool hasActiveRequests();
+ LIBBINDER_EXPORTED bool hasActiveRequests();
- ~RpcServer();
+ LIBBINDER_EXPORTED ~RpcServer();
private:
friend RpcServerTrusty;
diff --git a/libs/binder/include/binder/RpcSession.h b/libs/binder/include/binder/RpcSession.h
index 11fbde9..e8d9829 100644
--- a/libs/binder/include/binder/RpcSession.h
+++ b/libs/binder/include/binder/RpcSession.h
@@ -15,6 +15,7 @@
*/
#pragma once
+#include <binder/Common.h>
#include <binder/IBinder.h>
#include <binder/RpcThreads.h>
#include <binder/RpcTransport.h>
@@ -57,12 +58,13 @@
class RpcSession final : public virtual RefBase {
public:
// Create an RpcSession with default configuration (raw sockets).
- static sp<RpcSession> make();
+ LIBBINDER_EXPORTED static sp<RpcSession> make();
// Create an RpcSession with the given configuration. |serverRpcCertificateFormat| and
// |serverCertificate| must have values or be nullopt simultaneously. If they have values, set
// server certificate.
- static sp<RpcSession> make(std::unique_ptr<RpcTransportCtxFactory> rpcTransportCtxFactory);
+ LIBBINDER_EXPORTED static sp<RpcSession> make(
+ std::unique_ptr<RpcTransportCtxFactory> rpcTransportCtxFactory);
/**
* Set the maximum number of incoming threads allowed to be made (for things like callbacks).
@@ -75,8 +77,8 @@
*
* TODO(b/189955605): start these lazily - currently all are started
*/
- void setMaxIncomingThreads(size_t threads);
- size_t getMaxIncomingThreads();
+ LIBBINDER_EXPORTED void setMaxIncomingThreads(size_t threads);
+ LIBBINDER_EXPORTED size_t getMaxIncomingThreads();
/**
* Set the maximum number of outgoing connections allowed to be made.
@@ -90,15 +92,15 @@
* created. This API is used to limit the amount of resources a server can request you
* create.
*/
- void setMaxOutgoingConnections(size_t connections);
- size_t getMaxOutgoingThreads();
+ LIBBINDER_EXPORTED void setMaxOutgoingConnections(size_t connections);
+ LIBBINDER_EXPORTED size_t getMaxOutgoingThreads();
/**
* By default, the minimum of the supported versions of the client and the
* server will be used. Usually, this API should only be used for debugging.
*/
- [[nodiscard]] bool setProtocolVersion(uint32_t version);
- std::optional<uint32_t> getProtocolVersion();
+ [[nodiscard]] LIBBINDER_EXPORTED bool setProtocolVersion(uint32_t version);
+ LIBBINDER_EXPORTED std::optional<uint32_t> getProtocolVersion();
enum class FileDescriptorTransportMode : uint8_t {
NONE = 0,
@@ -111,29 +113,30 @@
/**
* Set the transport for sending and receiving file descriptors.
*/
- void setFileDescriptorTransportMode(FileDescriptorTransportMode mode);
- FileDescriptorTransportMode getFileDescriptorTransportMode();
+ LIBBINDER_EXPORTED void setFileDescriptorTransportMode(FileDescriptorTransportMode mode);
+ LIBBINDER_EXPORTED FileDescriptorTransportMode getFileDescriptorTransportMode();
/**
* This should be called once per thread, matching 'join' in the remote
* process.
*/
- [[nodiscard]] status_t setupUnixDomainClient(const char* path);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t setupUnixDomainClient(const char* path);
/**
* Connects to an RPC server over a nameless Unix domain socket pair.
*/
- [[nodiscard]] status_t setupUnixDomainSocketBootstrapClient(binder::unique_fd bootstrap);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t
+ setupUnixDomainSocketBootstrapClient(binder::unique_fd bootstrap);
/**
* Connects to an RPC server at the CVD & port.
*/
- [[nodiscard]] status_t setupVsockClient(unsigned int cvd, unsigned int port);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t setupVsockClient(unsigned int cvd, unsigned int port);
/**
* Connects to an RPC server at the given address and port.
*/
- [[nodiscard]] status_t setupInetClient(const char* addr, unsigned int port);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t setupInetClient(const char* addr, unsigned int port);
/**
* Starts talking to an RPC server which has already been connected to. This
@@ -145,8 +148,8 @@
*
* For future compatibility, 'request' should not reference any stack data.
*/
- [[nodiscard]] status_t setupPreconnectedClient(binder::unique_fd fd,
- std::function<binder::unique_fd()>&& request);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t
+ setupPreconnectedClient(binder::unique_fd fd, std::function<binder::unique_fd()>&& request);
/**
* For debugging!
@@ -155,24 +158,24 @@
* response will never be satisfied. All data sent here will be
* unceremoniously cast down the bottomless pit, /dev/null.
*/
- [[nodiscard]] status_t addNullDebuggingClient();
+ [[nodiscard]] LIBBINDER_EXPORTED status_t addNullDebuggingClient();
/**
* Query the other side of the session for the root object hosted by that
* process's RpcServer (if one exists)
*/
- sp<IBinder> getRootObject();
+ LIBBINDER_EXPORTED sp<IBinder> getRootObject();
/**
* Query the other side of the session for the maximum number of threads
* it supports (maximum number of concurrent non-nested synchronous transactions)
*/
- [[nodiscard]] status_t getRemoteMaxThreads(size_t* maxThreads);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t getRemoteMaxThreads(size_t* maxThreads);
/**
* See RpcTransportCtx::getCertificate
*/
- std::vector<uint8_t> getCertificate(RpcCertificateFormat);
+ LIBBINDER_EXPORTED std::vector<uint8_t> getCertificate(RpcCertificateFormat);
/**
* Shuts down the service.
@@ -188,33 +191,34 @@
* complete before returning. This will hang if it is called from the
* session threadpool (when processing received calls).
*/
- [[nodiscard]] bool shutdownAndWait(bool wait);
+ [[nodiscard]] LIBBINDER_EXPORTED bool shutdownAndWait(bool wait);
- [[nodiscard]] status_t transact(const sp<IBinder>& binder, uint32_t code, const Parcel& data,
- Parcel* reply, uint32_t flags);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t transact(const sp<IBinder>& binder, uint32_t code,
+ const Parcel& data, Parcel* reply,
+ uint32_t flags);
/**
* Generally, you should not call this, unless you are testing error
* conditions, as this is called automatically by BpBinders when they are
* deleted (this is also why a raw pointer is used here)
*/
- [[nodiscard]] status_t sendDecStrong(const BpBinder* binder);
+ [[nodiscard]] LIBBINDER_EXPORTED status_t sendDecStrong(const BpBinder* binder);
/**
* Whether any requests are currently being processed.
*/
- bool hasActiveRequests();
+ LIBBINDER_EXPORTED bool hasActiveRequests();
- ~RpcSession();
+ LIBBINDER_EXPORTED ~RpcSession();
/**
* Server if this session is created as part of a server (symmetrical to
* client servers). Otherwise, nullptr.
*/
- sp<RpcServer> server();
+ LIBBINDER_EXPORTED sp<RpcServer> server();
// internal only
- const std::unique_ptr<RpcState>& state() { return mRpcBinderState; }
+ LIBBINDER_EXPORTED const std::unique_ptr<RpcState>& state() { return mRpcBinderState; }
private:
friend sp<RpcSession>;
diff --git a/libs/binder/include/binder/RpcThreads.h b/libs/binder/include/binder/RpcThreads.h
index d25f292..99fa6b8 100644
--- a/libs/binder/include/binder/RpcThreads.h
+++ b/libs/binder/include/binder/RpcThreads.h
@@ -22,27 +22,29 @@
#include <memory>
#include <thread>
+#include <binder/Common.h>
+
namespace android {
#ifdef BINDER_RPC_SINGLE_THREADED
-class RpcMutex {
+class LIBBINDER_EXPORTED RpcMutex {
public:
void lock() {}
void unlock() {}
};
-class RpcMutexUniqueLock {
+class LIBBINDER_EXPORTED RpcMutexUniqueLock {
public:
RpcMutexUniqueLock(RpcMutex&) {}
void unlock() {}
};
-class RpcMutexLockGuard {
+class LIBBINDER_EXPORTED RpcMutexLockGuard {
public:
RpcMutexLockGuard(RpcMutex&) {}
};
-class RpcConditionVariable {
+class LIBBINDER_EXPORTED RpcConditionVariable {
public:
void notify_one() {}
void notify_all() {}
@@ -65,7 +67,7 @@
}
};
-class RpcMaybeThread {
+class LIBBINDER_EXPORTED RpcMaybeThread {
public:
RpcMaybeThread() = default;
diff --git a/libs/binder/include/binder/RpcTransport.h b/libs/binder/include/binder/RpcTransport.h
index a50cdc1..843c4bf 100644
--- a/libs/binder/include/binder/RpcTransport.h
+++ b/libs/binder/include/binder/RpcTransport.h
@@ -27,6 +27,7 @@
#include <utils/Errors.h>
+#include <binder/Common.h>
#include <binder/Functional.h>
#include <binder/RpcCertificateFormat.h>
#include <binder/RpcThreads.h>
@@ -51,7 +52,7 @@
// Represents a socket connection.
// No thread-safety is guaranteed for these APIs.
-class RpcTransport {
+class LIBBINDER_EXPORTED RpcTransport {
public:
virtual ~RpcTransport() = default;
@@ -123,7 +124,7 @@
// Represents the context that generates the socket connection.
// All APIs are thread-safe. See RpcTransportCtxRaw and RpcTransportCtxTls for details.
-class RpcTransportCtx {
+class LIBBINDER_EXPORTED RpcTransportCtx {
public:
virtual ~RpcTransportCtx() = default;
@@ -154,7 +155,7 @@
// A factory class that generates RpcTransportCtx.
// All APIs are thread-safe.
-class RpcTransportCtxFactory {
+class LIBBINDER_EXPORTED RpcTransportCtxFactory {
public:
virtual ~RpcTransportCtxFactory() = default;
// Creates server context.
@@ -171,7 +172,7 @@
RpcTransportCtxFactory() = default;
};
-struct RpcTransportFd final {
+struct LIBBINDER_EXPORTED RpcTransportFd final {
private:
mutable bool isPolling{false};
diff --git a/libs/binder/include/binder/RpcTransportRaw.h b/libs/binder/include/binder/RpcTransportRaw.h
index 6fb1f92..bfa73ea 100644
--- a/libs/binder/include/binder/RpcTransportRaw.h
+++ b/libs/binder/include/binder/RpcTransportRaw.h
@@ -21,6 +21,7 @@
#include <memory>
+#include <binder/Common.h>
#include <binder/RpcTransport.h>
namespace android {
@@ -28,11 +29,11 @@
// RpcTransportCtxFactory with TLS disabled.
class RpcTransportCtxFactoryRaw : public RpcTransportCtxFactory {
public:
- static std::unique_ptr<RpcTransportCtxFactory> make();
+ LIBBINDER_EXPORTED static std::unique_ptr<RpcTransportCtxFactory> make();
- std::unique_ptr<RpcTransportCtx> newServerCtx() const override;
- std::unique_ptr<RpcTransportCtx> newClientCtx() const override;
- const char* toCString() const override;
+ LIBBINDER_EXPORTED std::unique_ptr<RpcTransportCtx> newServerCtx() const override;
+ LIBBINDER_EXPORTED std::unique_ptr<RpcTransportCtx> newClientCtx() const override;
+ LIBBINDER_EXPORTED const char* toCString() const override;
private:
RpcTransportCtxFactoryRaw() = default;
diff --git a/libs/binder/include/binder/SafeInterface.h b/libs/binder/include/binder/SafeInterface.h
index 96b9733..c671eed 100644
--- a/libs/binder/include/binder/SafeInterface.h
+++ b/libs/binder/include/binder/SafeInterface.h
@@ -16,6 +16,7 @@
#pragma once
+#include <binder/Common.h>
#include <binder/IInterface.h>
#include <binder/Parcel.h>
@@ -34,7 +35,7 @@
namespace SafeInterface {
// ParcelHandler is responsible for writing/reading various types to/from a Parcel in a generic way
-class ParcelHandler {
+class LIBBINDER_EXPORTED ParcelHandler {
public:
explicit ParcelHandler(const char* logTag) : mLogTag(logTag) {}
@@ -243,7 +244,7 @@
} // namespace SafeInterface
template <typename Interface>
-class SafeBpInterface : public BpInterface<Interface> {
+class LIBBINDER_EXPORTED SafeBpInterface : public BpInterface<Interface> {
protected:
SafeBpInterface(const sp<IBinder>& impl, const char* logTag)
: BpInterface<Interface>(impl), mLogTag(logTag) {}
@@ -438,7 +439,7 @@
};
template <typename Interface>
-class SafeBnInterface : public BnInterface<Interface> {
+class LIBBINDER_EXPORTED SafeBnInterface : public BnInterface<Interface> {
public:
explicit SafeBnInterface(const char* logTag) : mLogTag(logTag) {}
diff --git a/libs/binder/include/binder/Stability.h b/libs/binder/include/binder/Stability.h
index ce4362f..cafb8aa 100644
--- a/libs/binder/include/binder/Stability.h
+++ b/libs/binder/include/binder/Stability.h
@@ -16,6 +16,7 @@
#pragma once
+#include <binder/Common.h>
#include <binder/IBinder.h>
#include <string>
@@ -54,7 +55,7 @@
// requirements associated with that higher stability level. For instance, a
// VINTF stability binder is required to be in the VINTF manifest. This API
// can be called to use that same interface within the local partition.
- static void forceDowngradeToLocalStability(const sp<IBinder>& binder);
+ LIBBINDER_EXPORTED static void forceDowngradeToLocalStability(const sp<IBinder>& binder);
// WARNING: Below APIs are only ever expected to be called by auto-generated code.
// Instead of calling them, you should set the stability of a .aidl interface
@@ -76,30 +77,30 @@
// requirements associated with that higher stability level. For instance, a
// VINTF stability binder is required to be in the VINTF manifest. This API
// can be called to use that same interface within the vendor partition.
- static void forceDowngradeToVendorStability(const sp<IBinder>& binder);
+ LIBBINDER_EXPORTED static void forceDowngradeToVendorStability(const sp<IBinder>& binder);
// Given a binder interface at a certain stability, there may be some
// requirements associated with that higher stability level. For instance, a
// VINTF stability binder is required to be in the VINTF manifest. This API
// can be called to use that same interface within the system partition.
- static void forceDowngradeToSystemStability(const sp<IBinder>& binder);
+ LIBBINDER_EXPORTED static void forceDowngradeToSystemStability(const sp<IBinder>& binder);
// WARNING: This is only ever expected to be called by auto-generated code. You likely want to
// change or modify the stability class of the interface you are using.
// This must be called as soon as the binder in question is constructed. No thread safety
// is provided.
// E.g. stability is according to libbinder compilation unit
- static void markCompilationUnit(IBinder* binder);
+ LIBBINDER_EXPORTED static void markCompilationUnit(IBinder* binder);
// WARNING: This is only ever expected to be called by auto-generated code. You likely want to
// change or modify the stability class of the interface you are using.
// This must be called as soon as the binder in question is constructed. No thread safety
// is provided.
// E.g. stability is according to libbinder_ndk or Java SDK AND the interface
// expressed here is guaranteed to be stable for multiple years (Stable AIDL)
- static void markVintf(IBinder* binder);
+ LIBBINDER_EXPORTED static void markVintf(IBinder* binder);
// WARNING: for debugging only
- static std::string debugToString(const sp<IBinder>& binder);
+ LIBBINDER_EXPORTED static std::string debugToString(const sp<IBinder>& binder);
// WARNING: This is only ever expected to be called by auto-generated code or tests.
// You likely want to change or modify the stability of the interface you are using.
@@ -109,11 +110,12 @@
// expressed here is guaranteed to be stable for multiple years (Stable AIDL)
// If this is called when __ANDROID_VNDK__ is not defined, then it is UB and will likely
// break the device during GSI or other tests.
- static void markVndk(IBinder* binder);
+ LIBBINDER_EXPORTED static void markVndk(IBinder* binder);
// Returns true if the binder needs to be declared in the VINTF manifest or
// else false if the binder is local to the current partition.
- static bool requiresVintfDeclaration(const sp<IBinder>& binder);
+ LIBBINDER_EXPORTED static bool requiresVintfDeclaration(const sp<IBinder>& binder);
+
private:
// Parcel needs to read/write stability level in an unstable format.
friend ::android::Parcel;
diff --git a/libs/binder/include/binder/Status.h b/libs/binder/include/binder/Status.h
index af34695..49ccf7c 100644
--- a/libs/binder/include/binder/Status.h
+++ b/libs/binder/include/binder/Status.h
@@ -21,6 +21,7 @@
#include <sstream> // historical
#include <ostream>
+#include <binder/Common.h>
#include <binder/Parcel.h>
#include <utils/String8.h>
#include <string>
@@ -51,7 +52,7 @@
// // exception during handling.
// }
//
-class Status final {
+class LIBBINDER_EXPORTED Status final {
public:
// Keep the exception codes in sync with android/os/Parcel.java.
enum Exception {
diff --git a/libs/binder/include/binder/TextOutput.h b/libs/binder/include/binder/TextOutput.h
index 50158c3..0527eeb 100644
--- a/libs/binder/include/binder/TextOutput.h
+++ b/libs/binder/include/binder/TextOutput.h
@@ -16,6 +16,7 @@
#pragma once
+#include <binder/Common.h>
#include <utils/Errors.h>
#include <utils/String8.h>
@@ -26,8 +27,7 @@
// ---------------------------------------------------------------------------
namespace android {
-class TextOutput
-{
+class LIBBINDER_EXPORTED TextOutput {
public:
TextOutput();
virtual ~TextOutput();
@@ -52,17 +52,17 @@
// DO NOT USE: prefer libutils/libbase logs, which don't require static data to
// be allocated.
// Text output stream for printing to the log (via utils/Log.h).
-extern TextOutput& alog;
+extern LIBBINDER_EXPORTED TextOutput& alog;
// DO NOT USE: prefer libutils/libbase logs, which don't require static data to
// be allocated.
// Text output stream for printing to stdout.
-extern TextOutput& aout;
+extern LIBBINDER_EXPORTED TextOutput& aout;
// DO NOT USE: prefer libutils/libbase logs, which don't require static data to
// be allocated.
// Text output stream for printing to stderr.
-extern TextOutput& aerr;
+extern LIBBINDER_EXPORTED TextOutput& aerr;
typedef TextOutput& (*TextOutputManipFunc)(TextOutput&);
@@ -80,10 +80,9 @@
return to;
}
-TextOutput& operator<<(TextOutput& to, TextOutputManipFunc func);
+LIBBINDER_EXPORTED TextOutput& operator<<(TextOutput& to, TextOutputManipFunc func);
-class TypeCode
-{
+class LIBBINDER_EXPORTED TypeCode {
public:
inline explicit TypeCode(uint32_t code);
inline ~TypeCode();
@@ -94,10 +93,9 @@
uint32_t mCode;
};
-std::ostream& operator<<(std::ostream& to, const TypeCode& val);
+LIBBINDER_EXPORTED std::ostream& operator<<(std::ostream& to, const TypeCode& val);
-class HexDump
-{
+class LIBBINDER_EXPORTED HexDump {
public:
HexDump(const void *buf, size_t size, size_t bytesPerLine=16);
inline ~HexDump();
@@ -123,7 +121,7 @@
bool mCArrayStyle;
};
-std::ostream& operator<<(std::ostream& to, const HexDump& val);
+LIBBINDER_EXPORTED std::ostream& operator<<(std::ostream& to, const HexDump& val);
inline TextOutput& operator<<(TextOutput& to,
decltype(std::endl<char,
std::char_traits<char>>)
diff --git a/libs/binder/include/binder/Trace.h b/libs/binder/include/binder/Trace.h
index 95318b2..268157e 100644
--- a/libs/binder/include/binder/Trace.h
+++ b/libs/binder/include/binder/Trace.h
@@ -22,6 +22,8 @@
#include <cutils/trace.h>
#endif
+#include <binder/Common.h>
+
#ifdef ATRACE_TAG_AIDL
#if ATRACE_TAG_AIDL != (1 << 24)
#error "Mismatched ATRACE_TAG_AIDL definitions"
@@ -41,7 +43,7 @@
void trace_end(uint64_t tag);
} // namespace os
-class ScopedTrace {
+class LIBBINDER_EXPORTED ScopedTrace {
public:
inline ScopedTrace(uint64_t tag, const char* name) : mTag(tag) { os::trace_begin(mTag, name); }
diff --git a/libs/binder/include/binder/unique_fd.h b/libs/binder/include/binder/unique_fd.h
index 439b8a2..3de4149 100644
--- a/libs/binder/include/binder/unique_fd.h
+++ b/libs/binder/include/binder/unique_fd.h
@@ -16,6 +16,8 @@
#pragma once
+#include <binder/Common.h>
+
#ifndef BINDER_NO_LIBBASE
#include <android-base/unique_fd.h>
@@ -43,7 +45,7 @@
//
// return 0; // Descriptor is closed for you.
//
-class unique_fd final {
+class LIBBINDER_EXPORTED unique_fd final {
public:
unique_fd() {}
@@ -99,7 +101,7 @@
// If you think of unique_fd as being like std::string in that represents
// ownership, borrowed_fd is like std::string_view (and int is like const
// char*).
-struct borrowed_fd {
+struct LIBBINDER_EXPORTED borrowed_fd {
/* implicit */ borrowed_fd(int fd) : fd_(fd) {} // NOLINT
/* implicit */ borrowed_fd(const unique_fd& ufd) : fd_(ufd.get()) {} // NOLINT
diff --git a/libs/binder/trusty/OS.cpp b/libs/binder/trusty/OS.cpp
index a8dabc3..09db326 100644
--- a/libs/binder/trusty/OS.cpp
+++ b/libs/binder/trusty/OS.cpp
@@ -21,6 +21,7 @@
#include <lib/rand/rand.h>
#endif
+#include <binder/Common.h>
#include <binder/RpcTransportTipcTrusty.h>
#include <log/log.h>
#include <trusty_log.h>
@@ -92,7 +93,8 @@
} // namespace android::binder::os
-int __android_log_print(int prio [[maybe_unused]], const char* tag, const char* fmt, ...) {
+LIBBINDER_EXPORTED int __android_log_print(int prio [[maybe_unused]], const char* tag,
+ const char* fmt, ...) {
#ifdef TRUSTY_USERSPACE
#define trusty_tlog _tlog
#define trusty_vtlog _vtlog
diff --git a/libs/binder/trusty/include/binder/RpcTransportTipcTrusty.h b/libs/binder/trusty/include/binder/RpcTransportTipcTrusty.h
index 8eae8c2..91c6008 100644
--- a/libs/binder/trusty/include/binder/RpcTransportTipcTrusty.h
+++ b/libs/binder/trusty/include/binder/RpcTransportTipcTrusty.h
@@ -26,7 +26,7 @@
namespace android {
// RpcTransportCtxFactory with TLS disabled.
-class RpcTransportCtxFactoryTipcTrusty : public RpcTransportCtxFactory {
+class LIBBINDER_EXPORTED RpcTransportCtxFactoryTipcTrusty : public RpcTransportCtxFactory {
public:
static std::unique_ptr<RpcTransportCtxFactory> make();