Merge "Add support for PersistableBundle in C++"

/*

 * Copyright (C) 2015 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.

 */

#ifndef ANDROID_PERSISTABLE_BUNDLE_H

#define ANDROID_PERSISTABLE_BUNDLE_H

#include <map>

#include <vector>

#include <binder/Parcelable.h>

#include <utils/String16.h>

#include <utils/StrongPointer.h>

namespace android {

namespace os {

/*

 * 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 {

public:

    PersistableBundle() = default;

    virtual ~PersistableBundle() = default;

    PersistableBundle(const PersistableBundle& bundle) = default;

    status_t writeToParcel(Parcel* parcel) const override;

    status_t readFromParcel(const Parcel* parcel) override;

    bool empty() const;

    size_t size() const;

    size_t erase(const String16& key);

    /*

     * Setters for PersistableBundle. Adds a a key-value pair instantiated with

     * |key| and |value| into the member map appropriate for the type of |value|.

     * If there is already an existing value for |key|, |value| will replace it.

     */

    void putBoolean(const String16& key, bool value);

    void putInt(const String16& key, int32_t value);

    void putLong(const String16& key, int64_t value);

    void putDouble(const String16& key, double value);

    void putString(const String16& key, const String16& value);

    void putBooleanVector(const String16& key, const std::vector<bool>& value);

    void putIntVector(const String16& key, const std::vector<int32_t>& value);

    void putLongVector(const String16& key, const std::vector<int64_t>& value);

    void putDoubleVector(const String16& key, const std::vector<double>& value);

    void putStringVector(const String16& key, const std::vector<String16>& value);

    void putPersistableBundle(const String16& key, const PersistableBundle& value);

    /*

     * Getters for PersistableBundle. If |key| exists, these methods write the

     * value associated with |key| into |out|, and return true. Otherwise, these

     * methods return false.

     */

    bool getBoolean(const String16& key, bool* out) const;

    bool getInt(const String16& key, int32_t* out) const;

    bool getLong(const String16& key, int64_t* out) const;

    bool getDouble(const String16& key, double* out) const;

    bool getString(const String16& key, String16* out) const;

    bool getBooleanVector(const String16& key, std::vector<bool>* out) const;

    bool getIntVector(const String16& key, std::vector<int32_t>* out) const;

    bool getLongVector(const String16& key, std::vector<int64_t>* out) const;

    bool getDoubleVector(const String16& key, std::vector<double>* out) const;

    bool getStringVector(const String16& key, std::vector<String16>* out) const;

    bool getPersistableBundle(const String16& key, PersistableBundle* out) const;

    friend bool operator==(const PersistableBundle& lhs, const PersistableBundle& rhs) {

        return (lhs.mBoolMap == rhs.mBoolMap && lhs.mIntMap == rhs.mIntMap &&

                lhs.mLongMap == rhs.mLongMap && lhs.mDoubleMap == rhs.mDoubleMap &&

                lhs.mStringMap == rhs.mStringMap && lhs.mBoolVectorMap == rhs.mBoolVectorMap &&

                lhs.mIntVectorMap == rhs.mIntVectorMap &&

                lhs.mLongVectorMap == rhs.mLongVectorMap &&

                lhs.mDoubleVectorMap == rhs.mDoubleVectorMap &&

                lhs.mStringVectorMap == rhs.mStringVectorMap &&

                lhs.mPersistableBundleMap == rhs.mPersistableBundleMap);

    }

    friend bool operator!=(const PersistableBundle& lhs, const PersistableBundle& rhs) {

        return !(lhs == rhs);

    }

private:

    status_t writeToParcelInner(Parcel* parcel) const;

    status_t readFromParcelInner(const Parcel* parcel, size_t length);

    std::map<String16, bool> mBoolMap;

    std::map<String16, int32_t> mIntMap;

    std::map<String16, int64_t> mLongMap;

    std::map<String16, double> mDoubleMap;

    std::map<String16, String16> mStringMap;

    std::map<String16, std::vector<bool>> mBoolVectorMap;

    std::map<String16, std::vector<int32_t>> mIntVectorMap;

    std::map<String16, std::vector<int64_t>> mLongVectorMap;

    std::map<String16, std::vector<double>> mDoubleVectorMap;

    std::map<String16, std::vector<String16>> mStringVectorMap;

    std::map<String16, PersistableBundle> mPersistableBundleMap;

};

}  // namespace os

}  // namespace android

#endif  // ANDROID_PERSISTABLE_BUNDLE_H

    IPCThreadState.cpp \

    IPermissionController.cpp \

    IProcessInfoService.cpp \

    ProcessInfoService.cpp \

    IServiceManager.cpp \

    MemoryDealer.cpp \

    MemoryBase.cpp \

    MemoryDealer.cpp \

    MemoryHeapBase.cpp \

    Parcel.cpp \

    PermissionCache.cpp \

    PersistableBundle.cpp \

    ProcessInfoService.cpp \

    ProcessState.cpp \

    Static.cpp \

    Status.cpp \

