chromeos/audio/audio_device.cc

   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