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            pointer p;
107            Fumble anotherStruct;
108            bitfield<BitField> bf;
109        } u;
110
111        int8_t number;
112        handle h;
113        fmq_sync<uint8_t> descSync;
114        fmq_unsync<uint8_t> descUnsync;
115        memory mem;
116        pointer p;
117        string s;
118        vec<string> vs;
119        string[2][2] multidimArray;
120        string[3] sArray;
121        Quux anotherStruct;
122        bitfield<BitField> bf;
123    };
124
125    enum Discriminator : uint8_t {
126        BOOL,
127        INT,
128    };
129    union Union {
130        bool boolValue;
131        int64_t intValue;
132    };
133    struct ContainsUnion {
134        Discriminator discriminator;
135        Union value;
136    };
137
138    typedef int32_t[5][6][7] multidimArrayOne;
139    typedef multidimArrayOne[8][9][10] multidimArrayTwo;
140    typedef multidimArrayTwo[2][3][4] multidimArrayThree;
141
142    struct InnerTestStruct {};
143    typedef InnerTestStruct InnerTestStructTypedef;
144    struct S1 {
145        struct InnerTestStruct {};
146        InnerTestStructTypedef foo;
147    };
148
149    enum InnerTestEnum : int32_t {
150        VALUE = 0
151    };
152    typedef InnerTestEnum InnerTestEnumTypedef;
153    struct S2 {
154        enum InnerTestEnum : int32_t {
155            VALUE = 1
156        };
157        InnerTestEnumTypedef foo;
158    };
159
160    /**
161     * If d is INT, converts all values to bools which are small enough (0 or 1).
162     * If d is BOOL, should leave all values as BOOLs.
163     *
164     * @param d discriminator for all values in u
165     * @param u values to be expanded
166     * @return c must have same length as u unless there is an error in which case it will be empty.
167     */
168    convertToBoolIfSmall(Discriminator d, vec<Union> u) generates (vec<ContainsUnion> c);
169
170    doThis(float param);
171    doThatAndReturnSomething(int64_t param) generates (int32_t result);
172    doQuiteABit(int32_t a, int64_t b, float c, double d) generates (double something);
173    doSomethingElse(int32_t[15] param) generates (int32_t[32] something);
174    doStuffAndReturnAString() generates (string something);
175    mapThisVector(vec<int32_t> param) generates (vec<int32_t> something);
176    oneway callMe(IFooCallback cb);
177    useAnEnum(SomeEnum zzz) generates (SomeEnum sleepy);
178
179    haveAGooberVec(vec<Goober> param);
180    haveAGoober(Goober g);
181    haveAGooberArray(Goober[20] lots);
182
183    haveATypeFromAnotherFile(Abc def);
184
185    haveSomeStrings(string[3] array) generates (string[2] result);
186    haveAStringVec(vec<string> vector) generates (vec<string> result);
187
188    transposeMe(FiveFloats[3] in) generates (ThreeFloats[5] out);
189    callingDrWho(MultiDimensional in) generates (MultiDimensional out);
190
191    transpose(StringMatrix5x3 in) generates (StringMatrix3x5 out);
192    transpose2(ThreeStrings[5] in) generates (FiveStrings[3] out);
193
194    sendVec(vec<uint8_t> data) generates (vec<uint8_t> data);
195
196    sendVecVec() generates (vec<vec<uint8_t>> vecvec);
197
198    haveAVectorOfInterfaces(vec<ISimple> in) generates (vec<ISimple> out);
199
200    haveAVectorOfGenericInterfaces(vec<interface> in)
201        generates (vec<interface> out);
202
203    echoNullInterface(IFooCallback cb) generates (bool receivedNull, IFooCallback cb);
204
205    createMyHandle() generates (MyHandle h);
206    createHandles(uint32_t size) generates (vec<handle> handles);
207    closeHandles();
208};
209