/*

 * Copyright (C) 2015 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.

 */

#define LOG_TAG "PersistableBundle"

#include <binder/PersistableBundle.h>

#include <limits>

#include <binder/IBinder.h>

#include <binder/Parcel.h>

#include <log/log.h>

#include <utils/Errors.h>

using android::BAD_TYPE;

using android::BAD_VALUE;

using android::NO_ERROR;

using android::Parcel;

using android::sp;

using android::status_t;

using android::UNEXPECTED_NULL;

enum {

    // Keep in sync with BUNDLE_MAGIC in frameworks/base/core/java/android/os/BaseBundle.java.

    BUNDLE_MAGIC = 0x4C444E42,

};

enum {

    // Keep in sync with frameworks/base/core/java/android/os/Parcel.java.

    VAL_STRING = 0,

    VAL_INTEGER = 1,

    VAL_LONG = 6,

    VAL_DOUBLE = 8,

    VAL_BOOLEAN = 9,

    VAL_STRINGARRAY = 14,

    VAL_INTARRAY = 18,

    VAL_LONGARRAY = 19,

    VAL_BOOLEANARRAY = 23,

    VAL_PERSISTABLEBUNDLE = 25,

    VAL_DOUBLEARRAY = 28,

};

namespace {

template <typename T>

bool getValue(const android::String16& key, T* out, const std::map<android::String16, T>& map) {

    const auto& it = map.find(key);

    if (it == map.end()) return false;

    *out = it->second;

    return true;

}

}  // namespace

namespace android {

namespace os {

#define RETURN_IF_FAILED(calledOnce)                                     \

    {                                                                    \

        status_t returnStatus = calledOnce;                              \

        if (returnStatus) {                                              \

            ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \

            return returnStatus;                                         \

         }                                                               \

    }

#define RETURN_IF_ENTRY_ERASED(map, key)                                 \

