broadcastradio/1.0/default/Utils.cpp

   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
 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
 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
 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
 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
 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
 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
 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