1/*
2 * Copyright (C) 2016 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
17package android.hardware.tests.foo@1.0;
18
19import IFooCallback;
20import IMyTypes.SomeStruct;
21import ISimple;
22import ITheirTypes.FloatArray;
23
24interface IFoo {
25
26    enum SomeBaseEnum : uint8_t {
27        bar = 66
28    };
29
30    enum SomeEnum : SomeBaseEnum {
31        quux = 33,
32        goober = 192,
33        blah = goober
34    };
35
36    enum BitField : uint8_t {
37        V0 = 1 << 0,
38        V1 = 1 << 1,
39        V2 = 1 << 2,
40        V3 = 1 << 3,
41        VALL = V0 | V1 | V2 | V3,
42    };
43
44    struct Fumble {
45        Outer.Inner data;
46    };
47
48    typedef Fumble Gumble;
49
50    struct Goober {
51        int32_t q;
52        string name;
53        string address;
54        double[10] numbers;
55        Fumble fumble;
56        Gumble gumble;
57        // vec<double> lotsOfFumbles;
58        // handle loveHandle;
59    };
60
61    typedef float[3] ThreeFloats;
62    typedef float[5] FiveFloats;
63
64    struct Quux {
65        string first;
66        string last;
67    };
68
69    typedef Quux[3] ThreeQuuxes;
70
71    struct MultiDimensional {
72        ThreeQuuxes[5] quuxMatrix;
73    };
74
75    typedef string[3] ThreeStrings;
76    typedef string[5] FiveStrings;
77
78    struct StringMatrix3x5 {
79        FiveStrings[3] s;
80    };
81
82    struct StringMatrix5x3 {
83        ThreeStrings[5] s;
84    };
85
86    struct MyStruct {
87        SomeStruct innerStruct;
88        FloatArray myFloatArray;
89    };
90
91    struct MyHandle {
92        handle h;
93        int32_t guard;
94    };
95
96    struct MyMask {
97        bitfield<BitField> value;
98    };
99
100    typedef bitfield<BitField> Mask;
101
102    struct Everything {
103        union U {
104            int8_t number;
105            int8_t[1][2] multidimArray;
106            Fumble anotherStruct;
107            bitfield<BitField> bf;
108        } u;
109
110        int8_t number;
111        handle h;
112        fmq_sync<uint8_t> descSync;
113        fmq_unsync<uint8_t> descUnsync;
114        memory mem;
115        pointer p;
116        string s;
117        vec<string> vs;
118        string[2][2] multidimArray;
119        string[3] sArray;
120        Quux anotherStruct;
121        bitfield<BitField> bf;
122    };
123
124    struct WithFmq {
125        struct ScatterGather {
126            fmq_sync<uint8_t> descSync;
127        } scatterGathered;
128
129        struct ContainsPointer {
130            fmq_sync<uint8_t> descSync;
131            interface foo;
132        } containsPointer;
133    };
134
135    enum Discriminator : uint8_t {
136        BOOL,
137        INT,
138    };
139    union Union {
140        bool boolValue;
141        int64_t intValue;
142    };
143    struct ContainsUnion {
144        Discriminator discriminator;
145        Union value;
146    };
147
148    typedef int32_t[5][6][7] multidimArrayOne;
149    typedef multidimArrayOne[8][9][10] multidimArrayTwo;
150    typedef multidimArrayTwo[2][3][4] multidimArrayThree;
151
152    struct InnerTestStruct {};
153    typedef InnerTestStruct InnerTestStructTypedef;
154    struct S1 {
155        struct InnerTestStruct {};
156        InnerTestStructTypedef foo;
157    };
158
159    enum InnerTestEnum : int32_t {
160        VALUE = 0
161    };
162    typedef InnerTestEnum InnerTestEnumTypedef;
163    struct S2 {
164        enum InnerTestEnum : int32_t {
165            VALUE = 1
166        };
167        InnerTestEnumTypedef foo;
168    };
169
170    /**
171     * If d is INT, converts all values to bools which are small enough (0 or 1).
172     * If d is BOOL, should leave all values as BOOLs.
173     *
174     * @param d discriminator for all values in u
175     * @param u values to be expanded
176     * @return c must have same length as u unless there is an error in which case it will be empty.
177     */
178    convertToBoolIfSmall(Discriminator d, vec<Union> u) generates (vec<ContainsUnion> c);
179
180    doThis(float param);
181    doThatAndReturnSomething(int64_t param) generates (int32_t result);
182    doQuiteABit(int32_t a, int64_t b, float c, double d) generates (double something);
183    doSomethingElse(int32_t[15] param) generates (int32_t[32] something);
184    doStuffAndReturnAString() generates (string something);
185    mapThisVector(vec<int32_t> param) generates (vec<int32_t> something);
186    oneway callMe(IFooCallback cb);
187    useAnEnum(SomeEnum zzz) generates (SomeEnum sleepy);
188
189    haveAGooberVec(vec<Goober> param);
190    haveAGoober(Goober g);
191    haveAGooberArray(Goober[20] lots);
192
193    haveATypeFromAnotherFile(Abc def);
194
195    haveSomeStrings(string[3] array) generates (string[2] result);
196    haveAStringVec(vec<string> vector) generates (vec<string> result);
197
198    transposeMe(FiveFloats[3] in) generates (ThreeFloats[5] out);
199    callingDrWho(MultiDimensional in) generates (MultiDimensional out);
200
201    transpose(StringMatrix5x3 in) generates (StringMatrix3x5 out);
202    transpose2(ThreeStrings[5] in) generates (FiveStrings[3] out);
203
204    sendVec(vec<uint8_t> data) generates (vec<uint8_t> data);
205
206    sendVecVec() generates (vec<vec<uint8_t>> vecvec);
207
208    haveAVectorOfInterfaces(vec<ISimple> in) generates (vec<ISimple> out);
209
210    haveAVectorOfGenericInterfaces(vec<interface> in)
211        generates (vec<interface> out);
212
213    echoNullInterface(IFooCallback cb) generates (bool receivedNull, IFooCallback cb);
214
215    createMyHandle() generates (MyHandle h);
216    createHandles(uint32_t size) generates (vec<handle> handles);
217    closeHandles();
218
219    repeatWithFmq(WithFmq withFmq) generates (WithFmq withFmq);
220};
221