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 #define LOG_TAG "BroadcastRadioHalUtils"
17 //#define LOG_NDEBUG 0
18
19 #include <log/log.h>
20 #include <utils/misc.h>
21 #include <system/radio_metadata.h>
22
23 #include "Utils.h"
24
25 namespace android {
26 namespace hardware {
27 namespace broadcastradio {
28 namespace V1_0 {
29 namespace implementation {
30
31 const char *Utils::sClassModuleNames[] = {
32 RADIO_HARDWARE_MODULE_ID_FM, /* corresponds to RADIO_CLASS_AM_FM */
33 RADIO_HARDWARE_MODULE_ID_SAT, /* corresponds to RADIO_CLASS_SAT */
34 RADIO_HARDWARE_MODULE_ID_DT, /* corresponds to RADIO_CLASS_DT */
35 };
36
37 // make sure HIDL enum values are aligned with legacy values
38 static_assert(RADIO_CLASS_AM_FM == static_cast<int>(Class::AM_FM),
39 "AM/FM class mismatch with legacy");
40 static_assert(RADIO_CLASS_SAT == static_cast<int>(Class::SAT),
41 "SAT class mismatch with legacy");
42 static_assert(RADIO_CLASS_DT == static_cast<int>(Class::DT),
43 "DT class mismatch with legacy");
44
45 static_assert(RADIO_BAND_AM == static_cast<int>(Band::AM),
46 "AM band mismatch with legacy");
47 static_assert(RADIO_BAND_FM == static_cast<int>(Band::FM),
48 "FM band mismatch with legacy");
49 static_assert(RADIO_BAND_AM_HD == static_cast<int>(Band::AM_HD),
50 "AM HD band mismatch with legacy");
51 static_assert(RADIO_BAND_FM_HD == static_cast<int>(Band::FM_HD),
52 "FM HD band mismatch with legacy");
53
54 static_assert(RADIO_RDS_NONE == static_cast<int>(Rds::NONE),
55 "RDS NONE mismatch with legacy");
56 static_assert(RADIO_RDS_WORLD == static_cast<int>(Rds::WORLD),
57 "RDS WORLD mismatch with legacy");
58 static_assert(RADIO_RDS_US == static_cast<int>(Rds::US),
59 "RDS US mismatch with legacy");
60
61 static_assert(RADIO_DEEMPHASIS_50 == static_cast<int>(Deemphasis::D50),
62 "De-emphasis 50 mismatch with legacy");
63 static_assert(RADIO_DEEMPHASIS_75 == static_cast<int>(Deemphasis::D75),
64 "De-emphasis 75 mismatch with legacy");
65
66 static_assert(RADIO_DIRECTION_UP == static_cast<int>(Direction::UP),
67 "Direction Up mismatch with legacy");
68 static_assert(RADIO_DIRECTION_DOWN == static_cast<int>(Direction::DOWN),
69 "Direction Up mismatch with legacy");
70
71 static_assert(RADIO_METADATA_TYPE_INVALID == static_cast<int>(MetadataType::INVALID),
72 "Metadata type INVALID mismatch with legacy");
73 static_assert(RADIO_METADATA_TYPE_INT == static_cast<int>(MetadataType::INT),
74 "Metadata type INT mismatch with legacy");
75 static_assert(RADIO_METADATA_TYPE_TEXT == static_cast<int>(MetadataType::TEXT),
76 "Metadata type TEXT mismatch with legacy");
77 static_assert(RADIO_METADATA_TYPE_RAW == static_cast<int>(MetadataType::RAW),
78 "Metadata type RAW mismatch with legacy");
79 static_assert(RADIO_METADATA_TYPE_CLOCK == static_cast<int>(MetadataType::CLOCK),
80 "Metadata type CLOCK mismatch with legacy");
81
82 static_assert(RADIO_METADATA_KEY_INVALID == static_cast<int>(MetadataKey::INVALID),
83 "Metadata key INVALID mismatch with legacy");
84 static_assert(RADIO_METADATA_KEY_RDS_PI == static_cast<int>(MetadataKey::RDS_PI),
85 "Metadata key RDS_PI mismatch with legacy");
86 static_assert(RADIO_METADATA_KEY_RDS_PS == static_cast<int>(MetadataKey::RDS_PS),
87 "Metadata key RDS_PS mismatch with legacy");
88 static_assert(RADIO_METADATA_KEY_RDS_PTY == static_cast<int>(MetadataKey::RDS_PTY),
89 "Metadata key RDS_PTY mismatch with legacy");
90 static_assert(RADIO_METADATA_KEY_RBDS_PTY == static_cast<int>(MetadataKey::RBDS_PTY),
91 "Metadata key RBDS_PTY mismatch with legacy");
92 static_assert(RADIO_METADATA_KEY_RDS_RT == static_cast<int>(MetadataKey::RDS_RT),
93 "Metadata key RDS_RT mismatch with legacy");
94 static_assert(RADIO_METADATA_KEY_TITLE == static_cast<int>(MetadataKey::TITLE),
95 "Metadata key TITLE mismatch with legacy");
96 static_assert(RADIO_METADATA_KEY_ARTIST == static_cast<int>(MetadataKey::ARTIST),
97 "Metadata key ARTIST mismatch with legacy");
98 static_assert(RADIO_METADATA_KEY_ALBUM == static_cast<int>(MetadataKey::ALBUM),
99 "Metadata key ALBUM mismatch with legacy");
100 static_assert(RADIO_METADATA_KEY_GENRE == static_cast<int>(MetadataKey::GENRE),
101 "Metadata key GENRE mismatch with legacy");
102 static_assert(RADIO_METADATA_KEY_ICON == static_cast<int>(MetadataKey::ICON),
103 "Metadata key ICON mismatch with legacy");
104 static_assert(RADIO_METADATA_KEY_ART == static_cast<int>(MetadataKey::ART),
105 "Metadata key ART mismatch with legacy");
106 static_assert(RADIO_METADATA_KEY_CLOCK == static_cast<int>(MetadataKey::CLOCK),
107 "Metadata key CLOCK mismatch with legacy");
108
109
110 //static
getClassString(Class ClassId)111 const char * Utils::getClassString(Class ClassId)
112 {
113 int id = static_cast<int>(ClassId);
114
115 if ((id < 0) ||
116 (id >= NELEM(sClassModuleNames))) {
117 ALOGE("invalid class ID %d", id);
118 return NULL;
119 }
120 return sClassModuleNames[id];
121 }
122
123 //static
convertHalResult(int rc)124 Result Utils::convertHalResult(int rc)
125 {
126 switch (rc) {
127 case 0:
128 return Result::OK;
129 case -EINVAL:
130 return Result::INVALID_ARGUMENTS;
131 case -ENOSYS:
132 return Result::INVALID_STATE;
133 case -ETIMEDOUT:
134 return Result::TIMEOUT;
135 case -ENODEV:
136 default:
137 return Result::NOT_INITIALIZED;
138 }
139 }
140
141 //static
convertBandConfigFromHal(BandConfig * config,const radio_hal_band_config_t * halConfig)142 void Utils::convertBandConfigFromHal(
143 BandConfig *config,
144 const radio_hal_band_config_t *halConfig)
145 {
146
147 config->type = static_cast<Band>(halConfig->type);
148 config->antennaConnected = halConfig->antenna_connected;
149 config->lowerLimit = halConfig->lower_limit;
150 config->upperLimit = halConfig->upper_limit;
151 config->spacings.setToExternal(const_cast<unsigned int *>(&halConfig->spacings[0]),
152 halConfig->num_spacings * sizeof(uint32_t));
153 // FIXME: transfer buffer ownership. should have a method for that in hidl_vec
154 config->spacings.resize(halConfig->num_spacings);
155
156 if (config->type == Band::FM) {
157 config->ext.fm.deemphasis = static_cast<Deemphasis>(halConfig->fm.deemphasis);
158 config->ext.fm.stereo = halConfig->fm.stereo;
159 config->ext.fm.rds = static_cast<Rds>(halConfig->fm.rds);
160 config->ext.fm.ta = halConfig->fm.ta;
161 config->ext.fm.af = halConfig->fm.af;
162 config->ext.fm.ea = halConfig->fm.ea;
163 } else {
164 config->ext.am.stereo = halConfig->am.stereo;
165 }
166 }
167
168 //static
convertPropertiesFromHal(Properties * properties,const radio_hal_properties_t * halProperties)169 void Utils::convertPropertiesFromHal(
170 Properties *properties,
171 const radio_hal_properties_t *halProperties)
172 {
173 properties->classId = static_cast<Class>(halProperties->class_id);
174 properties->implementor.setToExternal(halProperties->implementor, strlen(halProperties->implementor));
175 properties->product.setToExternal(halProperties->product, strlen(halProperties->product));
176 properties->version.setToExternal(halProperties->version, strlen(halProperties->version));
177 properties->serial.setToExternal(halProperties->serial, strlen(halProperties->serial));
178 properties->numTuners = halProperties->num_tuners;
179 properties->numAudioSources = halProperties->num_audio_sources;
180 properties->supportsCapture = halProperties->supports_capture;
181
182 BandConfig *bands =
183 new BandConfig[halProperties->num_bands];
184 for (size_t i = 0; i < halProperties->num_bands; i++) {
185 convertBandConfigFromHal(&bands[i], &halProperties->bands[i]);
186 }
187 properties->bands.setToExternal(bands, halProperties->num_bands);
188 // FIXME: transfer buffer ownership. should have a method for that in hidl_vec
189 properties->bands.resize(halProperties->num_bands);
190 delete[] bands;
191 }
192
193 //static
convertBandConfigToHal(radio_hal_band_config_t * halConfig,const BandConfig * config)194 void Utils::convertBandConfigToHal(
195 radio_hal_band_config_t *halConfig,
196 const BandConfig *config)
197 {
198
199 halConfig->type = static_cast<radio_band_t>(config->type);
200 halConfig->antenna_connected = config->antennaConnected;
201 halConfig->lower_limit = config->lowerLimit;
202 halConfig->upper_limit = config->upperLimit;
203 halConfig->num_spacings = config->spacings.size();
204 if (halConfig->num_spacings > RADIO_NUM_SPACINGS_MAX) {
205 halConfig->num_spacings = RADIO_NUM_SPACINGS_MAX;
206 }
207 memcpy(halConfig->spacings, config->spacings.data(),
208 sizeof(uint32_t) * halConfig->num_spacings);
209
210 if (config->type == Band::FM) {
211 halConfig->fm.deemphasis = static_cast<radio_deemphasis_t>(config->ext.fm.deemphasis);
212 halConfig->fm.stereo = config->ext.fm.stereo;
213 halConfig->fm.rds = static_cast<radio_rds_t>(config->ext.fm.rds);
214 halConfig->fm.ta = config->ext.fm.ta;
215 halConfig->fm.af = config->ext.fm.af;
216 halConfig->fm.ea = config->ext.fm.ea;
217 } else {
218 halConfig->am.stereo = config->ext.am.stereo;
219 }
220 }
221
222
223 //static
convertProgramInfoFromHal(ProgramInfo * info,radio_program_info_t * halInfo)224 void Utils::convertProgramInfoFromHal(ProgramInfo *info,
225 radio_program_info_t *halInfo)
226 {
227 info->channel = halInfo->channel;
228 info->subChannel = halInfo->sub_channel;
229 info->tuned = halInfo->tuned;
230 info->stereo = halInfo->stereo;
231 info->digital = halInfo->digital;
232 info->signalStrength = halInfo->signal_strength;
233 convertMetaDataFromHal(info->metadata, halInfo->metadata);
234 }
235
236 //static
convertMetaDataFromHal(hidl_vec<MetaData> & metadata,radio_metadata_t * halMetadata)237 int Utils::convertMetaDataFromHal(hidl_vec<MetaData>& metadata,
238 radio_metadata_t *halMetadata)
239 {
240 if (halMetadata == NULL) {
241 ALOGE("Invalid argument: halMetadata is NULL");
242 return 0;
243 }
244
245 int count = radio_metadata_get_count(halMetadata);
246 if (count <= 0) {
247 return count;
248 }
249 MetaData *newMetadata =
250 new MetaData[count];
251 int outCount = 0;
252 for (int i = 0; i < count; i++) {
253 radio_metadata_key_t key;
254 radio_metadata_type_t type;
255 void *value;
256 size_t size;
257 if (radio_metadata_get_at_index(halMetadata, i , &key, &type, &value, &size) != 0 ||
258 size == 0) {
259 continue;
260 }
261 switch (type) {
262 case RADIO_METADATA_TYPE_INT: {
263 newMetadata[outCount].intValue = *(static_cast<int32_t *>(value));
264 } break;
265 case RADIO_METADATA_TYPE_TEXT: {
266 newMetadata[outCount].stringValue = static_cast<char *>(value);
267 } break;
268 case RADIO_METADATA_TYPE_RAW: {
269 newMetadata[outCount].rawValue.setToExternal(static_cast<uint8_t *>(value), size);
270 // FIXME: transfer buffer ownership. should have a method for that in hidl_vec
271 newMetadata[outCount].rawValue.resize(size);
272 } break;
273 case RADIO_METADATA_TYPE_CLOCK: {
274 radio_metadata_clock_t *clock = static_cast<radio_metadata_clock_t *>(value);
275 newMetadata[outCount].clockValue.utcSecondsSinceEpoch =
276 clock->utc_seconds_since_epoch;
277 newMetadata[outCount].clockValue.timezoneOffsetInMinutes =
278 clock->timezone_offset_in_minutes;
279 } break;
280 }
281 newMetadata[outCount].type = static_cast<MetadataType>(type);
282 newMetadata[outCount].key = static_cast<MetadataKey>(key);
283 outCount++;
284 }
285 metadata.setToExternal(newMetadata, outCount);
286 // FIXME: transfer buffer ownership. should have a method for that in hidl_vec
287 metadata.resize(outCount);
288 return outCount;
289 }
290
291 } // namespace implementation
292 } // namespace V1_0
293 } // namespace broadcastradio
294 } // namespace hardware
295 } // namespace android
296