path: root/libs/binder/include/binder/SafeInterface.h

/*
 * Copyright 2016 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

#include <binder/IInterface.h>
#include <binder/Parcel.h>
#include <cutils/compiler.h>

// Set to 1 to enable CallStacks when logging errors
#define SI_DUMP_CALLSTACKS 0
#if SI_DUMP_CALLSTACKS
#include <utils/CallStack.h>
#endif

#include <utils/NativeHandle.h>

#include <functional>
#include <type_traits>

namespace android {
namespace SafeInterface {

// ParcelHandler is responsible for writing/reading various types to/from a Parcel in a generic way
class ParcelHandler {
public:
    explicit ParcelHandler(const char* logTag) : mLogTag(logTag) {}

    // Specializations for types with dedicated handling in Parcel
    status_t read(const Parcel& parcel, bool* b) const {
        return callParcel("readBool", [&]() { return parcel.readBool(b); });
    }
    status_t write(Parcel* parcel, bool b) const {
        return callParcel("writeBool", [&]() { return parcel->writeBool(b); });
    }
    template <typename E>
    typename std::enable_if<std::is_enum<E>::value, status_t>::type read(const Parcel& parcel,
                                                                         E* e) const {
        typename std::underlying_type<E>::type u{};
        status_t result = read(parcel, &u);
        *e = static_cast<E>(u);
        return result;
    }
    template <typename E>
    typename std::enable_if<std::is_enum<E>::value, status_t>::type write(Parcel* parcel,
                                                                          E e) const {
        return write(parcel, static_cast<typename std::underlying_type<E>::type>(e));
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<Flattenable<T>, T>::value, status_t>::type read(
            const Parcel& parcel, T* t) const {
        return callParcel("read(Flattenable)", [&]() { return parcel.read(*t); });
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<Flattenable<T>, T>::value, status_t>::type write(
            Parcel* parcel, const T& t) const {
        return callParcel("write(Flattenable)", [&]() { return parcel->write(t); });
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<Flattenable<T>, T>::value, status_t>::type read(
            const Parcel& parcel, sp<T>* t) const {
        *t = new T{};
        return callParcel("read(sp<Flattenable>)", [&]() { return parcel.read(*(t->get())); });
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<Flattenable<T>, T>::value, status_t>::type write(
            Parcel* parcel, const sp<T>& t) const {
        return callParcel("write(sp<Flattenable>)", [&]() { return parcel->write(*(t.get())); });
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<LightFlattenable<T>, T>::value, status_t>::type read(
            const Parcel& parcel, T* t) const {
        return callParcel("read(LightFlattenable)", [&]() { return parcel.read(*t); });
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<LightFlattenable<T>, T>::value, status_t>::type write(
            Parcel* parcel, const T& t) const {
        return callParcel("write(LightFlattenable)", [&]() { return parcel->write(t); });
    }
    template <typename NH>
    typename std::enable_if<std::is_same<NH, sp<NativeHandle>>::value, status_t>::type read(
            const Parcel& parcel, NH* nh) {
        *nh = NativeHandle::create(parcel.readNativeHandle(), true);
        return NO_ERROR;
    }
    template <typename NH>
    typename std::enable_if<std::is_same<NH, sp<NativeHandle>>::value, status_t>::type write(
            Parcel* parcel, const NH& nh) {
        return callParcel("write(sp<NativeHandle>)",
                          [&]() { return parcel->writeNativeHandle(nh->handle()); });
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<Parcelable, T>::value, status_t>::type read(
            const Parcel& parcel, T* t) const {
        return callParcel("readParcelable", [&]() { return parcel.readParcelable(t); });
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<Parcelable, T>::value, status_t>::type write(
            Parcel* parcel, const T& t) const {
        return callParcel("writeParcelable", [&]() { return parcel->writeParcelable(t); });
    }
    status_t read(const Parcel& parcel, String8* str) const {
        return callParcel("readString8", [&]() { return parcel.readString8(str); });
    }
    status_t write(Parcel* parcel, const String8& str) const {
        return callParcel("writeString8", [&]() { return parcel->writeString8(str); });
    }
    template <typename T>
    typename std::enable_if<std::is_same<IBinder, T>::value, status_t>::type read(
            const Parcel& parcel, sp<T>* pointer) const {
        return callParcel("readNullableStrongBinder",
                          [&]() { return parcel.readNullableStrongBinder(pointer); });
    }
    template <typename T>
    typename std::enable_if<std::is_same<IBinder, T>::value, status_t>::type write(
            Parcel* parcel, const sp<T>& pointer) const {
        return callParcel("writeStrongBinder",
                          [&]() { return parcel->writeStrongBinder(pointer); });
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<IInterface, T>::value, status_t>::type read(
            const Parcel& parcel, sp<T>* pointer) const {
        return callParcel("readNullableStrongBinder[IInterface]",
                          [&]() { return parcel.readNullableStrongBinder(pointer); });
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<IInterface, T>::value, status_t>::type write(
            Parcel* parcel, const sp<T>& interface) const {
        return write(parcel, IInterface::asBinder(interface));
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<Parcelable, T>::value, status_t>::type read(
            const Parcel& parcel, std::vector<T>* v) const {
        return callParcel("readParcelableVector", [&]() { return parcel.readParcelableVector(v); });
    }
    template <typename T>
    typename std::enable_if<std::is_base_of<Parcelable, T>::value, status_t>::type write(
            Parcel* parcel, const std::vector<T>& v) const {
        return callParcel("writeParcelableVector",
                          [&]() { return parcel->writeParcelableVector(v); });
    }
    status_t read(const Parcel& parcel, float* f) const {
        return callParcel("readFloat", [&]() { return parcel.readFloat(f); });
    }
    status_t write(Parcel* parcel, float f) const {
        return callParcel("writeFloat", [&]() { return parcel->writeFloat(f); });
    }

    // Templates to handle integral types. We use a struct template to require that the called
    // function exactly matches the signedness and size of the argument (e.g., the argument isn't
    // silently widened).
    template <bool isSigned, size_t size, typename I>
    struct HandleInt;
    template <typename I>
    struct HandleInt<true, 4, I> {
        static status_t read(const ParcelHandler& handler, const Parcel& parcel, I* i) {
            return handler.callParcel("readInt32", [&]() { return parcel.readInt32(i); });
        }
        static status_t write(const ParcelHandler& handler, Parcel* parcel, I i) {
            return handler.callParcel("writeInt32", [&]() { return parcel->writeInt32(i); });
        }
    };
    template <typename I>
    struct HandleInt<false, 4, I> {
        static status_t read(const ParcelHandler& handler, const Parcel& parcel, I* i) {
            return handler.callParcel("readUint32", [&]() { return parcel.readUint32(i); });
        }
        static status_t write(const ParcelHandler& handler, Parcel* parcel, I i) {
            return handler.callParcel("writeUint32", [&]() { return parcel->writeUint32(i); });
        }
    };
    template <typename I>
    struct HandleInt<true, 8, I> {
        static status_t read(const ParcelHandler& handler, const Parcel& parcel, I* i) {
            return handler.callParcel("readInt64", [&]() { return parcel.readInt64(i); });
        }
        static status_t write(const ParcelHandler& handler, Parcel* parcel, I i) {
            return handler.callParcel("writeInt64", [&]() { return parcel->writeInt64(i); });
        }
    };
    template <typename I>
    struct HandleInt<false, 8, I> {
        static status_t read(const ParcelHandler& handler, const Parcel& parcel, I* i) {
            return handler.callParcel("readUint64", [&]() { return parcel.readUint64(i); });
        }
        static status_t write(const ParcelHandler& handler, Parcel* parcel, I i) {
            return handler.callParcel("writeUint64", [&]() { return parcel->writeUint64(i); });
        }
    };
    template <typename I>
    typename std::enable_if<std::is_integral<I>::value, status_t>::type read(const Parcel& parcel,
                                                                             I* i) const {
        return HandleInt<std::is_signed<I>::value, sizeof(I), I>::read(*this, parcel, i);
    }
    template <typename I>
    typename std::enable_if<std::is_integral<I>::value, status_t>::type write(Parcel* parcel,
                                                                              I i) const {
        return HandleInt<std::is_signed<I>::value, sizeof(I), I>::write(*this, parcel, i);
    }

private:
    const char* const mLogTag;

    // Helper to encapsulate error handling while calling the various Parcel methods
    template <typename Function>
    status_t callParcel(const char* name, Function f) const {
        status_t error = f();
        if (CC_UNLIKELY(error != NO_ERROR)) {
            ALOG(LOG_ERROR, mLogTag, "Failed to %s, (%d: %s)", name, error, strerror(-error));
#if SI_DUMP_CALLSTACKS
            CallStack callStack(mLogTag);
#endif
        }
        return error;
    }
};

// Utility struct template which allows us to retrieve the types of the parameters of a member
// function pointer
template <typename T>
struct ParamExtractor;
template <typename Class, typename Return, typename... Params>
struct ParamExtractor<Return (Class::*)(Params...)> {
    using ParamTuple = std::tuple<Params...>;
};
template <typename Class, typename Return, typename... Params>
struct ParamExtractor<Return (Class::*)(Params...) const> {
    using ParamTuple = std::tuple<Params...>;
};

} // namespace SafeInterface

template <typename Interface>
class SafeBpInterface : public BpInterface<Interface> {
protected:
    SafeBpInterface(const sp<IBinder>& impl, const char* logTag)
          : BpInterface<Interface>(impl), mLogTag(logTag) {}
    ~SafeBpInterface() override = default;

    // callRemote is used to invoke a synchronous procedure call over Binder
    template <typename Method, typename TagType, typename... Args>
    status_t callRemote(TagType tag, Args&&... args) const {
        static_assert(sizeof(TagType) <= sizeof(uint32_t), "Tag must fit inside uint32_t");

        // Verify that the arguments are compatible with the parameters
        using ParamTuple = typename SafeInterface::ParamExtractor<Method>::ParamTuple;
        static_assert(ArgsMatchParams<std::tuple<Args...>, ParamTuple>::value,
                      "Invalid argument type");

        // Write the input arguments to the data Parcel
        Parcel data;
        data.writeInterfaceToken(this->getInterfaceDescriptor());

        status_t error = writeInputs(&data, std::forward<Args>(args)...);
        if (CC_UNLIKELY(error != NO_ERROR)) {
            // A message will have been logged by writeInputs
            return error;
        }

        // Send the data Parcel to the remote and retrieve the reply parcel
        Parcel reply;
        error = this->remote()->transact(static_cast<uint32_t>(tag), data, &reply);
        if (CC_UNLIKELY(error != NO_ERROR)) {
            ALOG(LOG_ERROR, mLogTag, "Failed to transact (%d)", error);
#if SI_DUMP_CALLSTACKS
            CallStack callStack(mLogTag);
#endif
            return error;
        }

        // Read the outputs from the reply Parcel into the output arguments
        error = readOutputs(reply, std::forward<Args>(args)...);
        if (CC_UNLIKELY(error != NO_ERROR)) {
            // A message will have been logged by readOutputs
            return error;
        }

        // Retrieve the result code from the reply Parcel
        status_t result = NO_ERROR;
        error = reply.readInt32(&result);
        if (CC_UNLIKELY(error != NO_ERROR)) {
            ALOG(LOG_ERROR, mLogTag, "Failed to obtain result");
#if SI_DUMP_CALLSTACKS
            CallStack callStack(mLogTag);
#endif
            return error;
        }
        return result;
    }

    // callRemoteAsync is used to invoke an asynchronous procedure call over Binder
    template <typename Method, typename TagType, typename... Args>
    void callRemoteAsync(TagType tag, Args&&... args) const {
        static_assert(sizeof(TagType) <= sizeof(uint32_t), "Tag must fit inside uint32_t");

        // Verify that the arguments are compatible with the parameters
        using ParamTuple = typename SafeInterface::ParamExtractor<Method>::ParamTuple;
        static_assert(ArgsMatchParams<std::tuple<Args...>, ParamTuple>::value,
                      "Invalid argument type");

        // Write the input arguments to the data Parcel
        Parcel data;
        data.writeInterfaceToken(this->getInterfaceDescriptor());
        status_t error = writeInputs(&data, std::forward<Args>(args)...);
        if (CC_UNLIKELY(error != NO_ERROR)) {
            // A message will have been logged by writeInputs
            return;
        }

        // There will be no data in the reply Parcel since the call is one-way
        Parcel reply;
        error = this->remote()->transact(static_cast<uint32_t>(tag), data, &reply,
                                         IBinder::FLAG_ONEWAY);
        if (CC_UNLIKELY(error != NO_ERROR)) {
            ALOG(LOG_ERROR, mLogTag, "Failed to transact (%d)", error);
#if SI_DUMP_CALLSTACKS
            CallStack callStack(mLogTag);
#endif
        }
    }

private:
    const char* const mLogTag;

    // This struct provides information on whether the decayed types of the elements at Index in the
    // tuple types T and U (that is, the types after stripping cv-qualifiers, removing references,
    // and a few other less common operations) are the same
    template <size_t Index, typename T, typename U>
    struct DecayedElementsMatch {
    private:
        using FirstT = typename std::tuple_element<Index, T>::type;
        using DecayedT = typename std::decay<FirstT>::type;
        using FirstU = typename std::tuple_element<Index, U>::type;
        using DecayedU = typename std::decay<FirstU>::type;

    public:
        static constexpr bool value = std::is_same<DecayedT, DecayedU>::value;
    };

    // When comparing whether the argument types match the parameter types, we first decay them (see
    // DecayedElementsMatch) to avoid falsely flagging, say, T&& against T even though they are
    // equivalent enough for our purposes
    template <typename T, typename U>
    struct ArgsMatchParams {};
    template <typename... Args, typename... Params>
    struct ArgsMatchParams<std::tuple<Args...>, std::tuple<Params...>> {
        static_assert(sizeof...(Args) <= sizeof...(Params), "Too many arguments");
        static_assert(sizeof...(Args) >= sizeof...(Params), "Not enough arguments");

    private:
        template <size_t Index>
        static constexpr typename std::enable_if<(Index < sizeof...(Args)), bool>::type
        elementsMatch() {
            if (!DecayedElementsMatch<Index, std::tuple<Args...>, std::tuple<Params...>>::value) {
                return false;
            }
            return elementsMatch<Index + 1>();
        }
        template <size_t Index>
        static constexpr typename std::enable_if<(Index >= sizeof...(Args)), bool>::type
        elementsMatch() {
            return true;
        }

    public:
        static constexpr bool value = elementsMatch<0>();
    };

    // Since we assume that pointer arguments are outputs, we can use this template struct to
    // determine whether or not a given argument is fundamentally a pointer type and thus an output
    template <typename T>
    struct IsPointerIfDecayed {
    private:
        using Decayed = typename std::decay<T>::type;

    public:
        static constexpr bool value = std::is_pointer<Decayed>::value;
    };

    template <typename T>
    typename std::enable_if<!IsPointerIfDecayed<T>::value, status_t>::type writeIfInput(
            Parcel* data, T&& t) const {
        return SafeInterface::ParcelHandler{mLogTag}.write(data, std::forward<T>(t));
    }
    template <typename T>
    typename std::enable_if<IsPointerIfDecayed<T>::value, status_t>::type writeIfInput(
            Parcel* /*data*/, T&& /*t*/) const {
        return NO_ERROR;
    }

    // This method iterates through all of the arguments, writing them to the data Parcel if they
    // are an input (i.e., if they are not a pointer type)
    template <typename T, typename... Remaining>
    status_t writeInputs(Parcel* data, T&& t, Remaining&&... remaining) const {
        status_t error = writeIfInput(data, std::forward<T>(t));
        if (CC_UNLIKELY(error != NO_ERROR)) {
            // A message will have been logged by writeIfInput
            return error;
        }
        return writeInputs(data, std::forward<Remaining>(remaining)...);
    }
    static status_t writeInputs(Parcel* /*data*/) { return NO_ERROR; }

    template <typename T>
    typename std::enable_if<IsPointerIfDecayed<T>::value, status_t>::type readIfOutput(
            const Parcel& reply, T&& t) const {
        return SafeInterface::ParcelHandler{mLogTag}.read(reply, std::forward<T>(t));
    }
    template <typename T>
    static typename std::enable_if<!IsPointerIfDecayed<T>::value, status_t>::type readIfOutput(
            const Parcel& /*reply*/, T&& /*t*/) {
        return NO_ERROR;
    }

    // Similar to writeInputs except that it reads output arguments from the reply Parcel
    template <typename T, typename... Remaining>
    status_t readOutputs(const Parcel& reply, T&& t, Remaining&&... remaining) const {
        status_t error = readIfOutput(reply, std::forward<T>(t));
        if (CC_UNLIKELY(error != NO_ERROR)) {
            // A message will have been logged by readIfOutput
            return error;
        }
        return readOutputs(reply, std::forward<Remaining>(remaining)...);
    }
    static status_t readOutputs(const Parcel& /*data*/) { return NO_ERROR; }
};

