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

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

Merge "Updates encoding/decoding of optional metadata" am: 67fbd47a

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

Change-Id: Ieda8ad960a8295a59a9e4f016fceecddcd9b388d
parents 74724e2d 67fbd47a
Loading
Loading
Loading
Loading
+89 −34
Original line number Diff line number Diff line
@@ -195,6 +195,35 @@ using ErrorHandler = void(*)(T*);
status_t encodeMetadataType(const MetadataType& input, OutputHidlVec* output);
status_t validateMetadataType(InputHidlVec* input, const MetadataType& expectedMetadataType);

/**
 * Private helper functions
 */
template <class T>
status_t encodeInteger(const T& input, OutputHidlVec* output) {
    static_assert(std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value ||
                  std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value ||
                  std::is_same<T, float>::value || std::is_same<T, double>::value);
    if (!output) {
        return BAD_VALUE;
    }

    const uint8_t* tmp = reinterpret_cast<const uint8_t*>(&input);
    return output->encode(tmp, sizeof(input));
}

template <class T>
status_t decodeInteger(InputHidlVec* input, T* output) {
    static_assert(std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value ||
                  std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value ||
                  std::is_same<T, float>::value || std::is_same<T, double>::value);
    if (!output) {
        return BAD_VALUE;
    }

    uint8_t* tmp = reinterpret_cast<uint8_t*>(output);
    return input->decode(tmp, sizeof(*output));
}

/**
 * encode/encodeMetadata are the main encoding functions. They take in T and uses the encodeHelper
 * function to turn T into the hidl_vec byte stream.
@@ -251,10 +280,45 @@ status_t encodeMetadata(const MetadataType& metadataType, const T& input, hidl_v
template <class T>
status_t encodeOptionalMetadata(const MetadataType& metadataType, const std::optional<T>& input,
                        hidl_vec<uint8_t>* output, EncodeHelper<T> encodeHelper) {
    if (!input) {
        return NO_ERROR;
    OutputHidlVec outputHidlVec{output};

    status_t err = encodeMetadataType(metadataType, &outputHidlVec);
    if (err) {
        return err;
    }
    return encodeMetadata(metadataType, *input, output, encodeHelper);

    err = encodeInteger<uint32_t>(input.has_value() ? 1 : 0, &outputHidlVec);
    if (err) {
        return err;
    }

    if (input) {
        err = encodeHelper(*input, &outputHidlVec);
        if (err) {
            return err;
        }
    }

    err = outputHidlVec.resize();
    if (err) {
        return err;
    }

    err = encodeMetadataType(metadataType, &outputHidlVec);
    if (err) {
        return err;
    }

    err = encodeInteger<uint32_t>(input.has_value() ? 1 : 0, &outputHidlVec);
    if (err) {
        return err;
    }

    if (input) {
        return encodeHelper(*input, &outputHidlVec);
    }

    return NO_ERROR;
}

/**
@@ -315,45 +379,36 @@ status_t decodeOptionalMetadata(const MetadataType& metadataType, const hidl_vec
    if (!output) {
        return BAD_VALUE;
    }
    if (input.size() <= 0) {
        output->reset();
        return NO_ERROR;
    }
    T tmp;
    status_t err = decodeMetadata(metadataType, input, &tmp, decodeHelper);
    if (!err) {
        *output = tmp;

    InputHidlVec inputHidlVec{&input};

    status_t err = validateMetadataType(&inputHidlVec, metadataType);
    if (err) {
        return err;
    }

    uint32_t present = 0;
    err = decodeInteger<uint32_t>(&inputHidlVec, &present);
    if (err) {
        return err;
    }

/**
 * Private helper functions
 */
template <class T>
status_t encodeInteger(const T& input, OutputHidlVec* output) {
    static_assert(std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value ||
                  std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value ||
                  std::is_same<T, float>::value || std::is_same<T, double>::value);
    if (!output) {
        return BAD_VALUE;
    if (present) {
        T tmp;
        err = decodeHelper(&inputHidlVec, &tmp);
        if (err) {
            return err;
        }

    const uint8_t* tmp = reinterpret_cast<const uint8_t*>(&input);
    return output->encode(tmp, sizeof(input));
        *output = tmp;
    }

template <class T>
status_t decodeInteger(InputHidlVec* input, T* output) {
    static_assert(std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value ||
                  std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value ||
                  std::is_same<T, float>::value || std::is_same<T, double>::value);
    if (!output) {
    err = inputHidlVec.hasRemainingData();
    if (err) {
        return BAD_VALUE;
    }

    uint8_t* tmp = reinterpret_cast<uint8_t*>(output);
    return input->decode(tmp, sizeof(*output));
    return NO_ERROR;
}

status_t encodeString(const std::string& input, OutputHidlVec* output) {