| /* |
| * Copyright (C) 2008 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. |
| */ |
| |
| /* |
| * Implementation of the user-space ashmem API for devices, which have our |
| * ashmem-enabled kernel. See ashmem-sim.c for the "fake" tmp-based version, |
| * used by the simulator. |
| */ |
| |
| #include "IPCResult.h" |
| #include <cstdlib> |
| |
| namespace { |
| class VoidResult : public IPCResult { |
| public: |
| const void* getData() override; |
| IPCType getType() override; |
| const uint16_t* getStringContent() override; |
| size_t getStringLength() override; |
| const char* getByteArrayContent() override; |
| size_t getByteArrayLength() override; |
| }; |
| |
| template <typename T> |
| struct TypeTrait { |
| }; |
| |
| template <> |
| struct TypeTrait<int32_t> { |
| static const IPCType s_type = IPCType::INT32; |
| }; |
| |
| template <> |
| struct TypeTrait<double> { |
| static const IPCType s_type = IPCType::DOUBLE; |
| }; |
| |
| template <typename T> |
| class ValueResult : public IPCResult { |
| public: |
| explicit ValueResult(T val); |
| const void* getData() override; |
| IPCType getType() override; |
| const uint16_t* getStringContent() override; |
| size_t getStringLength() override; |
| const char* getByteArrayContent() override; |
| size_t getByteArrayLength() override; |
| |
| private: |
| typedef T value_type; |
| typedef TypeTrait<value_type> trait_type; |
| |
| value_type m_value; |
| static const IPCType s_type = trait_type::s_type; |
| }; |
| |
| class StringResult : public IPCResult { |
| public: |
| StringResult(JNIEnv* env, jstring val); |
| ~StringResult(); |
| |
| const void* getData() override; |
| IPCType getType() override; |
| const uint16_t* getStringContent() override; |
| size_t getStringLength() override; |
| const char* getByteArrayContent() override; |
| size_t getByteArrayLength() override; |
| void setJSON(); |
| |
| private: |
| JNIEnv* m_env; |
| jstring m_value; |
| const jchar* m_cvalue{ nullptr }; |
| size_t m_length{ 0U }; |
| bool m_isJSON{ false }; |
| }; |
| |
| |
| class ByteArrayResult: public IPCResult{ |
| public: |
| ByteArrayResult(const char* data, size_t length); |
| ~ByteArrayResult(); |
| |
| const void* getData() override; |
| IPCType getType() override; |
| const uint16_t* getStringContent() override; |
| size_t getStringLength() override; |
| const char* getByteArrayContent() override; |
| size_t getByteArrayLength() override; |
| private: |
| char* m_data; |
| size_t m_length; |
| }; |
| |
| const void* |
| VoidResult::getData() |
| { |
| return nullptr; |
| } |
| |
| IPCType VoidResult::getType() |
| { |
| return IPCType::VOID; |
| } |
| |
| const uint16_t* VoidResult::getStringContent() |
| { |
| return nullptr; |
| } |
| |
| size_t VoidResult::getStringLength() |
| { |
| return 0U; |
| } |
| |
| const char* VoidResult::getByteArrayContent() |
| { |
| return nullptr; |
| } |
| |
| size_t VoidResult::getByteArrayLength() |
| { |
| return 0U; |
| } |
| |
| template <typename T> |
| ValueResult<T>::ValueResult(T val) |
| : m_value(val) |
| { |
| } |
| |
| template <typename T> |
| const void* ValueResult<T>::getData() |
| { |
| return &m_value; |
| } |
| |
| template <typename T> |
| IPCType ValueResult<T>::getType() |
| { |
| return s_type; |
| } |
| |
| template <typename T> |
| const uint16_t* ValueResult<T>::getStringContent() |
| { |
| return nullptr; |
| } |
| |
| template <typename T> |
| size_t ValueResult<T>::getStringLength() |
| { |
| return 0U; |
| } |
| |
| template <typename T> |
| const char* ValueResult<T>::getByteArrayContent() |
| { |
| return nullptr; |
| } |
| |
| template <typename T> |
| size_t ValueResult<T>::getByteArrayLength() |
| { |
| return 0U; |
| } |
| |
| StringResult::StringResult(JNIEnv* env, jstring val) |
| : m_env(env) |
| , m_value(static_cast<jstring>(env->NewLocalRef(val))) |
| { |
| m_cvalue = env->GetStringChars(m_value, nullptr); |
| m_length = env->GetStringLength(m_value); |
| } |
| |
| StringResult::~StringResult() |
| { |
| if (m_cvalue) |
| m_env->ReleaseStringChars(m_value, m_cvalue); |
| m_env->DeleteLocalRef(m_value); |
| } |
| |
| const void* StringResult::getData() |
| { |
| return nullptr; |
| } |
| |
| IPCType StringResult::getType() |
| { |
| return m_isJSON ? IPCType::JSONSTRING : IPCType::STRING; |
| } |
| |
| const uint16_t* StringResult::getStringContent() |
| { |
| return m_cvalue; |
| } |
| |
| size_t StringResult::getStringLength() |
| { |
| return m_length; |
| } |
| |
| const char* StringResult::getByteArrayContent() |
| { |
| return nullptr; |
| } |
| |
| size_t StringResult::getByteArrayLength() |
| { |
| return 0U; |
| } |
| |
| void StringResult::setJSON() |
| { |
| m_isJSON = true; |
| } |
| |
| ByteArrayResult::ByteArrayResult(const char* data, size_t length):m_length(length) |
| { |
| if(length > 0){ |
| m_data = (char*)malloc(length*sizeof(char)); |
| memcpy(m_data, data, length); |
| }else{ |
| m_data = nullptr; |
| } |
| } |
| IPCType ByteArrayResult::getType() |
| { |
| return IPCType::BYTEARRAY; |
| } |
| |
| const void* ByteArrayResult::getData() |
| { |
| return nullptr; |
| } |
| |
| const uint16_t* ByteArrayResult::getStringContent(){ |
| return nullptr; |
| } |
| |
| size_t ByteArrayResult::getStringLength(){ |
| return 0l; |
| } |
| |
| const char* ByteArrayResult::getByteArrayContent(){ |
| return m_data; |
| } |
| |
| size_t ByteArrayResult::getByteArrayLength(){ |
| return m_length; |
| } |
| ByteArrayResult::~ByteArrayResult() |
| { |
| if (m_data){ |
| free(m_data); |
| m_data= NULL; |
| } |
| m_length = 0; |
| } |
| |
| } |
| |
| |
| |
| |
| std::unique_ptr<IPCResult> createVoidResult() |
| { |
| return std::unique_ptr<IPCResult>(new VoidResult); |
| } |
| |
| std::unique_ptr<IPCResult> createInt32Result(int32_t val) |
| { |
| return std::unique_ptr<IPCResult>(new ValueResult<int32_t>(val)); |
| } |
| |
| std::unique_ptr<IPCResult> createDoubleResult(double val) |
| { |
| return std::unique_ptr<IPCResult>(new ValueResult<double>(val)); |
| } |
| |
| std::unique_ptr<IPCResult> createStringResult(JNIEnv* env, jstring str) |
| { |
| return std::unique_ptr<IPCResult>(new StringResult(env, str)); |
| } |
| |
| std::unique_ptr<IPCResult> createJSONStringResult(JNIEnv* env, jstring str) |
| { |
| std::unique_ptr<StringResult> result(new StringResult(env, str)); |
| result->setJSON(); |
| return std::unique_ptr<IPCResult>(result.release()); |
| } |
| |
| std::unique_ptr<IPCResult> createByteArrayResult(const char* data, size_t length){ |
| return std::unique_ptr<IPCResult>(new ByteArrayResult(data, length)); |
| } |
| |
| class CharArrayResult : public IPCResult { |
| public: |
| CharArrayResult(char* chars); |
| // ByteArrayResult(const char* data); |
| ~CharArrayResult(); |
| |
| const void* getData() override; |
| IPCType getType() override; |
| const uint16_t* getStringContent() override; |
| size_t getStringLength() override; |
| const char* getByteArrayContent() override; |
| size_t getByteArrayLength() override; |
| |
| private: |
| char* m_char; |
| size_t m_length{ 0U }; |
| }; |
| |
| CharArrayResult::CharArrayResult(char* chars) |
| : m_char(chars) { |
| m_length = strlen(m_char); |
| } |
| |
| CharArrayResult::~CharArrayResult() { |
| delete[] m_char; |
| } |
| |
| const void* CharArrayResult::getData() |
| { |
| return m_char; |
| } |
| |
| IPCType CharArrayResult::getType() |
| { |
| return IPCType::CHARARRAY; |
| } |
| |
| const uint16_t* CharArrayResult::getStringContent() |
| { |
| return nullptr; |
| } |
| |
| size_t CharArrayResult::getStringLength() |
| { |
| return m_length; |
| } |
| |
| const char* CharArrayResult::getByteArrayContent() { |
| return nullptr; |
| } |
| |
| size_t CharArrayResult::getByteArrayLength() { |
| |
| return 0U; |
| } |
| |
| std::unique_ptr<IPCResult> createCharArrayResult(char* bytes) { |
| return std::unique_ptr<IPCResult>(new CharArrayResult(bytes)); |
| } |