template <typename Interface>
class SafeBnInterface : public BnInterface<Interface> {
public:
    explicit SafeBnInterface(const char* logTag) : mLogTag(logTag) {}

protected:
    template <typename Method>
    status_t callLocal(const Parcel& data, Parcel* reply, Method method) {
        CHECK_INTERFACE(this, data, reply);

        // Since we need to both pass inputs into the call as well as retrieve outputs, we create a
        // "raw" tuple, where the inputs are interleaved with actual, non-pointer versions of the
        // outputs. When we ultimately call into the method, we will pass the addresses of the
        // output arguments instead of their tuple members directly, but the storage will live in
        // the tuple.
        using ParamTuple = typename SafeInterface::ParamExtractor<Method>::ParamTuple;
        typename RawConverter<std::tuple<>, ParamTuple>::type rawArgs{};

        // Read the inputs from the data Parcel into the argument tuple
        status_t error = InputReader<ParamTuple>{mLogTag}.readInputs(data, &rawArgs);
        if (CC_UNLIKELY(error != NO_ERROR)) {
            // A message will have been logged by read
            return error;
        }

        // Call the local method
        status_t result = MethodCaller<ParamTuple>::call(this, method, &rawArgs);

        // Extract the outputs from the argument tuple and write them into the reply Parcel
        error = OutputWriter<ParamTuple>{mLogTag}.writeOutputs(reply, &rawArgs);
        if (CC_UNLIKELY(error != NO_ERROR)) {
            // A message will have been logged by write
            return error;
        }

        // Return the result code in the reply Parcel
        error = reply->writeInt32(result);
        if (CC_UNLIKELY(error != NO_ERROR)) {
            ALOG(LOG_ERROR, mLogTag, "Failed to write result");
#if SI_DUMP_CALLSTACKS
            CallStack callStack(mLogTag);
#endif
            return error;
        }
        return NO_ERROR;
    }

    template <typename Method>
    status_t callLocalAsync(const Parcel& data, Parcel* /*reply*/, Method method) {
        // reply is not actually used by CHECK_INTERFACE
        CHECK_INTERFACE(this, data, reply);

        // Since we need to both pass inputs into the call as well as retrieve outputs, we create a
        // "raw" tuple, where the inputs are interleaved with actual, non-pointer versions of the
        // outputs. When we ultimately call into the method, we will pass the addresses of the
        // output arguments instead of their tuple members directly, but the storage will live in
        // the tuple.
        using ParamTuple = typename SafeInterface::ParamExtractor<Method>::ParamTuple;
        typename RawConverter<std::tuple<>, ParamTuple>::type rawArgs{};

        // Read the inputs from the data Parcel into the argument tuple
        status_t error = InputReader<ParamTuple>{mLogTag}.readInputs(data, &rawArgs);
        if (CC_UNLIKELY(error != NO_ERROR)) {
            // A message will have been logged by read
            return error;
        }

        // Call the local method
        MethodCaller<ParamTuple>::callVoid(this, method, &rawArgs);

        // After calling, there is nothing more to do since asynchronous calls do not return a value
        // to the caller
        return NO_ERROR;
    }

private:
    const char* const mLogTag;

    // RemoveFirst strips the first element from a tuple.
    // For example, given T = std::tuple<A, B, C>, RemoveFirst<T>::type = std::tuple<B, C>
    template <typename T, typename... Args>
    struct RemoveFirst;
    template <typename T, typename... Args>
    struct RemoveFirst<std::tuple<T, Args...>> {
        using type = std::tuple<Args...>;
    };

    // RawConverter strips a tuple down to its fundamental types, discarding both pointers and
    // references. This allows us to allocate storage for both input (non-pointer) arguments and
    // output (pointer) arguments in one tuple.
    // For example, given T = std::tuple<const A&, B*>, RawConverter<T>::type = std::tuple<A, B>
    template <typename Unconverted, typename... Converted>
    struct RawConverter;
    template <typename Unconverted, typename... Converted>
    struct RawConverter<std::tuple<Converted...>, Unconverted> {
    private:
        using ElementType = typename std::tuple_element<0, Unconverted>::type;
        using Decayed = typename std::decay<ElementType>::type;
        using WithoutPointer = typename std::remove_pointer<Decayed>::type;

    public:
        using type = typename RawConverter<std::tuple<Converted..., WithoutPointer>,
                                           typename RemoveFirst<Unconverted>::type>::type;
    };
    template <typename... Converted>
    struct RawConverter<std::tuple<Converted...>, std::tuple<>> {
        using type = std::tuple<Converted...>;
    };

    // This provides a simple way to determine whether the indexed element of Args... is a pointer
    template <size_t I, typename... Args>
    struct ElementIsPointer {
    private:
        using ElementType = typename std::tuple_element<I, std::tuple<Args...>>::type;

    public:
        static constexpr bool value = std::is_pointer<ElementType>::value;
    };

    // This class iterates over the parameter types, and if a given parameter is an input
    // (i.e., is not a pointer), reads the corresponding argument tuple element from the data Parcel
    template <typename... Params>
    class InputReader;
    template <typename... Params>
    class InputReader<std::tuple<Params...>> {
    public:
        explicit InputReader(const char* logTag) : mLogTag(logTag) {}

        // Note that in this case (as opposed to in SafeBpInterface), we iterate using an explicit
        // index (starting with 0 here) instead of using recursion and stripping the first element.
        // This is because in SafeBpInterface we aren't actually operating on a real tuple, but are
        // instead just using a tuple as a convenient container for variadic types, whereas here we
        // can't modify the argument tuple without causing unnecessary copies or moves of the data
        // contained therein.
        template <typename RawTuple>
        status_t readInputs(const Parcel& data, RawTuple* args) {
            return dispatchArg<0>(data, args);
        }

    private:
        const char* const mLogTag;

        template <std::size_t I, typename RawTuple>
        typename std::enable_if<!ElementIsPointer<I, Params...>::value, status_t>::type readIfInput(
                const Parcel& data, RawTuple* args) {
            return SafeInterface::ParcelHandler{mLogTag}.read(data, &std::get<I>(*args));
        }
        template <std::size_t I, typename RawTuple>
        typename std::enable_if<ElementIsPointer<I, Params...>::value, status_t>::type readIfInput(
                const Parcel& /*data*/, RawTuple* /*args*/) {
            return NO_ERROR;
        }

        // Recursively iterate through the arguments
        template <std::size_t I, typename RawTuple>
        typename std::enable_if<(I < sizeof...(Params)), status_t>::type dispatchArg(
                const Parcel& data, RawTuple* args) {
            status_t error = readIfInput<I>(data, args);
            if (CC_UNLIKELY(error != NO_ERROR)) {
                // A message will have been logged in read
                return error;
            }
            return dispatchArg<I + 1>(data, args);
        }
        template <std::size_t I, typename RawTuple>
        typename std::enable_if<(I >= sizeof...(Params)), status_t>::type dispatchArg(
                const Parcel& /*data*/, RawTuple* /*args*/) {
            return NO_ERROR;
        }
    };

    // getForCall uses the types of the parameters to determine whether a given element of the
    // argument tuple is an input, which should be passed directly into the call, or an output, for
    // which its address should be passed into the call
    template <size_t I, typename RawTuple, typename... Params>
    static typename std::enable_if<
            ElementIsPointer<I, Params...>::value,
            typename std::tuple_element<I, std::tuple<Params...>>::type>::type
    getForCall(RawTuple* args) {
        return &std::get<I>(*args);
    }
    template <size_t I, typename RawTuple, typename... Params>
    static typename std::enable_if<
            !ElementIsPointer<I, Params...>::value,
            typename std::tuple_element<I, std::tuple<Params...>>::type>::type&
    getForCall(RawTuple* args) {
        return std::get<I>(*args);
    }