    {                                                                    \

        size_t num_erased = map.erase(key);                              \

        if (num_erased) {                                                \

            ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \

            return num_erased;                                           \

         }                                                               \

    }

status_t PersistableBundle::writeToParcel(Parcel* parcel) const {

    /*

     * Keep implementation in sync with writeToParcelInner() in

     * frameworks/base/core/java/android/os/BaseBundle.java.

     */

    // Special case for empty bundles.

    if (empty()) {

        RETURN_IF_FAILED(parcel->writeInt32(0));

        return NO_ERROR;

    }

    size_t length_pos = parcel->dataPosition();

    RETURN_IF_FAILED(parcel->writeInt32(1));  // dummy, will hold length

    RETURN_IF_FAILED(parcel->writeInt32(BUNDLE_MAGIC));

    size_t start_pos = parcel->dataPosition();

    RETURN_IF_FAILED(writeToParcelInner(parcel));

    size_t end_pos = parcel->dataPosition();

    // Backpatch length. This length value includes the length header.

    parcel->setDataPosition(length_pos);

    size_t length = end_pos - start_pos;

    if (length > std::numeric_limits<int32_t>::max()) {

        ALOGE("Parcel length (%u) too large to store in 32-bit signed int", length);

        return BAD_VALUE;

    }

    RETURN_IF_FAILED(parcel->writeInt32(static_cast<int32_t>(length)));

    parcel->setDataPosition(end_pos);

    return NO_ERROR;

}

status_t PersistableBundle::readFromParcel(const Parcel* parcel) {

    /*

     * Keep implementation in sync with readFromParcelInner() in

     * frameworks/base/core/java/android/os/BaseBundle.java.

     */

    int32_t length = parcel->readInt32();

    if (length < 0) {

        ALOGE("Bad length in parcel: %d", length);

        return UNEXPECTED_NULL;

    }

    return readFromParcelInner(parcel, static_cast<size_t>(length));

}

bool PersistableBundle::empty() const {

    return size() == 0u;

}

size_t PersistableBundle::size() const {

    return (mBoolMap.size() +

            mIntMap.size() +

            mLongMap.size() +

            mDoubleMap.size() +

            mStringMap.size() +

            mBoolVectorMap.size() +

            mIntVectorMap.size() +

            mLongVectorMap.size() +

            mDoubleVectorMap.size() +

            mStringVectorMap.size() +

            mPersistableBundleMap.size());

}

size_t PersistableBundle::erase(const String16& key) {

    RETURN_IF_ENTRY_ERASED(mBoolMap, key);

    RETURN_IF_ENTRY_ERASED(mIntMap, key);

    RETURN_IF_ENTRY_ERASED(mLongMap, key);

    RETURN_IF_ENTRY_ERASED(mDoubleMap, key);

    RETURN_IF_ENTRY_ERASED(mStringMap, key);

    RETURN_IF_ENTRY_ERASED(mBoolVectorMap, key);

    RETURN_IF_ENTRY_ERASED(mIntVectorMap, key);

    RETURN_IF_ENTRY_ERASED(mLongVectorMap, key);

    RETURN_IF_ENTRY_ERASED(mDoubleVectorMap, key);

    RETURN_IF_ENTRY_ERASED(mStringVectorMap, key);

    return mPersistableBundleMap.erase(key);

}

void PersistableBundle::putBoolean(const String16& key, bool value) {

    erase(key);

    mBoolMap[key] = value;

}

void PersistableBundle::putInt(const String16& key, int32_t value) {

    erase(key);

    mIntMap[key] = value;

}

void PersistableBundle::putLong(const String16& key, int64_t value) {

    erase(key);

    mLongMap[key] = value;

}

void PersistableBundle::putDouble(const String16& key, double value) {

    erase(key);

    mDoubleMap[key] = value;

}

void PersistableBundle::putString(const String16& key, const String16& value) {

    erase(key);

    mStringMap[key] = value;

}

void PersistableBundle::putBooleanVector(const String16& key, const std::vector<bool>& value) {

    erase(key);

    mBoolVectorMap[key] = value;

}

void PersistableBundle::putIntVector(const String16& key, const std::vector<int32_t>& value) {

    erase(key);

    mIntVectorMap[key] = value;

}

void PersistableBundle::putLongVector(const String16& key, const std::vector<int64_t>& value) {

    erase(key);

    mLongVectorMap[key] = value;

}

void PersistableBundle::putDoubleVector(const String16& key, const std::vector<double>& value) {

    erase(key);

    mDoubleVectorMap[key] = value;

}

void PersistableBundle::putStringVector(const String16& key, const std::vector<String16>& value) {

    erase(key);

    mStringVectorMap[key] = value;

}

void PersistableBundle::putPersistableBundle(const String16& key, const PersistableBundle& value) {

    erase(key);

    mPersistableBundleMap[key] = value;

}

bool PersistableBundle::getBoolean(const String16& key, bool* out) const {

    return getValue(key, out, mBoolMap);

}

bool PersistableBundle::getInt(const String16& key, int32_t* out) const {

    return getValue(key, out, mIntMap);

}

bool PersistableBundle::getLong(const String16& key, int64_t* out) const {

    return getValue(key, out, mLongMap);

}

bool PersistableBundle::getDouble(const String16& key, double* out) const {

    return getValue(key, out, mDoubleMap);

}

bool PersistableBundle::getString(const String16& key, String16* out) const {

    return getValue(key, out, mStringMap);

}

bool PersistableBundle::getBooleanVector(const String16& key, std::vector<bool>* out) const {

    return getValue(key, out, mBoolVectorMap);

}

bool PersistableBundle::getIntVector(const String16& key, std::vector<int32_t>* out) const {

    return getValue(key, out, mIntVectorMap);

}

bool PersistableBundle::getLongVector(const String16& key, std::vector<int64_t>* out) const {

    return getValue(key, out, mLongVectorMap);

}

bool PersistableBundle::getDoubleVector(const String16& key, std::vector<double>* out) const {

    return getValue(key, out, mDoubleVectorMap);

}

bool PersistableBundle::getStringVector(const String16& key, std::vector<String16>* out) const {

    return getValue(key, out, mStringVectorMap);

}

bool PersistableBundle::getPersistableBundle(const String16& key, PersistableBundle* out) const {

    return getValue(key, out, mPersistableBundleMap);

}

status_t PersistableBundle::writeToParcelInner(Parcel* parcel) const {

    /*

     * To keep this implementation in sync with writeArrayMapInternal() in

     * frameworks/base/core/java/android/os/Parcel.java, the number of key

     * value pairs must be written into the parcel before writing the key-value

     * pairs themselves.

     */

    size_t num_entries = size();

    if (num_entries > std::numeric_limits<int32_t>::max()) {

        ALOGE("The size of this PersistableBundle (%u) too large to store in 32-bit signed int",

              num_entries);

        return BAD_VALUE;

    }

    RETURN_IF_FAILED(parcel->writeInt32(static_cast<int32_t>(num_entries)));

    for (const auto& key_val_pair : mBoolMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_BOOLEAN));

        RETURN_IF_FAILED(parcel->writeBool(key_val_pair.second));

    }

