From 6cf95f371084d2d93d850f95e1739d7680adc6b0 Mon Sep 17 00:00:00 2001 From: Hridya Valsaraju Date: Wed, 22 Feb 2017 10:51:01 -0800 Subject: [PATCH] Move baz default implementation to hardware/interfaces Test: hidl_test and hidl_java_test passes Change-Id: Iaacfc3f203368ca674cbaddc6cdf06ddb8e34500 --- tests/Android.bp | 1 + tests/baz/1.0/default/Android.bp | 16 + tests/baz/1.0/default/Baz.cpp | 519 +++++++++++++++++++++++++++++++ tests/baz/1.0/default/Baz.h | 92 ++++++ 4 files changed, 628 insertions(+) create mode 100644 tests/baz/1.0/default/Android.bp create mode 100644 tests/baz/1.0/default/Baz.cpp create mode 100644 tests/baz/1.0/default/Baz.h diff --git a/tests/Android.bp b/tests/Android.bp index 337e4f4b46..41043d9e95 100644 --- a/tests/Android.bp +++ b/tests/Android.bp @@ -3,6 +3,7 @@ subdirs = [ "bar/1.0", "bar/1.0/default", "baz/1.0", + "baz/1.0/default", "expression/1.0", "foo/1.0", "foo/1.0/default", diff --git a/tests/baz/1.0/default/Android.bp b/tests/baz/1.0/default/Android.bp new file mode 100644 index 0000000000..e160d8aa82 --- /dev/null +++ b/tests/baz/1.0/default/Android.bp @@ -0,0 +1,16 @@ +cc_library_shared { + name: "android.hardware.tests.baz@1.0-impl", + relative_install_path: "hw", + proprietary: true, + srcs: [ + "Baz.cpp", + ], + shared_libs: [ + "libbase", + "libhidlbase", + "libhidltransport", + "libutils", + "android.hardware.tests.baz@1.0", + "android.hidl.base@1.0", + ], +} diff --git a/tests/baz/1.0/default/Baz.cpp b/tests/baz/1.0/default/Baz.cpp new file mode 100644 index 0000000000..8e57fa06da --- /dev/null +++ b/tests/baz/1.0/default/Baz.cpp @@ -0,0 +1,519 @@ +#include "Baz.h" +#include + +namespace android { +namespace hardware { +namespace tests { +namespace baz { +namespace V1_0 { +namespace implementation { + +struct BazCallback : public IBazCallback { + Return heyItsMe(const sp &cb) override; + Return hey() override; +}; + +Return BazCallback::heyItsMe( + const sp &cb) { + LOG(INFO) << "SERVER: heyItsMe cb = " << cb.get(); + + return Void(); +} + +Return BazCallback::hey() { + LOG(INFO) << "SERVER: hey"; + + return Void(); +} + +// TODO(b/35703683) : replace usage of below methods with toString() + +static std::string to_string(const IBaz::Foo::Bar &bar); +static std::string to_string(const IBaz::Foo &foo); +static std::string to_string(const hidl_string &s); +static std::string to_string(bool x); +static std::string to_string(const IBaz::StringMatrix5x3 &M); +static std::string to_string(const IBaz::StringMatrix3x5 &M); + +template +static std::string to_string(const hidl_array &array); + +template +static std::string to_string(const hidl_array &array); + +template +static std::string to_string(const hidl_vec &vec) { + std::string out; + out = "["; + for (size_t i = 0; i < vec.size(); ++i) { + if (i > 0) { + out += ", "; + } + out += to_string(vec[i]); + } + out += "]"; + + return out; +} + +template +static std::string to_string(const hidl_array &array) { + std::string out; + out = "["; + for (size_t i = 0; i < SIZE; ++i) { + if (i > 0) { + out += ", "; + } + out += to_string(array[i]); + } + out += "]"; + + return out; +} + +template +static std::string to_string(const hidl_array &array) { + std::string out; + for (size_t i = 0; i < SIZE; ++i) { + if (i > 0) { + out += ":"; + } + + char tmp[3]; + sprintf(tmp, "%02x", array[i]); + + out += tmp; + } + + return out; +} + +template +static std::string to_string(const hidl_array &array) { + std::string out; + out = "["; + for (size_t i = 0; i < SIZE1; ++i) { + if (i > 0) { + out += ", "; + } + + out += "["; + for (size_t j = 0; j < SIZE2; ++j) { + if (j > 0) { + out += ", "; + } + + out += to_string(array[i][j]); + } + out += "]"; + } + out += "]"; + + return out; +} + +static std::string to_string(bool x) { + return x ? "true" : "false"; +} + +static std::string to_string(const hidl_string &s) { + return std::string("'") + s.c_str() + "'"; +} + +static std::string to_string(const IBaz::Foo::Bar &bar) { + std::string out; + out = "Bar("; + out += "z = " + to_string(bar.z) + ", "; + out += "s = '" + std::string(bar.s.c_str()) + "'"; + out += ")"; + + return out; +} + +static std::string to_string(const IBaz::Foo &foo) { + std::string out; + out = "Foo("; + out += "x = " + to_string(foo.x) + ", "; + out += "y = " + to_string(foo.y) + ", "; + out += "aaa = " + to_string(foo.aaa); + out += ")"; + + return out; +} + +static std::string to_string(const IBaz::StringMatrix5x3 &M) { + return to_string(M.s); +} + +static std::string to_string(const IBaz::StringMatrix3x5 &M) { + return to_string(M.s); +} + +static std::string VectorOfArray_to_string(const IBaz::VectorOfArray &in) { + std::string out; + out += "VectorOfArray("; + + for (size_t i = 0; i < in.addresses.size(); ++i) { + if (i > 0) { + out += ", "; + } + + for (size_t j = 0; j < 6; ++j) { + if (j > 0) { + out += ":"; + } + + char tmp[3]; + sprintf(tmp, "%02x", in.addresses[i][j]); + + out += tmp; + } + } + + out += ")"; + + return out; +} + +// Methods from ::android::hardware::tests::baz::V1_0::IBase follow. +Return Baz::someBaseMethod() { + LOG(INFO) << "Baz::someBaseMethod"; + + return Void(); +} + +Return Baz::someBoolMethod(bool x) { + LOG(INFO) << "Baz::someBoolMethod(" << to_string(x) << ")"; + + return !x; +} + +Return Baz::someBoolArrayMethod(const hidl_array& x, + someBoolArrayMethod_cb _hidl_cb) { + LOG(INFO) << "Baz::someBoolArrayMethod(" + << to_string(x[0]) + << ", " + << to_string(x[1]) + << ", " + << to_string(x[2]) + << ")"; + + hidl_array out; + out[0] = !x[0]; + out[1] = !x[1]; + out[2] = !x[2]; + out[3] = true; + + _hidl_cb(out); + + return Void(); +} + +Return Baz::someBoolVectorMethod(const hidl_vec& x, someBoolVectorMethod_cb _hidl_cb) { + LOG(INFO) << "Baz::someBoolVectorMethod(" << to_string(x) << ")"; + + hidl_vec out; + out.resize(x.size()); + for (size_t i = 0; i < x.size(); ++i) { + out[i] = !x[i]; + } + + _hidl_cb(out); + + return Void(); +} + +Return Baz::someOtherBaseMethod(const IBase::Foo& foo, someOtherBaseMethod_cb _hidl_cb) { + LOG(INFO) << "Baz::someOtherBaseMethod " + << to_string(foo); + + _hidl_cb(foo); + + return Void(); +} + +Return Baz::someMethodWithFooArrays(const hidl_array& fooInput, + someMethodWithFooArrays_cb _hidl_cb) { + LOG(INFO) << "Baz::someMethodWithFooArrays " + << to_string(fooInput); + + hidl_array fooOutput; + fooOutput[0] = fooInput[1]; + fooOutput[1] = fooInput[0]; + + _hidl_cb(fooOutput); + + return Void(); +} + +Return Baz::someMethodWithFooVectors(const hidl_vec& fooInput, + someMethodWithFooVectors_cb _hidl_cb) { + LOG(INFO) << "Baz::someMethodWithFooVectors " + << to_string(fooInput); + + hidl_vec fooOutput; + fooOutput.resize(2); + fooOutput[0] = fooInput[1]; + fooOutput[1] = fooInput[0]; + + _hidl_cb(fooOutput); + + return Void(); +} + +Return Baz::someMethodWithVectorOfArray(const IBase::VectorOfArray& in, + someMethodWithVectorOfArray_cb _hidl_cb) { + LOG(INFO) << "Baz::someMethodWithVectorOfArray " + << VectorOfArray_to_string(in); + + IBase::VectorOfArray out; + + const size_t n = in.addresses.size(); + out.addresses.resize(n); + + for (size_t i = 0; i < n; ++i) { + out.addresses[i] = in.addresses[n - 1 - i]; + } + + _hidl_cb(out); + + return Void(); +} + +Return Baz::someMethodTakingAVectorOfArray(const hidl_vec>& in, + someMethodTakingAVectorOfArray_cb _hidl_cb) { + LOG(INFO) << "Baz::someMethodTakingAVectorOfArray " + << to_string(in); + + const size_t n = in.size(); + + hidl_vec > out; + out.resize(n); + + for (size_t i = 0; i < n; ++i) { + out[i] = in[n - 1 - i]; + } + + _hidl_cb(out); + + return Void(); +} + +Return Baz::transpose(const IBase::StringMatrix5x3& in, transpose_cb _hidl_cb) { + LOG(INFO) << "Baz::transpose " << to_string(in); + + IBase::StringMatrix3x5 out; + for (size_t i = 0; i < 3; ++i) { + for (size_t j = 0; j < 5; ++j) { + out.s[i][j] = in.s[j][i]; + } + } + + _hidl_cb(out); + + return Void(); +} + +Return Baz::transpose2(const hidl_array& in, transpose2_cb _hidl_cb) { + LOG(INFO) << "Baz::transpose2 " << to_string(in); + + hidl_array out; + for (size_t i = 0; i < 3; ++i) { + for (size_t j = 0; j < 5; ++j) { + out[i][j] = in[j][i]; + } + } + + _hidl_cb(out); + + return Void(); +} + +Return Baz::takeAMask(IBase::BitField bf, + uint8_t first, + const IBase::MyMask& second, + uint8_t third, + takeAMask_cb _hidl_cb) { + _hidl_cb(bf, bf | first, second.value & bf, (bf | bf) & third); + return Void(); +} + +// Methods from ::android::hardware::tests::baz::V1_0::IBaz follow. + +Return Baz::doThis(float param) { + LOG(INFO) << "Baz::doThis(" << param << ")"; + + return Void(); +} + +Return Baz::doThatAndReturnSomething(int64_t param) { + LOG(INFO) << "Baz::doThatAndReturnSomething(" << param << ")"; + + return 666; +} + +Return Baz::doQuiteABit(int32_t a, int64_t b, float c, double d) { + LOG(INFO) << "Baz::doQuiteABit(" + << a + << ", " + << b + << ", " + << c + << ", " + << d + << ")"; + + return 666.5; +} + +Return Baz::doSomethingElse(const hidl_array& param, + doSomethingElse_cb _hidl_cb) { + LOG(INFO) << "Baz::doSomethingElse(...)"; + + hidl_array result; + for (size_t i = 0; i < 15; ++i) { + result[i] = 2 * param[i]; + result[15 + i] = param[i]; + } + result[30] = 1; + result[31] = 2; + + _hidl_cb(result); + + return Void(); +} + +Return Baz::doStuffAndReturnAString(doStuffAndReturnAString_cb _hidl_cb) { + LOG(INFO) << "doStuffAndReturnAString"; + + hidl_string s; + s = "Hello, world!"; + + _hidl_cb(s); + + return Void(); +} + +Return Baz::mapThisVector(const hidl_vec& param, mapThisVector_cb _hidl_cb) { + LOG(INFO) << "mapThisVector"; + + hidl_vec out; + out.resize(param.size()); + for (size_t i = 0; i < param.size(); ++i) { + out[i] = param[i] * 2; + } + + _hidl_cb(out); + + return Void(); +} + +Return Baz::callMe(const sp& cb) { + LOG(INFO) << "callMe " << cb.get(); + + if (cb != NULL) { + sp my_cb = new BazCallback; + cb->heyItsMe(my_cb); + } + + return Void(); +} + +Return Baz::callMeLater(const sp& cb) { + LOG(INFO) << "callMeLater " << cb.get(); + + mStoredCallback = cb; + + return Void(); +} + +Return Baz::iAmFreeNow() { + if (mStoredCallback != nullptr) { + mStoredCallback->hey(); + } + return Void(); +} + +Return Baz::dieNow() { + exit(1); + return Void(); +} + +Return Baz::useAnEnum(IBaz::SomeEnum zzz) { + LOG(INFO) << "useAnEnum " << (int)zzz; + + return SomeEnum::goober; +} + +Return Baz::haveSomeStrings(const hidl_array& array, + haveSomeStrings_cb _hidl_cb) { + LOG(INFO) << "haveSomeStrings(" + << to_string(array) + << ")"; + + hidl_array result; + result[0] = "Hello"; + result[1] = "World"; + + _hidl_cb(result); + + return Void(); +} + +Return Baz::haveAStringVec(const hidl_vec& vector, + haveAStringVec_cb _hidl_cb) { + LOG(INFO) << "haveAStringVec(" << to_string(vector) << ")"; + + hidl_vec result; + result.resize(2); + + result[0] = "Hello"; + result[1] = "World"; + + _hidl_cb(result); + + return Void(); +} + +Return Baz::returnABunchOfStrings(returnABunchOfStrings_cb _hidl_cb) { + hidl_string eins; eins = "Eins"; + hidl_string zwei; zwei = "Zwei"; + hidl_string drei; drei = "Drei"; + _hidl_cb(eins, zwei, drei); + + return Void(); +} + +Return Baz::returnABitField() { + return 0; +} + +Return Baz::size(uint32_t size) { + return size; +} + +Return Baz::getNestedStructs(getNestedStructs_cb _hidl_cb) { + int size = 5; + hidl_vec result; + result.resize(size); + for (int i = 0; i < size; i++) { + result[i].a = i; + if (i == 1) { + result[i].matrices.resize(6); + } + } + _hidl_cb(result); + return Void(); +} +// Methods from ::android::hidl::base::V1_0::IBase follow. + +IBaz* HIDL_FETCH_IBaz(const char* /* name */) { + return new Baz(); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace baz +} // namespace tests +} // namespace hardware +} // namespace android diff --git a/tests/baz/1.0/default/Baz.h b/tests/baz/1.0/default/Baz.h new file mode 100644 index 0000000000..ceb3035ca0 --- /dev/null +++ b/tests/baz/1.0/default/Baz.h @@ -0,0 +1,92 @@ +#ifndef ANDROID_HARDWARE_TESTS_BAZ_V1_0_BAZ_H +#define ANDROID_HARDWARE_TESTS_BAZ_V1_0_BAZ_H + +#include +#include +#include + +namespace android { +namespace hardware { +namespace tests { +namespace baz { +namespace V1_0 { +namespace implementation { + +// using ::android::hardware::tests::baz::V1_0::IBase; +using ::android::hardware::tests::baz::V1_0::IBaz; +using ::android::hardware::tests::baz::V1_0::IBazCallback; +using ::android::hidl::base::V1_0::DebugInfo; +using ::android::hidl::base::V1_0::IBase; +using ::android::hardware::hidl_array; +using ::android::hardware::hidl_memory; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::sp; + +struct Baz : public IBaz { + // Methods from ::android::hardware::tests::baz::V1_0::IBase follow. + Return someBaseMethod() override; + Return someBoolMethod(bool x) override; + Return someBoolArrayMethod(const hidl_array& x, + someBoolArrayMethod_cb _hidl_cb) override; + Return someBoolVectorMethod(const hidl_vec& x, + someBoolVectorMethod_cb _hidl_cb) override; + Return someOtherBaseMethod(const IBase::Foo& foo, + someOtherBaseMethod_cb _hidl_cb) override; + Return someMethodWithFooArrays(const hidl_array& fooInput, + someMethodWithFooArrays_cb _hidl_cb) override; + Return someMethodWithFooVectors(const hidl_vec& fooInput, + someMethodWithFooVectors_cb _hidl_cb) override; + Return someMethodWithVectorOfArray(const IBase::VectorOfArray& in, + someMethodWithVectorOfArray_cb _hidl_cb) override; + Return someMethodTakingAVectorOfArray(const hidl_vec>& in, + someMethodTakingAVectorOfArray_cb _hidl_cb) override; + Return transpose(const IBase::StringMatrix5x3& in, + transpose_cb _hidl_cb) override; + Return transpose2(const hidl_array& in, + transpose2_cb _hidl_cb) override; + Return takeAMask(IBase::BitField bf, + uint8_t first, + const IBase::MyMask& second, + uint8_t third, + takeAMask_cb _hidl_cb) override; + + // Methods from ::android::hardware::tests::baz::V1_0::IBaz follow. + Return doThis(float param) override; + Return doThatAndReturnSomething(int64_t param) override; + Return doQuiteABit(int32_t a, int64_t b, float c, double d) override; + Return doSomethingElse(const hidl_array& param, + doSomethingElse_cb _hidl_cb) override; + Return doStuffAndReturnAString(doStuffAndReturnAString_cb _hidl_cb) override; + Return mapThisVector(const hidl_vec& param, mapThisVector_cb _hidl_cb) override; + Return callMe(const sp& cb) override; + Return callMeLater(const sp& cb) override; + Return iAmFreeNow() override; + Return dieNow() override; + Return useAnEnum(IBaz::SomeEnum zzz) override; + Return haveSomeStrings(const hidl_array& array, + haveSomeStrings_cb _hidl_cb) override; + Return haveAStringVec(const hidl_vec& vector, + haveAStringVec_cb _hidl_cb) override; + Return returnABunchOfStrings(returnABunchOfStrings_cb _hidl_cb) override; + Return returnABitField() override; + Return size(uint32_t size) override; + Return getNestedStructs(getNestedStructs_cb _hidl_cb) override; + + // Methods from ::android::hidl::base::V1_0::IBase follow. + private: + sp mStoredCallback; +}; + +extern "C" IBaz* HIDL_FETCH_IBaz(const char* name); + +} // namespace implementation +} // namespace V1_0 +} // namespace baz +} // namespace tests +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_TESTS_BAZ_V1_0_BAZ_H