Home | History | Annotate | Download | only in audio 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chromeos/audio/audio_device.h"
      6 
      7 #include "base/format_macros.h"
      8 #include "base/strings/string_number_conversions.h"
      9 #include "base/strings/stringprintf.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 
     12 namespace chromeos {
     13 
     14 namespace {
     15 
     16 // Get the priority for a particular device type. The priority returned
     17 // will be between 0 to 3, the higher number meaning a higher priority.
     18 uint8 GetDevicePriority(AudioDeviceType type) {
     19   switch (type) {
     20     case AUDIO_TYPE_HEADPHONE:
     21     case AUDIO_TYPE_MIC:
     22     case AUDIO_TYPE_USB:
     23     case AUDIO_TYPE_BLUETOOTH:
     24       return 3;
     25     case AUDIO_TYPE_HDMI:
     26       return 2;
     27     case AUDIO_TYPE_INTERNAL_SPEAKER:
     28     case AUDIO_TYPE_INTERNAL_MIC:
     29       return 1;
     30     case AUDIO_TYPE_KEYBOARD_MIC:
     31     case AUDIO_TYPE_OTHER:
     32     default:
     33       return 0;
     34   }
     35 }
     36 
     37 }  // namespace
     38 
     39 // static
     40 std::string AudioDevice::GetTypeString(AudioDeviceType type) {
     41   switch (type) {
     42     case AUDIO_TYPE_HEADPHONE:
     43       return "HEADPHONE";
     44     case AUDIO_TYPE_MIC:
     45       return "MIC";
     46     case AUDIO_TYPE_USB:
     47       return "USB";
     48     case AUDIO_TYPE_BLUETOOTH:
     49       return "BLUETOOTH";
     50     case AUDIO_TYPE_HDMI:
     51       return "HDMI";
     52     case AUDIO_TYPE_INTERNAL_SPEAKER:
     53       return "INTERNAL_SPEAKER";
     54     case AUDIO_TYPE_INTERNAL_MIC:
     55       return "INTERNAL_MIC";
     56     case AUDIO_TYPE_KEYBOARD_MIC:
     57       return "KEYBOARD_MIC";
     58     case AUDIO_TYPE_OTHER:
     59     default:
     60       return "OTHER";
     61   }
     62 }
     63 
     64 // static
     65 AudioDeviceType AudioDevice::GetAudioType(
     66     const std::string& node_type) {
     67   if (node_type.find("HEADPHONE") != std::string::npos)
     68     return AUDIO_TYPE_HEADPHONE;
     69   else if (node_type.find("INTERNAL_MIC") != std::string::npos)
     70     return AUDIO_TYPE_INTERNAL_MIC;
     71   else if (node_type.find("KEYBOARD_MIC") != std::string::npos)
     72     return AUDIO_TYPE_KEYBOARD_MIC;
     73   else if (node_type.find("MIC") != std::string::npos)
     74     return AUDIO_TYPE_MIC;
     75   else if (node_type.find("USB") != std::string::npos)
     76     return AUDIO_TYPE_USB;
     77   else if (node_type.find("BLUETOOTH") != std::string::npos)
     78     return AUDIO_TYPE_BLUETOOTH;
     79   else if (node_type.find("HDMI") != std::string::npos)
     80     return AUDIO_TYPE_HDMI;
     81   else if (node_type.find("INTERNAL_SPEAKER") != std::string::npos)
     82     return AUDIO_TYPE_INTERNAL_SPEAKER;
     83   else
     84     return AUDIO_TYPE_OTHER;
     85 }
     86 
     87 AudioDevice::AudioDevice()
     88     : is_input(false),
     89       id(0),
     90       display_name(""),
     91       type(AUDIO_TYPE_OTHER),
     92       priority(0),
     93       active(false),
     94       plugged_time(0) {
     95 }
     96 
     97 AudioDevice::AudioDevice(const AudioNode& node) {
     98   is_input = node.is_input;
     99   id = node.id;
    100   type = GetAudioType(node.type);
    101   if (!node.name.empty() && node.name != "(default)")
    102     display_name = node.name;
    103   else
    104     display_name = node.device_name;
    105   device_name = node.device_name;
    106   priority = GetDevicePriority(type);
    107   active = node.active;
    108   plugged_time = node.plugged_time;
    109 }
    110 
    111 std::string AudioDevice::ToString() const {
    112   std::string result;
    113   base::StringAppendF(&result,
    114                       "is_input = %s ",
    115                       is_input ? "true" : "false");
    116   base::StringAppendF(&result,
    117                       "id = 0x%" PRIx64 " ",
    118                       id);
    119   base::StringAppendF(&result,
    120                       "display_name = %s ",
    121                       display_name.c_str());
    122   base::StringAppendF(&result,
    123                       "device_name = %s ",
    124                       device_name.c_str());
    125   base::StringAppendF(&result,
    126                       "type = %s ",
    127                       GetTypeString(type).c_str());
    128   base::StringAppendF(&result,
    129                       "active = %s ",
    130                       active ? "true" : "false");
    131   base::StringAppendF(&result,
    132                       "plugged_time= %s ",
    133                       base::Uint64ToString(plugged_time).c_str());
    134 
    135   return result;
    136 }
    137 
    138 }  // namespace chromeos
    139