upload android base code part6

android/system/libhidl/base/HidlSupport.cpp

@@ -0,0 +1,279 @@
+/*
+ * Copyright (C) 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.
+ */
+#define LOG_TAG "HidlSupport"
+
+#include <hidl/HidlSupport.h>
+
+#include <unordered_map>
+
+#include <android-base/logging.h>
+#include <android-base/parseint.h>
+
+namespace android {
+namespace hardware {
+
+namespace details {
+bool debuggable() {
+#ifdef LIBHIDL_TARGET_DEBUGGABLE
+    return true;
+#else
+    return false;
+#endif
+}
+}  // namespace details
+
+hidl_handle::hidl_handle() {
+    mHandle = nullptr;
+    mOwnsHandle = false;
+}
+
+hidl_handle::~hidl_handle() {
+    freeHandle();
+}
+
+hidl_handle::hidl_handle(const native_handle_t *handle) {
+    mHandle = handle;
+    mOwnsHandle = false;
+}
+
+// copy constructor.
+hidl_handle::hidl_handle(const hidl_handle &other) {
+    mOwnsHandle = false;
+    *this = other;
+}
+
+// move constructor.
+hidl_handle::hidl_handle(hidl_handle &&other) {
+    mOwnsHandle = false;
+    *this = std::move(other);
+}
+
+// assignment operators
+hidl_handle &hidl_handle::operator=(const hidl_handle &other) {
+    if (this == &other) {
+        return *this;
+    }
+    freeHandle();
+    if (other.mHandle != nullptr) {
+        mHandle = native_handle_clone(other.mHandle);
+        if (mHandle == nullptr) {
+            PLOG(FATAL) << "Failed to clone native_handle in hidl_handle";
+        }
+        mOwnsHandle = true;
+    } else {
+        mHandle = nullptr;
+        mOwnsHandle = false;
+    }
+    return *this;
+}
+
+hidl_handle &hidl_handle::operator=(const native_handle_t *native_handle) {
+    freeHandle();
+    mHandle = native_handle;
+    mOwnsHandle = false;
+    return *this;
+}
+
+hidl_handle &hidl_handle::operator=(hidl_handle &&other) {
+    if (this != &other) {
+        freeHandle();
+        mHandle = other.mHandle;
+        mOwnsHandle = other.mOwnsHandle;
+        other.mHandle = nullptr;
+        other.mOwnsHandle = false;
+    }
+    return *this;
+}
+
+void hidl_handle::setTo(native_handle_t* handle, bool shouldOwn) {
+    freeHandle();
+    mHandle = handle;
+    mOwnsHandle = shouldOwn;
+}
+
+const native_handle_t* hidl_handle::operator->() const {
+    return mHandle;
+}
+
+// implicit conversion to const native_handle_t*
+hidl_handle::operator const native_handle_t *() const {
+    return mHandle;
+}
+
+// explicit conversion
+const native_handle_t *hidl_handle::getNativeHandle() const {
+    return mHandle;
+}
+
+void hidl_handle::freeHandle() {
+    if (mOwnsHandle && mHandle != nullptr) {
+        // This can only be true if:
+        // 1. Somebody called setTo() with shouldOwn=true, so we know the handle
+        //    wasn't const to begin with.
+        // 2. Copy/assignment from another hidl_handle, in which case we have
+        //    cloned the handle.
+        // 3. Move constructor from another hidl_handle, in which case the original
+        //    hidl_handle must have been non-const as well.
+        native_handle_t *handle = const_cast<native_handle_t*>(
+                static_cast<const native_handle_t*>(mHandle));
+        native_handle_close(handle);
+        native_handle_delete(handle);
+        mHandle = nullptr;
+    }
+}
+
+static const char *const kEmptyString = "";
+
+hidl_string::hidl_string()
+    : mBuffer(kEmptyString),
+      mSize(0),
+      mOwnsBuffer(false) {
+}
+
+hidl_string::~hidl_string() {
+    clear();
+}
+
+hidl_string::hidl_string(const char *s) : hidl_string() {
+    if (s == nullptr) {
+        return;
+    }
+
+    copyFrom(s, strlen(s));
+}
+
+hidl_string::hidl_string(const char *s, size_t length) : hidl_string() {
+    copyFrom(s, length);
+}
+
+hidl_string::hidl_string(const hidl_string &other): hidl_string() {
+    copyFrom(other.c_str(), other.size());
+}
+
+hidl_string::hidl_string(const std::string &s) : hidl_string() {
+    copyFrom(s.c_str(), s.size());
+}
+
+hidl_string::hidl_string(hidl_string &&other): hidl_string() {
+    moveFrom(std::forward<hidl_string>(other));
+}
+
+hidl_string &hidl_string::operator=(hidl_string &&other) {
+    if (this != &other) {
+        clear();
+        moveFrom(std::forward<hidl_string>(other));
+    }
+    return *this;
+}
+
+hidl_string &hidl_string::operator=(const hidl_string &other) {
+    if (this != &other) {
+        clear();
+        copyFrom(other.c_str(), other.size());
+    }
+
+    return *this;
+}
+
+hidl_string &hidl_string::operator=(const char *s) {
+    clear();
+
+    if (s == nullptr) {
+        return *this;
+    }
+
+    copyFrom(s, strlen(s));
+    return *this;
+}
+
+hidl_string &hidl_string::operator=(const std::string &s) {
+    clear();
+    copyFrom(s.c_str(), s.size());
+    return *this;
+}
+
+hidl_string::operator std::string() const {
+    return std::string(mBuffer, mSize);
+}
+
+std::ostream& operator<<(std::ostream& os, const hidl_string& str) {
+    os << str.c_str();
+    return os;
+}
+
+void hidl_string::copyFrom(const char *data, size_t size) {
+    // assume my resources are freed.
+
+    if (size > UINT32_MAX) {
+        LOG(FATAL) << "string size can't exceed 2^32 bytes: " << size;
+    }
+    char *buf = (char *)malloc(size + 1);
+    memcpy(buf, data, size);
+    buf[size] = '\0';
+    mBuffer = buf;
+
+    mSize = static_cast<uint32_t>(size);
+    mOwnsBuffer = true;
+}
+
+void hidl_string::moveFrom(hidl_string &&other) {
+    // assume my resources are freed.
+
+    mBuffer = std::move(other.mBuffer);
+    mSize = other.mSize;
+    mOwnsBuffer = other.mOwnsBuffer;
+
+    other.mOwnsBuffer = false;
+    other.clear();
+}
+
+void hidl_string::clear() {
+    if (mOwnsBuffer && (mBuffer != kEmptyString)) {
+        free(const_cast<char *>(static_cast<const char *>(mBuffer)));
+    }
+
+    mBuffer = kEmptyString;
+    mSize = 0;
+    mOwnsBuffer = false;
+}
+
+void hidl_string::setToExternal(const char *data, size_t size) {
+    if (size > UINT32_MAX) {
+        LOG(FATAL) << "string size can't exceed 2^32 bytes: " << size;
+    }
+    clear();
+
+    mBuffer = data;
+    mSize = static_cast<uint32_t>(size);
+    mOwnsBuffer = false;
+}
+
+const char *hidl_string::c_str() const {
+    return mBuffer;
+}
+
+size_t hidl_string::size() const {
+    return mSize;
+}
+
+bool hidl_string::empty() const {
+    return mSize == 0;
+}
+
+}  // namespace hardware
+}  // namespace android
+
+