1/* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "Baz.h" 18#include <android-base/logging.h> 19 20namespace android { 21namespace hardware { 22namespace tests { 23namespace baz { 24namespace V1_0 { 25namespace implementation { 26 27struct BazCallback : public IBazCallback { 28 Return<void> heyItsMe(const sp<IBazCallback> &cb) override; 29 Return<void> hey() override; 30}; 31 32Return<void> BazCallback::heyItsMe( 33 const sp<IBazCallback> &cb) { 34 LOG(INFO) << "SERVER: heyItsMe cb = " << cb.get(); 35 36 return Void(); 37} 38 39Return<void> BazCallback::hey() { 40 LOG(INFO) << "SERVER: hey"; 41 42 return Void(); 43} 44 45// Methods from ::android::hardware::tests::baz::V1_0::IBase follow. 46Return<void> Baz::someBaseMethod() { 47 LOG(INFO) << "Baz::someBaseMethod"; 48 49 return Void(); 50} 51 52Return<bool> Baz::someBoolMethod(bool x) { 53 LOG(INFO) << "Baz::someBoolMethod(" << std::to_string(x) << ")"; 54 55 return !x; 56} 57 58Return<void> Baz::someBoolArrayMethod(const hidl_array<bool, 3>& x, 59 someBoolArrayMethod_cb _hidl_cb) { 60 LOG(INFO) << "Baz::someBoolArrayMethod(" << toString(x) << ")"; 61 62 hidl_array<bool, 4> out; 63 out[0] = !x[0]; 64 out[1] = !x[1]; 65 out[2] = !x[2]; 66 out[3] = true; 67 68 _hidl_cb(out); 69 70 return Void(); 71} 72 73Return<void> Baz::someBoolVectorMethod(const hidl_vec<bool>& x, someBoolVectorMethod_cb _hidl_cb) { 74 LOG(INFO) << "Baz::someBoolVectorMethod(" << toString(x) << ")"; 75 76 hidl_vec<bool> out; 77 out.resize(x.size()); 78 for (size_t i = 0; i < x.size(); ++i) { 79 out[i] = !x[i]; 80 } 81 82 _hidl_cb(out); 83 84 return Void(); 85} 86 87Return<void> Baz::someOtherBaseMethod(const IBase::Foo& foo, someOtherBaseMethod_cb _hidl_cb) { 88 LOG(INFO) << "Baz::someOtherBaseMethod " 89 << toString(foo); 90 91 _hidl_cb(foo); 92 93 return Void(); 94} 95 96Return<void> Baz::someMethodWithFooArrays(const hidl_array<IBase::Foo, 2>& fooInput, 97 someMethodWithFooArrays_cb _hidl_cb) { 98 LOG(INFO) << "Baz::someMethodWithFooArrays " 99 << toString(fooInput); 100 101 hidl_array<IBaz::Foo, 2> fooOutput; 102 fooOutput[0] = fooInput[1]; 103 fooOutput[1] = fooInput[0]; 104 105 _hidl_cb(fooOutput); 106 107 return Void(); 108} 109 110Return<void> Baz::someMethodWithFooVectors(const hidl_vec<IBase::Foo>& fooInput, 111 someMethodWithFooVectors_cb _hidl_cb) { 112 LOG(INFO) << "Baz::someMethodWithFooVectors " 113 << toString(fooInput); 114 115 hidl_vec<IBaz::Foo> fooOutput; 116 fooOutput.resize(2); 117 fooOutput[0] = fooInput[1]; 118 fooOutput[1] = fooInput[0]; 119 120 _hidl_cb(fooOutput); 121 122 return Void(); 123} 124 125Return<void> Baz::someMethodWithVectorOfArray(const IBase::VectorOfArray& in, 126 someMethodWithVectorOfArray_cb _hidl_cb) { 127 LOG(INFO) << "Baz::someMethodWithVectorOfArray " 128 << toString(in); 129 130 IBase::VectorOfArray out; 131 132 const size_t n = in.addresses.size(); 133 out.addresses.resize(n); 134 135 for (size_t i = 0; i < n; ++i) { 136 out.addresses[i] = in.addresses[n - 1 - i]; 137 } 138 139 _hidl_cb(out); 140 141 return Void(); 142} 143 144Return<void> Baz::someMethodTakingAVectorOfArray(const hidl_vec<hidl_array<uint8_t, 6>>& in, 145 someMethodTakingAVectorOfArray_cb _hidl_cb) { 146 LOG(INFO) << "Baz::someMethodTakingAVectorOfArray " 147 << toString(in); 148 149 const size_t n = in.size(); 150 151 hidl_vec<hidl_array<uint8_t, 6> > out; 152 out.resize(n); 153 154 for (size_t i = 0; i < n; ++i) { 155 out[i] = in[n - 1 - i]; 156 } 157 158 _hidl_cb(out); 159 160 return Void(); 161} 162 163Return<void> Baz::transpose(const IBase::StringMatrix5x3& in, transpose_cb _hidl_cb) { 164 LOG(INFO) << "Baz::transpose " << toString(in); 165 166 IBase::StringMatrix3x5 out; 167 for (size_t i = 0; i < 3; ++i) { 168 for (size_t j = 0; j < 5; ++j) { 169 out.s[i][j] = in.s[j][i]; 170 } 171 } 172 173 _hidl_cb(out); 174 175 return Void(); 176} 177 178Return<void> Baz::transpose2(const hidl_array<hidl_string, 5, 3>& in, transpose2_cb _hidl_cb) { 179 LOG(INFO) << "Baz::transpose2 " << toString(in); 180 181 hidl_array<hidl_string, 3, 5> out; 182 for (size_t i = 0; i < 3; ++i) { 183 for (size_t j = 0; j < 5; ++j) { 184 out[i][j] = in[j][i]; 185 } 186 } 187 188 _hidl_cb(out); 189 190 return Void(); 191} 192 193Return<void> Baz::takeAMask(IBase::BitField bf, 194 uint8_t first, 195 const IBase::MyMask& second, 196 uint8_t third, 197 takeAMask_cb _hidl_cb) { 198 _hidl_cb(bf, bf | first, second.value & bf, (bf | bf) & third); 199 return Void(); 200} 201 202Return<void> Baz::testArrays( 203 const IBase::LotsOfPrimitiveArrays &in, 204 testArrays_cb _hidl_cb) { 205 _hidl_cb(in); 206 return Void(); 207} 208 209Return<void> Baz::testByteVecs( 210 const hidl_vec<IBase::ByteOneDim> &in, 211 testByteVecs_cb _hidl_cb) { 212 _hidl_cb(in); 213 return Void(); 214} 215 216Return<void> Baz::testBooleanVecs( 217 const hidl_vec<IBase::BooleanOneDim> &in, 218 testBooleanVecs_cb _hidl_cb) { 219 _hidl_cb(in); 220 return Void(); 221} 222 223Return<void> Baz::testDoubleVecs( 224 const hidl_vec<IBase::DoubleOneDim> &in, 225 testDoubleVecs_cb _hidl_cb) { 226 _hidl_cb(in); 227 return Void(); 228} 229 230// Methods from ::android::hardware::tests::baz::V1_0::IBaz follow. 231 232Return<void> Baz::doThis(float param) { 233 LOG(INFO) << "Baz::doThis(" << param << ")"; 234 235 return Void(); 236} 237 238Return<int32_t> Baz::doThatAndReturnSomething(int64_t param) { 239 LOG(INFO) << "Baz::doThatAndReturnSomething(" << param << ")"; 240 241 return 666; 242} 243 244Return<double> Baz::doQuiteABit(int32_t a, int64_t b, float c, double d) { 245 LOG(INFO) << "Baz::doQuiteABit(" 246 << a 247 << ", " 248 << b 249 << ", " 250 << c 251 << ", " 252 << d 253 << ")"; 254 255 return 666.5; 256} 257 258Return<void> Baz::doSomethingElse(const hidl_array<int32_t, 15>& param, 259 doSomethingElse_cb _hidl_cb) { 260 LOG(INFO) << "Baz::doSomethingElse(...)"; 261 262 hidl_array<int32_t, 32> result; 263 for (size_t i = 0; i < 15; ++i) { 264 result[i] = 2 * param[i]; 265 result[15 + i] = param[i]; 266 } 267 result[30] = 1; 268 result[31] = 2; 269 270 _hidl_cb(result); 271 272 return Void(); 273} 274 275Return<void> Baz::doStuffAndReturnAString(doStuffAndReturnAString_cb _hidl_cb) { 276 LOG(INFO) << "doStuffAndReturnAString"; 277 278 hidl_string s; 279 s = "Hello, world!"; 280 281 _hidl_cb(s); 282 283 return Void(); 284} 285 286Return<void> Baz::mapThisVector(const hidl_vec<int32_t>& param, mapThisVector_cb _hidl_cb) { 287 LOG(INFO) << "mapThisVector"; 288 289 hidl_vec<int32_t> out; 290 out.resize(param.size()); 291 for (size_t i = 0; i < param.size(); ++i) { 292 out[i] = param[i] * 2; 293 } 294 295 _hidl_cb(out); 296 297 return Void(); 298} 299 300Return<void> Baz::callMe(const sp<IBazCallback>& cb) { 301 LOG(INFO) << "callMe " << cb.get(); 302 303 if (cb != NULL) { 304 sp<IBazCallback> my_cb = new BazCallback; 305 cb->heyItsMe(my_cb); 306 } 307 308 return Void(); 309} 310 311Return<void> Baz::callMeLater(const sp<IBazCallback>& cb) { 312 LOG(INFO) << "callMeLater " << cb.get(); 313 314 mStoredCallback = cb; 315 316 return Void(); 317} 318 319Return<void> Baz::iAmFreeNow() { 320 if (mStoredCallback != nullptr) { 321 mStoredCallback->hey(); 322 } 323 return Void(); 324} 325 326Return<void> Baz::dieNow() { 327 exit(1); 328 return Void(); 329} 330 331Return<IBaz::SomeEnum> Baz::useAnEnum(IBaz::SomeEnum zzz) { 332 LOG(INFO) << "useAnEnum " << (int)zzz; 333 334 return SomeEnum::goober; 335} 336 337Return<void> Baz::haveSomeStrings(const hidl_array<hidl_string, 3>& array, 338 haveSomeStrings_cb _hidl_cb) { 339 LOG(INFO) << "haveSomeStrings(" 340 << toString(array) 341 << ")"; 342 343 hidl_array<hidl_string, 2> result; 344 result[0] = "Hello"; 345 result[1] = "World"; 346 347 _hidl_cb(result); 348 349 return Void(); 350} 351 352Return<void> Baz::haveAStringVec(const hidl_vec<hidl_string>& vector, 353 haveAStringVec_cb _hidl_cb) { 354 LOG(INFO) << "haveAStringVec(" << toString(vector) << ")"; 355 356 hidl_vec<hidl_string> result; 357 result.resize(2); 358 359 result[0] = "Hello"; 360 result[1] = "World"; 361 362 _hidl_cb(result); 363 364 return Void(); 365} 366 367Return<void> Baz::returnABunchOfStrings(returnABunchOfStrings_cb _hidl_cb) { 368 hidl_string eins; eins = "Eins"; 369 hidl_string zwei; zwei = "Zwei"; 370 hidl_string drei; drei = "Drei"; 371 _hidl_cb(eins, zwei, drei); 372 373 return Void(); 374} 375 376Return<uint8_t> Baz::returnABitField() { 377 return 0; 378} 379 380Return<uint32_t> Baz::size(uint32_t size) { 381 return size; 382} 383 384Return<void> Baz::getNestedStructs(getNestedStructs_cb _hidl_cb) { 385 int size = 5; 386 hidl_vec<IBaz::NestedStruct> result; 387 result.resize(size); 388 for (int i = 0; i < size; i++) { 389 result[i].a = i; 390 if (i == 1) { 391 result[i].matrices.resize(6); 392 } 393 } 394 _hidl_cb(result); 395 return Void(); 396} 397 398Return<void> Baz::haveSomeStructWithInterface(const StructWithInterface& swi, 399 haveSomeStructWithInterface_cb _hidl_cb) { 400 _hidl_cb(swi); 401 return Void(); 402} 403// Methods from ::android::hidl::base::V1_0::IBase follow. 404 405IBaz* HIDL_FETCH_IBaz(const char* /* name */) { 406 return new Baz(); 407} 408 409} // namespace implementation 410} // namespace V1_0 411} // namespace baz 412} // namespace tests 413} // namespace hardware 414} // namespace android 415