?
system/core/include/utils/RefBase.h
// This provides primarily wp<> weak pointer types and RefBase, which work
// together with sp<> from <StrongPointer.h>.
// sp<> (and wp<>) are a type of smart pointer that use a well defined protocol
// to operate. As long as the object they are templated with implements that
// protocol, these smart pointers work. In several places the platform
// instantiates sp<> with non-RefBase objects; the two are not tied to each
// other.
// RefBase is such an implementation and it supports strong pointers, weak
// pointers and some magic features for the binder.
// So, when using RefBase objects, you have the ability to use strong and weak
// pointers through sp<> and wp<>.
// Normally, when the last strong pointer goes away, the object is destroyed,
// i.e. it's destructor is called. HOWEVER, parts of its associated memory is not
// freed until the last weak pointer is released.
// Weak pointers are essentially "safe" pointers. They are always safe to
// access through promote(). They may return nullptr if the object was
// destroyed because it ran out of strong pointers. This makes them good candidates
// for keys in a cache for instance.
// How is this supposed / intended to be used?
// Our recommendation is to use strong references (sp<>) when there is an
// ownership relation. e.g. when an object "owns" another one, use a strong
// ref. And of course use strong refs as arguments of functions (it's extremely
// rare that a function will take a wp<>).
// Typically a newly allocated object will immediately be used to initialize
// a strong pointer, which may then be used to construct or assign to other
// strong and weak pointers.
// Use weak references when there are no ownership relation. e.g. the keys in a
// cache (you cannot use plain pointers because there is no safe way to acquire
// a strong reference from a vanilla pointer).
// This implies that two objects should never (or very rarely) have sp<> on
// each other, because they can't both own each other.
// Do not construct a strong pointer to "this" in an object's constructor.
// The onFirstRef() callback would be made on an incompletely constructed
// object.
frameworks/native/libs/binder/include/binder/IBinder.h
/**
?* Base class and low-level protocol for a remotable object.
?* You can derive from this class to create an object for which other
?* processes can hold references to it. ?Communication between processes
?* (method calls, property get and set) is down through a low-level
?* protocol implemented on top of the transact() API.
?*/
frameworks/native/libs/binder/include/binder/IInterface.h
#define DECLARE_META_INTERFACE(INTERFACE) ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
public: ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? static const ::android::String16 descriptor; ? ? ? ? ? ? ? ? ? ? ? ?\
? ? static ::android::sp<I##INTERFACE> asInterface( ? ? ? ? ? ? ? ? ? ? \
? ? ? ? ? ? const ::android::sp<::android::IBinder>& obj); ? ? ? ? ? ? ?\
? ? virtual const ::android::String16& getInterfaceDescriptor() const; ?\
? ? I##INTERFACE(); ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? virtual ~I##INTERFACE(); ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? static bool setDefaultImpl(std::unique_ptr<I##INTERFACE> impl); ? ? \
? ? static const std::unique_ptr<I##INTERFACE>& getDefaultImpl(); ? ? ? \
private: ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? static std::unique_ptr<I##INTERFACE> default_impl; ? ? ? ? ? ? ? ? ?\
public: ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
#define IMPLEMENT_META_INTERFACE(INTERFACE, NAME) ? ? ? ? ? ? ? ? ? ? ? \
? ? DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(INTERFACE, NAME) ? ?\
#define DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(INTERFACE, NAME)\
? ? const ::android::StaticString16 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? I##INTERFACE##_descriptor_static_str16(__IINTF_CONCAT(u, NAME));\
? ? const ::android::String16 I##INTERFACE::descriptor( ? ? ? ? ? ? ? ? \
? ? ? ? I##INTERFACE##_descriptor_static_str16); ? ? ? ? ? ? ? ? ? ? ? ?\
? ? const ::android::String16& ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? ? ? ? ? I##INTERFACE::getInterfaceDescriptor() const { ? ? ? ? ? ? ?\
? ? ? ? return I##INTERFACE::descriptor; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? } ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ::android::sp<I##INTERFACE> I##INTERFACE::asInterface( ? ? ? ? ? ? ?\
? ? ? ? ? ? const ::android::sp<::android::IBinder>& obj) ? ? ? ? ? ? ? \
? ? { ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? ::android::sp<I##INTERFACE> intr; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? if (obj != nullptr) { ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? ? ? intr = static_cast<I##INTERFACE*>( ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? ? ? ? ? ? ? obj->queryLocalInterface( ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? ? ? ? ? ? ? ? ? I##INTERFACE::descriptor).get()); ? ? ? ? ? ? ? \
? ? ? ? ? ? if (intr == nullptr) { ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? ? ? ? ? ? ? intr = new Bp##INTERFACE(obj); ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? ? ? ? ? } ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? } ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? return intr; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? } ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? std::unique_ptr<I##INTERFACE> I##INTERFACE::default_impl; ? ? ? ? ? \
? ? bool I##INTERFACE::setDefaultImpl(std::unique_ptr<I##INTERFACE> impl)\
? ? { ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? /* Only one user of this interface can use this function ? ? */ \
? ? ? ? /* at a time. This is a heuristic to detect if two different */ \
? ? ? ? /* users in the same process use this function. ? ? ? ? ? ? ?*/ \
? ? ? ? assert(!I##INTERFACE::default_impl); ? ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? ? ? if (impl) { ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? ? ? I##INTERFACE::default_impl = std::move(impl); ? ? ? ? ? ? ? \
? ? ? ? ? ? return true; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? ? ? } ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? return false; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? } ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? const std::unique_ptr<I##INTERFACE>& I##INTERFACE::getDefaultImpl() \
? ? { ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? ? ? return I##INTERFACE::default_impl; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? } ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \
? ? I##INTERFACE::I##INTERFACE() { } ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?\
? ? I##INTERFACE::~I##INTERFACE() { } ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \