Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b3b9dc8b authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "ParcelableHolder.(set|get)Parcelable return status_t" am: 41a1ee62 

Original change: https://android-review.googlesource.com/c/platform/frameworks/native/+/1534913

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: I8a5cfff7efcab8c29f2616679184084e2f3a6f60
parents 0522e004 41a1ee62

libs/binder/include/binder/ParcelableHolder.h

+17 −11
Original line number Original line Diff line number Diff line
@@ -52,53 +52,59 @@ public: 
    }

    }





    template <typename T>

    template <typename T>

    bool setParcelable(T&& p) {

    status_t setParcelable(T&& p) {

        using Tt = typename std::decay<T>::type;

        using Tt = typename std::decay<T>::type;

        return setParcelable<Tt>(std::make_shared<Tt>(std::forward<T>(p)));

        return setParcelable<Tt>(std::make_shared<Tt>(std::forward<T>(p)));

    }

    }





    template <typename T>

    template <typename T>

    bool setParcelable(std::shared_ptr<T> p) {

    status_t setParcelable(std::shared_ptr<T> p) {

        static_assert(std::is_base_of<Parcelable, T>::value, "T must be derived from Parcelable");

        static_assert(std::is_base_of<Parcelable, T>::value, "T must be derived from Parcelable");

        if (p && this->getStability() > p->getStability()) {

        if (p && this->getStability() > p->getStability()) {

            return false;

            return android::BAD_VALUE;

        }

        }

        this->mParcelable = p;

        this->mParcelable = p;

        this->mParcelableName = T::getParcelableDescriptor();

        this->mParcelableName = T::getParcelableDescriptor();

        this->mParcelPtr = nullptr;

        this->mParcelPtr = nullptr;

        return true;

        return android::OK;

    }

    }





    template <typename T>

    template <typename T>

    std::shared_ptr<T> getParcelable() const {

    status_t getParcelable(std::shared_ptr<T>* ret) const {

        static_assert(std::is_base_of<Parcelable, T>::value, "T must be derived from Parcelable");

        static_assert(std::is_base_of<Parcelable, T>::value, "T must be derived from Parcelable");

        const std::string& parcelableDesc = T::getParcelableDescriptor();

        const std::string& parcelableDesc = T::getParcelableDescriptor();

        if (!this->mParcelPtr) {

        if (!this->mParcelPtr) {

            if (!this->mParcelable || !this->mParcelableName) {

            if (!this->mParcelable || !this->mParcelableName) {

                ALOGD("empty ParcelableHolder");

                ALOGD("empty ParcelableHolder");

                return nullptr;

                *ret = nullptr;

                return android::OK;

            } else if (parcelableDesc != *mParcelableName) {

            } else if (parcelableDesc != *mParcelableName) {

                ALOGD("extension class name mismatch expected:%s actual:%s",

                ALOGD("extension class name mismatch expected:%s actual:%s",

                      mParcelableName->c_str(), parcelableDesc.c_str());

                      mParcelableName->c_str(), parcelableDesc.c_str());

                return nullptr;

                *ret = nullptr;

                return android::BAD_VALUE;

            }

            }

            return std::shared_ptr<T>(mParcelable, reinterpret_cast<T*>(mParcelable.get()));

            *ret = std::shared_ptr<T>(mParcelable, reinterpret_cast<T*>(mParcelable.get()));

            return android::OK;

        }

        }

        this->mParcelPtr->setDataPosition(0);

        this->mParcelPtr->setDataPosition(0);

        status_t status = this->mParcelPtr->readUtf8FromUtf16(&this->mParcelableName);

        status_t status = this->mParcelPtr->readUtf8FromUtf16(&this->mParcelableName);

        if (status != android::OK || parcelableDesc != this->mParcelableName) {

        if (status != android::OK || parcelableDesc != this->mParcelableName) {

            this->mParcelableName = std::nullopt;

            this->mParcelableName = std::nullopt;

            return nullptr;

            *ret = nullptr;

            return status;

        }

        }

        this->mParcelable = std::make_shared<T>();

        this->mParcelable = std::make_shared<T>();

        status = mParcelable.get()->readFromParcel(this->mParcelPtr.get());

        status = mParcelable.get()->readFromParcel(this->mParcelPtr.get());

        if (status != android::OK) {

        if (status != android::OK) {

            this->mParcelableName = std::nullopt;

            this->mParcelableName = std::nullopt;

            this->mParcelable = nullptr;

            this->mParcelable = nullptr;

            return nullptr;

            *ret = nullptr;

            return status;

        }

        }

        this->mParcelPtr = nullptr;

        this->mParcelPtr = nullptr;

        return std::shared_ptr<T>(mParcelable, reinterpret_cast<T*>(mParcelable.get()));

        *ret = std::shared_ptr<T>(mParcelable, reinterpret_cast<T*>(mParcelable.get()));

        return android::OK;

    }

    }





    Stability getStability() const override { return mStability; }

    Stability getStability() const override { return mStability; }

libs/binder/ndk/include_cpp/android/binder_parcelable_utils.h

+13 −10
Original line number Original line Diff line number Diff line
@@ -82,34 +82,37 @@ class AParcelableHolder { 
    }

    }





    template <typename T>

    template <typename T>

    bool setParcelable(const T& p) {

    binder_status_t setParcelable(const T& p) {

        if (this->mStability > T::_aidl_stability) {

        if (this->mStability > T::_aidl_stability) {

            return false;

            return STATUS_BAD_VALUE;

        }

        }

        AParcel_reset(mParcel.get());

        AParcel_reset(mParcel.get());

        AParcel_writeString(mParcel.get(), T::descriptor, strlen(T::descriptor));

        AParcel_writeString(mParcel.get(), T::descriptor, strlen(T::descriptor));

        p.writeToParcel(mParcel.get());

        p.writeToParcel(mParcel.get());

        return true;

        return STATUS_OK;

    }

    }





    template <typename T>

    template <typename T>

    std::unique_ptr<T> getParcelable() const {

    binder_status_t getParcelable(std::optional<T>* ret) const {

        const std::string parcelableDesc(T::descriptor);

        const std::string parcelableDesc(T::descriptor);

        AParcel_setDataPosition(mParcel.get(), 0);

        AParcel_setDataPosition(mParcel.get(), 0);

        if (AParcel_getDataSize(mParcel.get()) == 0) {

        if (AParcel_getDataSize(mParcel.get()) == 0) {

            return nullptr;

            *ret = std::nullopt;

            return STATUS_OK;

        }

        }

        std::string parcelableDescInParcel;

        std::string parcelableDescInParcel;

        binder_status_t status = AParcel_readString(mParcel.get(), &parcelableDescInParcel);

        binder_status_t status = AParcel_readString(mParcel.get(), &parcelableDescInParcel);

        if (status != STATUS_OK || parcelableDesc != parcelableDescInParcel) {

        if (status != STATUS_OK || parcelableDesc != parcelableDescInParcel) {

            return nullptr;

            *ret = std::nullopt;

            return status;

        }

        }

        std::unique_ptr<T> ret = std::make_unique<T>();

        *ret = std::make_optional<T>();

        status = ret->readFromParcel(this->mParcel.get());

        status = (*ret)->readFromParcel(this->mParcel.get());

        if (status != STATUS_OK) {

        if (status != STATUS_OK) {

            return nullptr;

            *ret = std::nullopt;

            return status;

        }

        }

        return std::move(ret);

        return STATUS_OK;

    }

    }





    void reset() { AParcel_reset(mParcel.get()); }

    void reset() { AParcel_reset(mParcel.get()); }