    // This template class uses std::index_sequence and parameter pack expansion to call the given
    // method using the elements of the argument tuple (after those arguments are passed through
    // getForCall to get addresses instead of values for output arguments)
    template <typename... Params>
    struct MethodCaller;
    template <typename... Params>
    struct MethodCaller<std::tuple<Params...>> {
    public:
        // The calls through these to the helper methods are necessary to generate the
        // std::index_sequences used to unpack the argument tuple into the method call
        template <typename Class, typename MemberFunction, typename RawTuple>
        static status_t call(Class* instance, MemberFunction function, RawTuple* args) {
            return callHelper(instance, function, args, std::index_sequence_for<Params...>{});
        }
        template <typename Class, typename MemberFunction, typename RawTuple>
        static void callVoid(Class* instance, MemberFunction function, RawTuple* args) {
            callVoidHelper(instance, function, args, std::index_sequence_for<Params...>{});
        }

    private:
        template <typename Class, typename MemberFunction, typename RawTuple, std::size_t... I>
        static status_t callHelper(Class* instance, MemberFunction function, RawTuple* args,
                                   std::index_sequence<I...> /*unused*/) {
            return (instance->*function)(getForCall<I, RawTuple, Params...>(args)...);
        }
        template <typename Class, typename MemberFunction, typename RawTuple, std::size_t... I>
        static void callVoidHelper(Class* instance, MemberFunction function, RawTuple* args,
                                   std::index_sequence<I...> /*unused*/) {
            (instance->*function)(getForCall<I, RawTuple, Params...>(args)...);
        }
    };

    // This class iterates over the parameter types, and if a given parameter is an output
    // (i.e., is a pointer), writes the corresponding argument tuple element into the reply Parcel
    template <typename... Params>
    struct OutputWriter;
    template <typename... Params>
    struct OutputWriter<std::tuple<Params...>> {
    public:
        explicit OutputWriter(const char* logTag) : mLogTag(logTag) {}

        // See the note on InputReader::readInputs for why this differs from the arguably simpler
        // RemoveFirst approach in SafeBpInterface
        template <typename RawTuple>
        status_t writeOutputs(Parcel* reply, RawTuple* args) {
            return dispatchArg<0>(reply, args);
        }

    private:
        const char* const mLogTag;

        template <std::size_t I, typename RawTuple>
        typename std::enable_if<ElementIsPointer<I, Params...>::value, status_t>::type
        writeIfOutput(Parcel* reply, RawTuple* args) {
            return SafeInterface::ParcelHandler{mLogTag}.write(reply, std::get<I>(*args));
        }
        template <std::size_t I, typename RawTuple>
        typename std::enable_if<!ElementIsPointer<I, Params...>::value, status_t>::type
        writeIfOutput(Parcel* /*reply*/, RawTuple* /*args*/) {
            return NO_ERROR;
        }

        // Recursively iterate through the arguments
        template <std::size_t I, typename RawTuple>
        typename std::enable_if<(I < sizeof...(Params)), status_t>::type dispatchArg(
                Parcel* reply, RawTuple* args) {
            status_t error = writeIfOutput<I>(reply, args);
            if (CC_UNLIKELY(error != NO_ERROR)) {
                // A message will have been logged in read
                return error;
            }
            return dispatchArg<I + 1>(reply, args);
        }
        template <std::size_t I, typename RawTuple>
        typename std::enable_if<(I >= sizeof...(Params)), status_t>::type dispatchArg(
                Parcel* /*reply*/, RawTuple* /*args*/) {
            return NO_ERROR;
        }
    };
};

} // namespace android