tests/safeunion/1.0/default/SafeUnion.cpp

   1 /*
   2  * Copyright (C) 2018 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 "SafeUnion.h"
  18 #include <android-base/logging.h>
  19
  20 namespace android {
  21 namespace hardware {
  22 namespace tests {
  23 namespace safeunion {
  24 namespace V1_0 {
  25 namespace implementation {
  26
  27 // Methods from ::android::hardware::tests::safeunion::V1_0::ISafeUnion follow.
  28 Return<void> SafeUnion::newLargeSafeUnion(newLargeSafeUnion_cb _hidl_cb) {
  29     LOG(INFO) << "SERVER(SafeUnion) newLargeSafeUnion()";
  30
  31     LargeSafeUnion ret;
  32     _hidl_cb(ret);
  33     return Void();
  34 }
  35
  36 Return<void> SafeUnion::setA(const LargeSafeUnion& myUnion, int8_t a, setA_cb _hidl_cb) {
  37     LOG(INFO) << "SERVER(SafeUnion) setA(myUnion, " << a << ")";
  38
  39     LargeSafeUnion myNewUnion = myUnion;
  40     myNewUnion.a(a);
  41
  42     _hidl_cb(myNewUnion);
  43     return Void();
  44 }
  45
  46 Return<void> SafeUnion::setB(const LargeSafeUnion& myUnion, uint16_t b, setB_cb _hidl_cb) {
  47     LOG(INFO) << "SERVER(SafeUnion) setB(myUnion, " << b << ")";
  48
  49     LargeSafeUnion myNewUnion = myUnion;
  50     myNewUnion.b(b);
  51
  52     _hidl_cb(myNewUnion);
  53     return Void();
  54 }
  55
  56 Return<void> SafeUnion::setC(const LargeSafeUnion& myUnion, int32_t c, setC_cb _hidl_cb) {
  57     LOG(INFO) << "SERVER(SafeUnion) setC(myUnion, " << c << ")";
  58
  59     LargeSafeUnion myNewUnion = myUnion;
  60     myNewUnion.c(c);
  61
  62     _hidl_cb(myNewUnion);
  63     return Void();
  64 }
  65
  66 Return<void> SafeUnion::setD(const LargeSafeUnion& myUnion, uint64_t d, setD_cb _hidl_cb) {
  67     LOG(INFO) << "SERVER(SafeUnion) setD(myUnion, " << d << ")";
  68
  69     LargeSafeUnion myNewUnion = myUnion;
  70     myNewUnion.d(d);
  71
  72     _hidl_cb(myNewUnion);
  73     return Void();
  74 }
  75
  76 Return<void> SafeUnion::setE(const LargeSafeUnion& myUnion, const hidl_array<int8_t, 13>& e, setE_cb _hidl_cb) {
  77     LOG(INFO) << "SERVER(SafeUnion) setE(myUnion, " << toString(e) << ")";
  78
  79     LargeSafeUnion myNewUnion = myUnion;
  80     myNewUnion.e(e);
  81
  82     _hidl_cb(myNewUnion);
  83     return Void();
  84 }
  85
  86 Return<void> SafeUnion::setF(const LargeSafeUnion& myUnion, const hidl_array<int64_t, 5>& f, setF_cb _hidl_cb) {
  87     LOG(INFO) << "SERVER(SafeUnion) setF(myUnion, " << toString(f) << ")";
  88
  89     LargeSafeUnion myNewUnion = myUnion;
  90     myNewUnion.f(f);
  91
  92     _hidl_cb(myNewUnion);
  93     return Void();
  94 }
  95
  96 Return<void> SafeUnion::setG(const LargeSafeUnion& myUnion, const hidl_string& g, setG_cb _hidl_cb) {
  97     LOG(INFO) << "SERVER(SafeUnion) setG(myUnion, " << toString(g) << ")";
  98
  99     LargeSafeUnion myNewUnion = myUnion;
 100     myNewUnion.g(g);
 101
 102     _hidl_cb(myNewUnion);
 103     return Void();
 104 }
 105
 106 Return<void> SafeUnion::setH(const LargeSafeUnion& myUnion, const hidl_vec<bool>& h, setH_cb _hidl_cb) {
 107     LOG(INFO) << "SERVER(SafeUnion) setH(myUnion, " << toString(h) << ")";
 108
 109     LargeSafeUnion myNewUnion = myUnion;
 110     myNewUnion.h(h);
 111
 112     _hidl_cb(myNewUnion);
 113     return Void();
 114 }
 115
 116 Return<void> SafeUnion::setI(const LargeSafeUnion& myUnion, const hidl_vec<uint64_t>& i, setI_cb _hidl_cb) {
 117     LOG(INFO) << "SERVER(SafeUnion) setI(myUnion, " << toString(i) << ")";
 118
 119     LargeSafeUnion myNewUnion = myUnion;
 120     myNewUnion.i(i);
 121
 122     _hidl_cb(myNewUnion);
 123     return Void();
 124 }
 125
 126 Return<void> SafeUnion::setJ(const LargeSafeUnion& myUnion, const J& j, setJ_cb _hidl_cb) {
 127     LOG(INFO) << "SERVER(SafeUnion) setJ(myUnion, " << toString(j) << ")";
 128
 129     LargeSafeUnion myNewUnion = myUnion;
 130     myNewUnion.j(j);
 131
 132     _hidl_cb(myNewUnion);
 133     return Void();
 134 }
 135
 136 Return<void> SafeUnion::setK(const LargeSafeUnion& myUnion, const LargeSafeUnion::K& k, setK_cb _hidl_cb) {
 137     LOG(INFO) << "SERVER(SafeUnion) setK(myUnion, " << toString(k) << ")";
 138
 139     LargeSafeUnion myNewUnion = myUnion;
 140     myNewUnion.k(k);
 141
 142     _hidl_cb(myNewUnion);
 143     return Void();
 144 }
 145
 146 Return<void> SafeUnion::setL(const LargeSafeUnion& myUnion, const SmallSafeUnion& l, setL_cb _hidl_cb) {
 147     LOG(INFO) << "SERVER(SafeUnion) setL(myUnion, " << toString(l) << ")";
 148
 149     LargeSafeUnion myNewUnion = myUnion;
 150     myNewUnion.l(l);
 151
 152     _hidl_cb(myNewUnion);
 153     return Void();
 154 }
 155
 156 Return<void> SafeUnion::setM(const LargeSafeUnion& myUnion, BitField m, setL_cb _hidl_cb) {
 157     LOG(INFO) << "SERVER(SafeUnion) setM(myUnion, " << toString(m) << ")";
 158
 159     LargeSafeUnion myNewUnion = myUnion;
 160     myNewUnion.m(m);
 161
 162     _hidl_cb(myNewUnion);
 163     return Void();
 164 }
 165
 166 Return<void> SafeUnion::setN(const LargeSafeUnion& myUnion, hidl_bitfield<BitField> n,
 167                              setL_cb _hidl_cb) {
 168     LOG(INFO) << "SERVER(SafeUnion) setN(myUnion, " << n << ")";
 169
 170     LargeSafeUnion myNewUnion = myUnion;
 171     myNewUnion.n(n);
 172
 173     _hidl_cb(myNewUnion);
 174     return Void();
 175 }
 176
 177 Return<void> SafeUnion::newInterfaceTypeSafeUnion(newInterfaceTypeSafeUnion_cb _hidl_cb) {
 178     LOG(INFO) << "SERVER(SafeUnion) newInterfaceTypeSafeUnion()";
 179
 180     InterfaceTypeSafeUnion ret;
 181     _hidl_cb(ret);
 182     return Void();
 183 }
 184
 185 Return<void> SafeUnion::setInterfaceA(const InterfaceTypeSafeUnion& myUnion, uint32_t a, setInterfaceA_cb _hidl_cb) {
 186     LOG(INFO) << "SERVER(SafeUnion) setInterfaceA(myUnion, " << a << ")";
 187
 188     InterfaceTypeSafeUnion myNewUnion = myUnion;
 189     myNewUnion.a(a);
 190
 191     _hidl_cb(myNewUnion);
 192     return Void();
 193 }
 194
 195 Return<void> SafeUnion::setInterfaceB(const InterfaceTypeSafeUnion& myUnion, const hidl_array<int8_t, 7>& b, setInterfaceB_cb _hidl_cb) {
 196     LOG(INFO) << "SERVER(SafeUnion) setInterfaceB(myUnion, " << toString(b) << ")";
 197
 198     InterfaceTypeSafeUnion myNewUnion = myUnion;
 199     myNewUnion.b(b);
 200
 201     _hidl_cb(myNewUnion);
 202     return Void();
 203 }
 204
 205 Return<void> SafeUnion::setInterfaceC(const InterfaceTypeSafeUnion& myUnion, const sp<::android::hardware::tests::safeunion::V1_0::IOtherInterface>& c, setInterfaceC_cb _hidl_cb) {
 206     LOG(INFO) << "SERVER(SafeUnion) setInterfaceC(myUnion, " << toString(c) << ")";
 207
 208     InterfaceTypeSafeUnion myNewUnion = myUnion;
 209     myNewUnion.c(c);
 210
 211     _hidl_cb(myNewUnion);
 212     return Void();
 213 }
 214
 215 Return<void> SafeUnion::setInterfaceD(const InterfaceTypeSafeUnion& myUnion, const hidl_string& d,
 216                                       setInterfaceD_cb _hidl_cb) {
 217     LOG(INFO) << "SERVER(SafeUnion) setInterfaceD(myUnion, " << toString(d) << ")";
 218
 219     InterfaceTypeSafeUnion myNewUnion = myUnion;
 220     myNewUnion.d(d);
 221
 222     _hidl_cb(myNewUnion);
 223     return Void();
 224 }
 225
 226 Return<void> SafeUnion::setInterfaceE(const InterfaceTypeSafeUnion& myUnion,
 227                                       const hidl_vec<hidl_string>& e, setInterfaceE_cb _hidl_cb) {
 228     LOG(INFO) << "SERVER(SafeUnion) setInterfaceE(myUnion, " << toString(e) << ")";
 229
 230     InterfaceTypeSafeUnion myNewUnion = myUnion;
 231     myNewUnion.e(e);
 232
 233     _hidl_cb(myNewUnion);
 234     return Void();
 235 }
 236
 237 Return<void> SafeUnion::setInterfaceF(const InterfaceTypeSafeUnion& myUnion, const hidl_handle& f,
 238                                       setInterfaceF_cb _hidl_cb) {
 239     LOG(INFO) << "SERVER(SafeUnion) setInterfaceF(myUnion, " << toString(f) << ")";
 240
 241     InterfaceTypeSafeUnion myNewUnion = myUnion;
 242     myNewUnion.f(f);
 243
 244     _hidl_cb(myNewUnion);
 245     return Void();
 246 }
 247
 248 Return<void> SafeUnion::setInterfaceG(const InterfaceTypeSafeUnion& myUnion,
 249                                       const hidl_vec<hidl_handle>& g, setInterfaceG_cb _hidl_cb) {
 250     LOG(INFO) << "SERVER(SafeUnion) setInterfaceG(myUnion, " << toString(g) << ")";
 251
 252     InterfaceTypeSafeUnion myNewUnion = myUnion;
 253     myNewUnion.g(g);
 254
 255     _hidl_cb(myNewUnion);
 256     return Void();
 257 }
 258
 259 Return<void> SafeUnion::newHandleTypeSafeUnion(newHandleTypeSafeUnion_cb _hidl_cb) {
 260     LOG(INFO) << "SERVER(SafeUnion) newHandleTypeSafeUnion()";
 261
 262     HandleTypeSafeUnion ret;
 263     _hidl_cb(ret);
 264     return Void();
 265 }
 266
 267 Return<void> SafeUnion::setHandleA(
 268     const ::android::hardware::tests::safeunion::V1_0::ISafeUnion::HandleTypeSafeUnion& myUnion,
 269     const hidl_handle& a, setHandleA_cb _hidl_cb) {
 270     LOG(INFO) << "SERVER(SafeUnion) setHandleA(myUnion, " << toString(a) << ")";
 271
 272     HandleTypeSafeUnion myNewUnion = myUnion;
 273     myNewUnion.a(a);
 274
 275     _hidl_cb(myNewUnion);
 276     return Void();
 277 }
 278
 279 Return<void> SafeUnion::setHandleB(const HandleTypeSafeUnion& myUnion,
 280                                    const hidl_array<hidl_handle, 5>& b, setHandleB_cb _hidl_cb) {
 281     LOG(INFO) << "SERVER(SafeUnion) setHandleB(myUnion, " << toString(b) << ")";
 282
 283     HandleTypeSafeUnion myNewUnion = myUnion;
 284     myNewUnion.b(b);
 285
 286     _hidl_cb(myNewUnion);
 287     return Void();
 288 }
 289
 290 Return<void> SafeUnion::setHandleC(const HandleTypeSafeUnion& myUnion,
 291                                    const hidl_vec<hidl_handle>& c, setHandleC_cb _hidl_cb) {
 292     LOG(INFO) << "SERVER(SafeUnion) setHandleC(myUnion, " << toString(c) << ")";
 293
 294     HandleTypeSafeUnion myNewUnion = myUnion;
 295     myNewUnion.c(c);
 296
 297     _hidl_cb(myNewUnion);
 298     return Void();
 299 }
 300
 301 ISafeUnion* HIDL_FETCH_ISafeUnion(const char* /* name */) {
 302     return new SafeUnion();
 303 }
 304
 305 }  // namespace implementation
 306 }  // namespace V1_0
 307 }  // namespace safeunion
 308 }  // namespace tests
 309 }  // namespace hardware
 310 }  // namespace android