1
2#define LOG_TAG "hidl_test"
3
4#include "Bar.h"
5
6#include <inttypes.h>
7
8#include <log/log.h>
9
10namespace android {
11namespace hardware {
12namespace tests {
13namespace bar {
14namespace V1_0 {
15namespace implementation {
16
17Bar::Bar() {
18    mFoo = IFoo::getService("", true);
19}
20
21// Methods from ::android::hardware::tests::foo::V1_0::IFoo follow.
22Return<void> Bar::convertToBoolIfSmall(Discriminator d, const hidl_vec<Union>& u,
23                                       convertToBoolIfSmall_cb _hidl_cb) {
24    return mFoo->convertToBoolIfSmall(d, u, _hidl_cb);
25}
26
27Return<void> Bar::doThis(float param) {
28    return mFoo->doThis(param);
29}
30
31Return<int32_t> Bar::doThatAndReturnSomething(
32        int64_t param) {
33    return mFoo->doThatAndReturnSomething(param);
34}
35
36Return<double> Bar::doQuiteABit(
37        int32_t a,
38        int64_t b,
39        float c,
40        double d) {
41    return mFoo->doQuiteABit(a, b, c, d);
42}
43
44Return<void> Bar::doSomethingElse(
45        const hidl_array<int32_t, 15> &param, doSomethingElse_cb _cb) {
46    return mFoo->doSomethingElse(param, _cb);
47}
48
49Return<void> Bar::doStuffAndReturnAString(
50        doStuffAndReturnAString_cb _cb) {
51    return mFoo->doStuffAndReturnAString(_cb);
52}
53
54Return<void> Bar::mapThisVector(
55        const hidl_vec<int32_t> &param, mapThisVector_cb _cb) {
56    return mFoo->mapThisVector(param, _cb);
57}
58
59Return<void> Bar::callMe(
60        const sp<IFooCallback> &cb) {
61    return mFoo->callMe(cb);
62}
63
64Return<Bar::SomeEnum> Bar::useAnEnum(SomeEnum param) {
65    return mFoo->useAnEnum(param);
66}
67
68Return<void> Bar::haveAGooberVec(const hidl_vec<Goober>& param) {
69    return mFoo->haveAGooberVec(param);
70}
71
72Return<void> Bar::haveAGoober(const Goober &g) {
73    return mFoo->haveAGoober(g);
74}
75
76Return<void> Bar::haveAGooberArray(const hidl_array<Goober, 20> &lots) {
77    return mFoo->haveAGooberArray(lots);
78}
79
80Return<void> Bar::haveATypeFromAnotherFile(const Abc &def) {
81    return mFoo->haveATypeFromAnotherFile(def);
82}
83
84Return<void> Bar::haveSomeStrings(
85        const hidl_array<hidl_string, 3> &array,
86        haveSomeStrings_cb _cb) {
87    return mFoo->haveSomeStrings(array, _cb);
88}
89
90Return<void> Bar::haveAStringVec(
91        const hidl_vec<hidl_string> &vector,
92        haveAStringVec_cb _cb) {
93    return mFoo->haveAStringVec(vector, _cb);
94}
95
96Return<void> Bar::transposeMe(
97        const hidl_array<float, 3, 5> &in, transposeMe_cb _cb) {
98    return mFoo->transposeMe(in, _cb);
99}
100
101Return<void> Bar::callingDrWho(
102        const MultiDimensional &in, callingDrWho_cb _hidl_cb) {
103    return mFoo->callingDrWho(in, _hidl_cb);
104}
105
106Return<void> Bar::transpose(const StringMatrix5x3 &in, transpose_cb _hidl_cb) {
107    return mFoo->transpose(in, _hidl_cb);
108}
109
110Return<void> Bar::transpose2(
111        const hidl_array<hidl_string, 5, 3> &in, transpose2_cb _hidl_cb) {
112    return mFoo->transpose2(in, _hidl_cb);
113}
114
115Return<void> Bar::sendVec(
116        const hidl_vec<uint8_t> &data, sendVec_cb _hidl_cb) {
117    return mFoo->sendVec(data, _hidl_cb);
118}
119
120Return<void> Bar::sendVecVec(sendVecVec_cb _hidl_cb) {
121    return mFoo->sendVecVec(_hidl_cb);
122}
123
124Return<void> Bar::haveAVectorOfInterfaces(
125        const hidl_vec<sp<ISimple> > &in,
126        haveAVectorOfInterfaces_cb _hidl_cb) {
127    _hidl_cb(in);
128
129    return Void();
130}
131
132Return<void> Bar::haveAVectorOfGenericInterfaces(
133        const hidl_vec<sp<android::hidl::base::V1_0::IBase> > &in,
134        haveAVectorOfGenericInterfaces_cb _hidl_cb) {
135    _hidl_cb(in);
136
137    return Void();
138}
139
140Return<void> Bar::createMyHandle(createMyHandle_cb _hidl_cb) {
141    return mFoo->createMyHandle(_hidl_cb);
142}
143
144Return<void> Bar::createHandles(uint32_t size, createHandles_cb _hidl_cb) {
145    return mFoo->createHandles(size, _hidl_cb);
146}
147
148Return<void> Bar::closeHandles() {
149    return mFoo->closeHandles();
150}
151
152Return<void> Bar::echoNullInterface(const sp<IFooCallback> &cb, echoNullInterface_cb _hidl_cb) {
153    return mFoo->echoNullInterface(cb, _hidl_cb);
154}
155
156// Methods from ::android::hardware::tests::bar::V1_0::IBar follow.
157Return<void> Bar::thisIsNew()  {
158    ALOGI("SERVER(Bar) thisIsNew");
159
160    return Void();
161}
162
163Return<void> Bar::expectNullHandle(const hidl_handle& h, const Abc& xyz, expectNullHandle_cb _hidl_cb) {
164    ALOGI("SERVER(Bar) h = %p, xyz.z = %p", h.getNativeHandle(), xyz.z.getNativeHandle());
165    _hidl_cb(h == nullptr, xyz.z == nullptr);
166    return Void();
167}
168
169Return<void> Bar::takeAMask(BitField bf, uint8_t first, const MyMask& second, uint8_t third,
170            takeAMask_cb _hidl_cb) {
171    _hidl_cb(bf, bf | first, second.value & bf, (bf | bf) & third);
172    return Void();
173}
174
175Return<sp<ISimple>> Bar::haveAInterface(const sp<ISimple> &in) {
176    return in;
177}
178
179
180IBar* HIDL_FETCH_IBar(const char* /* name */) {
181    return new Bar();
182}
183
184} // namespace implementation
185}  // namespace V1_0
186}  // namespace bar
187}  // namespace tests
188}  // namespace hardware
189}  // namespace android
190