    for (const auto& key_val_pair : mIntMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_INTEGER));

        RETURN_IF_FAILED(parcel->writeInt32(key_val_pair.second));

    }

    for (const auto& key_val_pair : mLongMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_LONG));

        RETURN_IF_FAILED(parcel->writeInt64(key_val_pair.second));

    }

    for (const auto& key_val_pair : mDoubleMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_DOUBLE));

        RETURN_IF_FAILED(parcel->writeDouble(key_val_pair.second));

    }

    for (const auto& key_val_pair : mStringMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_STRING));

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.second));

    }

    for (const auto& key_val_pair : mBoolVectorMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_BOOLEANARRAY));

        RETURN_IF_FAILED(parcel->writeBoolVector(key_val_pair.second));

    }

    for (const auto& key_val_pair : mIntVectorMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_INTARRAY));

        RETURN_IF_FAILED(parcel->writeInt32Vector(key_val_pair.second));

    }

    for (const auto& key_val_pair : mLongVectorMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_LONGARRAY));

        RETURN_IF_FAILED(parcel->writeInt64Vector(key_val_pair.second));

    }

    for (const auto& key_val_pair : mDoubleVectorMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_DOUBLEARRAY));

        RETURN_IF_FAILED(parcel->writeDoubleVector(key_val_pair.second));

    }

    for (const auto& key_val_pair : mStringVectorMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_STRINGARRAY));

        RETURN_IF_FAILED(parcel->writeString16Vector(key_val_pair.second));

    }

    for (const auto& key_val_pair : mPersistableBundleMap) {

        RETURN_IF_FAILED(parcel->writeString16(key_val_pair.first));

        RETURN_IF_FAILED(parcel->writeInt32(VAL_PERSISTABLEBUNDLE));

        RETURN_IF_FAILED(key_val_pair.second.writeToParcel(parcel));

    }

    return NO_ERROR;

}

status_t PersistableBundle::readFromParcelInner(const Parcel* parcel, size_t length) {

    /*

     * Note: we don't actually use length for anything other than an empty PersistableBundle

     * check, since we do not actually need to copy in an entire Parcel, unlike in the Java

     * implementation.

     */

    if (length == 0) {

        // Empty PersistableBundle or end of data.

        return NO_ERROR;

    }

    int32_t magic;

    RETURN_IF_FAILED(parcel->readInt32(&magic));

    if (magic != BUNDLE_MAGIC) {

        ALOGE("Bad magic number for PersistableBundle: 0x%08x", magic);

        return BAD_VALUE;

    }

    /*

     * To keep this implementation in sync with unparcel() in

     * frameworks/base/core/java/android/os/BaseBundle.java, the number of

     * key-value pairs must be read from the parcel before reading the key-value

     * pairs themselves.

     */

    int32_t num_entries;

    RETURN_IF_FAILED(parcel->readInt32(&num_entries));

    for (; num_entries > 0; --num_entries) {

        size_t start_pos = parcel->dataPosition();

        String16 key;

        int32_t value_type;

        RETURN_IF_FAILED(parcel->readString16(&key));

        RETURN_IF_FAILED(parcel->readInt32(&value_type));

        /*

         * We assume that both the C++ and Java APIs ensure that all keys in a PersistableBundle

         * are unique.

         */

        switch (value_type) {

            case VAL_STRING: {

                RETURN_IF_FAILED(parcel->readString16(&mStringMap[key]));

                break;

            }

            case VAL_INTEGER: {

                RETURN_IF_FAILED(parcel->readInt32(&mIntMap[key]));

                break;

            }

            case VAL_LONG: {

                RETURN_IF_FAILED(parcel->readInt64(&mLongMap[key]));

                break;

            }

            case VAL_DOUBLE: {

                RETURN_IF_FAILED(parcel->readDouble(&mDoubleMap[key]));

                break;

            }

            case VAL_BOOLEAN: {

                RETURN_IF_FAILED(parcel->readBool(&mBoolMap[key]));

                break;

            }

            case VAL_STRINGARRAY: {

                RETURN_IF_FAILED(parcel->readString16Vector(&mStringVectorMap[key]));

                break;

            }

            case VAL_INTARRAY: {

                RETURN_IF_FAILED(parcel->readInt32Vector(&mIntVectorMap[key]));

                break;

            }

            case VAL_LONGARRAY: {

                RETURN_IF_FAILED(parcel->readInt64Vector(&mLongVectorMap[key]));

                break;

            }

            case VAL_BOOLEANARRAY: {

                RETURN_IF_FAILED(parcel->readBoolVector(&mBoolVectorMap[key]));

                break;

            }

            case VAL_PERSISTABLEBUNDLE: {

                RETURN_IF_FAILED(mPersistableBundleMap[key].readFromParcel(parcel));

                break;

            }

            case VAL_DOUBLEARRAY: {

                RETURN_IF_FAILED(parcel->readDoubleVector(&mDoubleVectorMap[key]));

                break;

            }

            default: {

                ALOGE("Unrecognized type: %d", value_type);

                return BAD_TYPE;

                break;

            }

        }

    }

    return NO_ERROR;

}

}  // namespace os

}  // namespace android