1 /**
2  * Copyright (C) 2022 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 <EvsParams.h>
18 
19 namespace android
20 {
21 
22 namespace telephony
23 {
24 
25 namespace imsmedia
26 {
27 
28 /** Native representation of android.telephony.imsmedia.EvsParams */
EvsParams()29 EvsParams::EvsParams()
30 {
31     this->evsBandwidth = 0;
32     this->evsMode = 0;
33     this->channelAwareMode = 0;
34     this->useHeaderFullOnly = false;
35     this->codecModeRequest = 0;
36 }
37 
EvsParams(EvsParams & params)38 EvsParams::EvsParams(EvsParams& params)
39 {
40     this->evsBandwidth = params.evsBandwidth;
41     this->evsMode = params.evsMode;
42     this->channelAwareMode = params.channelAwareMode;
43     this->useHeaderFullOnly = params.useHeaderFullOnly;
44     this->codecModeRequest = params.codecModeRequest;
45 }
46 
~EvsParams()47 EvsParams::~EvsParams() {}
48 
operator =(const EvsParams & param)49 EvsParams& EvsParams::operator=(const EvsParams& param)
50 {
51     if (this != &param)
52     {
53         this->evsBandwidth = param.evsBandwidth;
54         this->evsMode = param.evsMode;
55         this->channelAwareMode = param.channelAwareMode;
56         this->useHeaderFullOnly = param.useHeaderFullOnly;
57         this->codecModeRequest = param.codecModeRequest;
58     }
59     return *this;
60 }
61 
operator ==(const EvsParams & param) const62 bool EvsParams::operator==(const EvsParams& param) const
63 {
64     return (this->evsBandwidth == param.evsBandwidth && this->evsMode == param.evsMode &&
65             this->channelAwareMode == param.channelAwareMode &&
66             this->useHeaderFullOnly == param.useHeaderFullOnly &&
67             this->codecModeRequest == param.codecModeRequest);
68 }
69 
operator !=(const EvsParams & param) const70 bool EvsParams::operator!=(const EvsParams& param) const
71 {
72     return (this->evsBandwidth != param.evsBandwidth || this->evsMode != param.evsMode ||
73             this->channelAwareMode != param.channelAwareMode ||
74             this->useHeaderFullOnly != param.useHeaderFullOnly ||
75             this->codecModeRequest != param.codecModeRequest);
76 }
77 
writeToParcel(Parcel * out) const78 status_t EvsParams::writeToParcel(Parcel* out) const
79 {
80     status_t err;
81     if (out == nullptr)
82     {
83         return BAD_VALUE;
84     }
85 
86     err = out->writeInt32(evsBandwidth);
87     if (err != NO_ERROR)
88     {
89         return err;
90     }
91 
92     err = out->writeInt32(evsMode);
93     if (err != NO_ERROR)
94     {
95         return err;
96     }
97 
98     err = out->writeByte(channelAwareMode);
99     if (err != NO_ERROR)
100     {
101         return err;
102     }
103 
104     int32_t value = 0;
105     useHeaderFullOnly ? value = 1 : value = 0;
106     err = out->writeInt32(value);
107     if (err != NO_ERROR)
108     {
109         return err;
110     }
111 
112     err = out->writeByte(codecModeRequest);
113     if (err != NO_ERROR)
114     {
115         return err;
116     }
117 
118     return NO_ERROR;
119 }
120 
readFromParcel(const Parcel * in)121 status_t EvsParams::readFromParcel(const Parcel* in)
122 {
123     status_t err;
124     if (in == nullptr)
125     {
126         return BAD_VALUE;
127     }
128 
129     err = in->readInt32(&evsBandwidth);
130     if (err != NO_ERROR)
131     {
132         return err;
133     }
134 
135     err = in->readInt32(&evsMode);
136     if (err != NO_ERROR)
137     {
138         return err;
139     }
140 
141     err = in->readByte(&channelAwareMode);
142     if (err != NO_ERROR)
143     {
144         return err;
145     }
146 
147     int32_t value = 0;
148     err = in->readInt32(&value);
149     if (err != NO_ERROR)
150     {
151         return err;
152     }
153 
154     value == 0 ? useHeaderFullOnly = false : useHeaderFullOnly = true;
155 
156     err = in->readByte(&codecModeRequest);
157     if (err != NO_ERROR)
158     {
159         return err;
160     }
161 
162     return NO_ERROR;
163 }
164 
setEvsBandwidth(const int32_t EvsBandwidth)165 void EvsParams::setEvsBandwidth(const int32_t EvsBandwidth)
166 {
167     evsBandwidth = EvsBandwidth;
168 }
169 
getEvsBandwidth()170 int32_t EvsParams::getEvsBandwidth()
171 {
172     return evsBandwidth;
173 }
174 
setEvsMode(const int32_t EvsMode)175 void EvsParams::setEvsMode(const int32_t EvsMode)
176 {
177     evsMode = EvsMode;
178 }
179 
getEvsMode()180 int32_t EvsParams::getEvsMode()
181 {
182     return evsMode;
183 }
184 
setChannelAwareMode(int8_t channelAwMode)185 void EvsParams::setChannelAwareMode(int8_t channelAwMode)
186 {
187     channelAwareMode = channelAwMode;
188 }
189 
getChannelAwareMode()190 int8_t EvsParams::getChannelAwareMode()
191 {
192     return channelAwareMode;
193 }
194 
setUseHeaderFullOnly(const bool enable)195 void EvsParams::setUseHeaderFullOnly(const bool enable)
196 {
197     useHeaderFullOnly = enable;
198 }
199 
getUseHeaderFullOnly()200 bool EvsParams::getUseHeaderFullOnly()
201 {
202     return useHeaderFullOnly;
203 }
204 
setCodecModeRequest(int8_t cmr)205 void EvsParams::setCodecModeRequest(int8_t cmr)
206 {
207     codecModeRequest = cmr;
208 }
209 
getCodecModeRequest()210 int8_t EvsParams::getCodecModeRequest()
211 {
212     return codecModeRequest;
213 }
214 
setDefaultEvsParams()215 void EvsParams::setDefaultEvsParams()
216 {
217     evsBandwidth = kBandwidth;
218     evsMode = kEvsMode;
219     channelAwareMode = kChannelAwareMode;
220     useHeaderFullOnly = kUseHeaderFullOnly;
221     codecModeRequest = kcodecModeRequest;
222 }
223 
224 }  // namespace imsmedia
225 
226 }  // namespace telephony
227 
228 }  // namespace android
229