/******************************************************************************
|
*
|
* Copyright 2016 Google, Inc.
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at:
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
******************************************************************************/
|
|
#include <unistd.h>
|
#include <algorithm>
|
#include <array>
|
#include <cerrno>
|
#include <chrono>
|
#include <cstdint>
|
#include <cstring>
|
#include <memory>
|
#include <mutex>
|
|
#include <base/base64.h>
|
#include <base/logging.h>
|
#include <include/hardware/bt_av.h>
|
#include <statslog.h>
|
|
#include "bluetooth/metrics/bluetooth.pb.h"
|
#include "osi/include/osi.h"
|
#include "stack/include/btm_api_types.h"
|
|
#include "address_obfuscator.h"
|
#include "leaky_bonded_queue.h"
|
#include "metrics.h"
|
#include "time_util.h"
|
|
namespace bluetooth {
|
|
namespace common {
|
|
using bluetooth::metrics::BluetoothMetricsProto::A2DPSession;
|
using bluetooth::metrics::BluetoothMetricsProto::A2dpSourceCodec;
|
using bluetooth::metrics::BluetoothMetricsProto::BluetoothLog;
|
using bluetooth::metrics::BluetoothMetricsProto::BluetoothSession;
|
using bluetooth::metrics::BluetoothMetricsProto::
|
BluetoothSession_ConnectionTechnologyType;
|
using bluetooth::metrics::BluetoothMetricsProto::
|
BluetoothSession_DisconnectReasonType;
|
using bluetooth::metrics::BluetoothMetricsProto::DeviceInfo;
|
using bluetooth::metrics::BluetoothMetricsProto::DeviceInfo_DeviceType;
|
using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileConnectionStats;
|
using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType;
|
using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType_ARRAYSIZE;
|
using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType_IsValid;
|
using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType_MAX;
|
using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType_MIN;
|
using bluetooth::metrics::BluetoothMetricsProto::PairEvent;
|
using bluetooth::metrics::BluetoothMetricsProto::ScanEvent;
|
using bluetooth::metrics::BluetoothMetricsProto::ScanEvent_ScanEventType;
|
using bluetooth::metrics::BluetoothMetricsProto::ScanEvent_ScanTechnologyType;
|
using bluetooth::metrics::BluetoothMetricsProto::WakeEvent;
|
using bluetooth::metrics::BluetoothMetricsProto::WakeEvent_WakeEventType;
|
|
static float combine_averages(float avg_a, int64_t ct_a, float avg_b,
|
int64_t ct_b) {
|
if (ct_a > 0 && ct_b > 0) {
|
return (avg_a * ct_a + avg_b * ct_b) / (ct_a + ct_b);
|
} else if (ct_b > 0) {
|
return avg_b;
|
} else {
|
return avg_a;
|
}
|
}
|
|
static int32_t combine_averages(int32_t avg_a, int64_t ct_a, int32_t avg_b,
|
int64_t ct_b) {
|
if (ct_a > 0 && ct_b > 0) {
|
return (avg_a * ct_a + avg_b * ct_b) / (ct_a + ct_b);
|
} else if (ct_b > 0) {
|
return avg_b;
|
} else {
|
return avg_a;
|
}
|
}
|
|
void A2dpSessionMetrics::Update(const A2dpSessionMetrics& metrics) {
|
if (metrics.audio_duration_ms >= 0) {
|
audio_duration_ms = std::max(static_cast<int64_t>(0), audio_duration_ms);
|
audio_duration_ms += metrics.audio_duration_ms;
|
}
|
if (metrics.media_timer_min_ms >= 0) {
|
if (media_timer_min_ms < 0) {
|
media_timer_min_ms = metrics.media_timer_min_ms;
|
} else {
|
media_timer_min_ms =
|
std::min(media_timer_min_ms, metrics.media_timer_min_ms);
|
}
|
}
|
if (metrics.media_timer_max_ms >= 0) {
|
media_timer_max_ms =
|
std::max(media_timer_max_ms, metrics.media_timer_max_ms);
|
}
|
if (metrics.media_timer_avg_ms >= 0 && metrics.total_scheduling_count >= 0) {
|
if (media_timer_avg_ms < 0 || total_scheduling_count < 0) {
|
media_timer_avg_ms = metrics.media_timer_avg_ms;
|
total_scheduling_count = metrics.total_scheduling_count;
|
} else {
|
media_timer_avg_ms = combine_averages(
|
media_timer_avg_ms, total_scheduling_count,
|
metrics.media_timer_avg_ms, metrics.total_scheduling_count);
|
total_scheduling_count += metrics.total_scheduling_count;
|
}
|
}
|
if (metrics.buffer_overruns_max_count >= 0) {
|
buffer_overruns_max_count =
|
std::max(buffer_overruns_max_count, metrics.buffer_overruns_max_count);
|
}
|
if (metrics.buffer_overruns_total >= 0) {
|
buffer_overruns_total =
|
std::max(static_cast<int32_t>(0), buffer_overruns_total);
|
buffer_overruns_total += metrics.buffer_overruns_total;
|
}
|
if (metrics.buffer_underruns_average >= 0 &&
|
metrics.buffer_underruns_count >= 0) {
|
if (buffer_underruns_average < 0 || buffer_underruns_count < 0) {
|
buffer_underruns_average = metrics.buffer_underruns_average;
|
buffer_underruns_count = metrics.buffer_underruns_count;
|
} else {
|
buffer_underruns_average = combine_averages(
|
buffer_underruns_average, buffer_underruns_count,
|
metrics.buffer_underruns_average, metrics.buffer_underruns_count);
|
buffer_underruns_count += metrics.buffer_underruns_count;
|
}
|
}
|
if (codec_index < 0) {
|
codec_index = metrics.codec_index;
|
}
|
if (!is_a2dp_offload) {
|
is_a2dp_offload = metrics.is_a2dp_offload;
|
}
|
}
|
|
bool A2dpSessionMetrics::operator==(const A2dpSessionMetrics& rhs) const {
|
return audio_duration_ms == rhs.audio_duration_ms &&
|
media_timer_min_ms == rhs.media_timer_min_ms &&
|
media_timer_max_ms == rhs.media_timer_max_ms &&
|
media_timer_avg_ms == rhs.media_timer_avg_ms &&
|
total_scheduling_count == rhs.total_scheduling_count &&
|
buffer_overruns_max_count == rhs.buffer_overruns_max_count &&
|
buffer_overruns_total == rhs.buffer_overruns_total &&
|
buffer_underruns_average == rhs.buffer_underruns_average &&
|
buffer_underruns_count == rhs.buffer_underruns_count &&
|
codec_index == rhs.codec_index &&
|
is_a2dp_offload == rhs.is_a2dp_offload;
|
}
|
|
static DeviceInfo_DeviceType get_device_type(device_type_t type) {
|
switch (type) {
|
case DEVICE_TYPE_BREDR:
|
return DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR;
|
case DEVICE_TYPE_LE:
|
return DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_LE;
|
case DEVICE_TYPE_DUMO:
|
return DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_DUMO;
|
case DEVICE_TYPE_UNKNOWN:
|
default:
|
return DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_UNKNOWN;
|
}
|
}
|
|
static BluetoothSession_ConnectionTechnologyType get_connection_tech_type(
|
connection_tech_t type) {
|
switch (type) {
|
case CONNECTION_TECHNOLOGY_TYPE_LE:
|
return BluetoothSession_ConnectionTechnologyType::
|
BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_LE;
|
case CONNECTION_TECHNOLOGY_TYPE_BREDR:
|
return BluetoothSession_ConnectionTechnologyType::
|
BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR;
|
case CONNECTION_TECHNOLOGY_TYPE_UNKNOWN:
|
default:
|
return BluetoothSession_ConnectionTechnologyType::
|
BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_UNKNOWN;
|
}
|
}
|
|
static ScanEvent_ScanTechnologyType get_scan_tech_type(scan_tech_t type) {
|
switch (type) {
|
case SCAN_TECH_TYPE_LE:
|
return ScanEvent_ScanTechnologyType::
|
ScanEvent_ScanTechnologyType_SCAN_TECH_TYPE_LE;
|
case SCAN_TECH_TYPE_BREDR:
|
return ScanEvent_ScanTechnologyType::
|
ScanEvent_ScanTechnologyType_SCAN_TECH_TYPE_BREDR;
|
case SCAN_TECH_TYPE_BOTH:
|
return ScanEvent_ScanTechnologyType::
|
ScanEvent_ScanTechnologyType_SCAN_TECH_TYPE_BOTH;
|
case SCAN_TYPE_UNKNOWN:
|
default:
|
return ScanEvent_ScanTechnologyType::
|
ScanEvent_ScanTechnologyType_SCAN_TYPE_UNKNOWN;
|
}
|
}
|
|
static WakeEvent_WakeEventType get_wake_event_type(wake_event_type_t type) {
|
switch (type) {
|
case WAKE_EVENT_ACQUIRED:
|
return WakeEvent_WakeEventType::WakeEvent_WakeEventType_ACQUIRED;
|
case WAKE_EVENT_RELEASED:
|
return WakeEvent_WakeEventType::WakeEvent_WakeEventType_RELEASED;
|
case WAKE_EVENT_UNKNOWN:
|
default:
|
return WakeEvent_WakeEventType::WakeEvent_WakeEventType_UNKNOWN;
|
}
|
}
|
|
static BluetoothSession_DisconnectReasonType get_disconnect_reason_type(
|
disconnect_reason_t type) {
|
switch (type) {
|
case DISCONNECT_REASON_METRICS_DUMP:
|
return BluetoothSession_DisconnectReasonType::
|
BluetoothSession_DisconnectReasonType_METRICS_DUMP;
|
case DISCONNECT_REASON_NEXT_START_WITHOUT_END_PREVIOUS:
|
return BluetoothSession_DisconnectReasonType::
|
BluetoothSession_DisconnectReasonType_NEXT_START_WITHOUT_END_PREVIOUS;
|
case DISCONNECT_REASON_UNKNOWN:
|
default:
|
return BluetoothSession_DisconnectReasonType::
|
BluetoothSession_DisconnectReasonType_UNKNOWN;
|
}
|
}
|
|
static A2dpSourceCodec get_a2dp_source_codec(int64_t codec_index) {
|
switch (codec_index) {
|
case BTAV_A2DP_CODEC_INDEX_SOURCE_SBC:
|
return A2dpSourceCodec::A2DP_SOURCE_CODEC_SBC;
|
case BTAV_A2DP_CODEC_INDEX_SOURCE_AAC:
|
return A2dpSourceCodec::A2DP_SOURCE_CODEC_AAC;
|
case BTAV_A2DP_CODEC_INDEX_SOURCE_APTX:
|
return A2dpSourceCodec::A2DP_SOURCE_CODEC_APTX;
|
case BTAV_A2DP_CODEC_INDEX_SOURCE_APTX_HD:
|
return A2dpSourceCodec::A2DP_SOURCE_CODEC_APTX_HD;
|
case BTAV_A2DP_CODEC_INDEX_SOURCE_LDAC:
|
return A2dpSourceCodec::A2DP_SOURCE_CODEC_LDAC;
|
default:
|
return A2dpSourceCodec::A2DP_SOURCE_CODEC_UNKNOWN;
|
}
|
}
|
|
struct BluetoothMetricsLogger::impl {
|
impl(size_t max_bluetooth_session, size_t max_pair_event,
|
size_t max_wake_event, size_t max_scan_event)
|
: bt_session_queue_(
|
new LeakyBondedQueue<BluetoothSession>(max_bluetooth_session)),
|
pair_event_queue_(new LeakyBondedQueue<PairEvent>(max_pair_event)),
|
wake_event_queue_(new LeakyBondedQueue<WakeEvent>(max_wake_event)),
|
scan_event_queue_(new LeakyBondedQueue<ScanEvent>(max_scan_event)) {
|
bluetooth_log_ = BluetoothLog::default_instance().New();
|
headset_profile_connection_counts_.fill(0);
|
bluetooth_session_ = nullptr;
|
bluetooth_session_start_time_ms_ = 0;
|
a2dp_session_metrics_ = A2dpSessionMetrics();
|
}
|
|
/* Bluetooth log lock protected */
|
BluetoothLog* bluetooth_log_;
|
std::array<int, HeadsetProfileType_ARRAYSIZE>
|
headset_profile_connection_counts_;
|
std::recursive_mutex bluetooth_log_lock_;
|
/* End Bluetooth log lock protected */
|
/* Bluetooth session lock protected */
|
BluetoothSession* bluetooth_session_;
|
uint64_t bluetooth_session_start_time_ms_;
|
A2dpSessionMetrics a2dp_session_metrics_;
|
std::recursive_mutex bluetooth_session_lock_;
|
/* End bluetooth session lock protected */
|
std::unique_ptr<LeakyBondedQueue<BluetoothSession>> bt_session_queue_;
|
std::unique_ptr<LeakyBondedQueue<PairEvent>> pair_event_queue_;
|
std::unique_ptr<LeakyBondedQueue<WakeEvent>> wake_event_queue_;
|
std::unique_ptr<LeakyBondedQueue<ScanEvent>> scan_event_queue_;
|
};
|
|
BluetoothMetricsLogger::BluetoothMetricsLogger()
|
: pimpl_(new impl(kMaxNumBluetoothSession, kMaxNumPairEvent,
|
kMaxNumWakeEvent, kMaxNumScanEvent)) {}
|
|
void BluetoothMetricsLogger::LogPairEvent(uint32_t disconnect_reason,
|
uint64_t timestamp_ms,
|
uint32_t device_class,
|
device_type_t device_type) {
|
PairEvent* event = new PairEvent();
|
DeviceInfo* info = event->mutable_device_paired_with();
|
info->set_device_class(device_class);
|
info->set_device_type(get_device_type(device_type));
|
event->set_disconnect_reason(disconnect_reason);
|
event->set_event_time_millis(timestamp_ms);
|
pimpl_->pair_event_queue_->Enqueue(event);
|
{
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
|
pimpl_->bluetooth_log_->set_num_pair_event(
|
pimpl_->bluetooth_log_->num_pair_event() + 1);
|
}
|
}
|
|
void BluetoothMetricsLogger::LogWakeEvent(wake_event_type_t type,
|
const std::string& requestor,
|
const std::string& name,
|
uint64_t timestamp_ms) {
|
WakeEvent* event = new WakeEvent();
|
event->set_wake_event_type(get_wake_event_type(type));
|
event->set_requestor(requestor);
|
event->set_name(name);
|
event->set_event_time_millis(timestamp_ms);
|
pimpl_->wake_event_queue_->Enqueue(event);
|
{
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
|
pimpl_->bluetooth_log_->set_num_wake_event(
|
pimpl_->bluetooth_log_->num_wake_event() + 1);
|
}
|
}
|
|
void BluetoothMetricsLogger::LogScanEvent(bool start,
|
const std::string& initator,
|
scan_tech_t type, uint32_t results,
|
uint64_t timestamp_ms) {
|
ScanEvent* event = new ScanEvent();
|
if (start) {
|
event->set_scan_event_type(ScanEvent::SCAN_EVENT_START);
|
} else {
|
event->set_scan_event_type(ScanEvent::SCAN_EVENT_STOP);
|
}
|
event->set_initiator(initator);
|
event->set_scan_technology_type(get_scan_tech_type(type));
|
event->set_number_results(results);
|
event->set_event_time_millis(timestamp_ms);
|
pimpl_->scan_event_queue_->Enqueue(event);
|
{
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
|
pimpl_->bluetooth_log_->set_num_scan_event(
|
pimpl_->bluetooth_log_->num_scan_event() + 1);
|
}
|
}
|
|
void BluetoothMetricsLogger::LogBluetoothSessionStart(
|
connection_tech_t connection_tech_type, uint64_t timestamp_ms) {
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
|
if (pimpl_->bluetooth_session_ != nullptr) {
|
LogBluetoothSessionEnd(DISCONNECT_REASON_NEXT_START_WITHOUT_END_PREVIOUS,
|
0);
|
}
|
if (timestamp_ms == 0) {
|
timestamp_ms = bluetooth::common::time_get_os_boottime_ms();
|
}
|
pimpl_->bluetooth_session_start_time_ms_ = timestamp_ms;
|
pimpl_->bluetooth_session_ = new BluetoothSession();
|
pimpl_->bluetooth_session_->set_connection_technology_type(
|
get_connection_tech_type(connection_tech_type));
|
}
|
|
void BluetoothMetricsLogger::LogBluetoothSessionEnd(
|
disconnect_reason_t disconnect_reason, uint64_t timestamp_ms) {
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
|
if (pimpl_->bluetooth_session_ == nullptr) {
|
return;
|
}
|
if (timestamp_ms == 0) {
|
timestamp_ms = bluetooth::common::time_get_os_boottime_ms();
|
}
|
int64_t session_duration_sec =
|
(timestamp_ms - pimpl_->bluetooth_session_start_time_ms_) / 1000;
|
pimpl_->bluetooth_session_->set_session_duration_sec(session_duration_sec);
|
pimpl_->bluetooth_session_->set_disconnect_reason_type(
|
get_disconnect_reason_type(disconnect_reason));
|
pimpl_->bt_session_queue_->Enqueue(pimpl_->bluetooth_session_);
|
pimpl_->bluetooth_session_ = nullptr;
|
pimpl_->a2dp_session_metrics_ = A2dpSessionMetrics();
|
{
|
std::lock_guard<std::recursive_mutex> log_lock(pimpl_->bluetooth_log_lock_);
|
pimpl_->bluetooth_log_->set_num_bluetooth_session(
|
pimpl_->bluetooth_log_->num_bluetooth_session() + 1);
|
}
|
}
|
|
void BluetoothMetricsLogger::LogBluetoothSessionDeviceInfo(
|
uint32_t device_class, device_type_t device_type) {
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
|
if (pimpl_->bluetooth_session_ == nullptr) {
|
LogBluetoothSessionStart(CONNECTION_TECHNOLOGY_TYPE_UNKNOWN, 0);
|
}
|
DeviceInfo* info = pimpl_->bluetooth_session_->mutable_device_connected_to();
|
info->set_device_class(device_class);
|
info->set_device_type(DeviceInfo::DEVICE_TYPE_BREDR);
|
}
|
|
void BluetoothMetricsLogger::LogA2dpSession(
|
const A2dpSessionMetrics& a2dp_session_metrics) {
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
|
if (pimpl_->bluetooth_session_ == nullptr) {
|
// When no bluetooth session exist, create one on system's behalf
|
// Set connection type: for A2DP it is always BR/EDR
|
LogBluetoothSessionStart(CONNECTION_TECHNOLOGY_TYPE_BREDR, 0);
|
LogBluetoothSessionDeviceInfo(BTM_COD_MAJOR_AUDIO, DEVICE_TYPE_BREDR);
|
}
|
// Accumulate metrics
|
pimpl_->a2dp_session_metrics_.Update(a2dp_session_metrics);
|
// Get or allocate new A2DP session object
|
A2DPSession* a2dp_session =
|
pimpl_->bluetooth_session_->mutable_a2dp_session();
|
a2dp_session->set_audio_duration_millis(
|
pimpl_->a2dp_session_metrics_.audio_duration_ms);
|
a2dp_session->set_media_timer_min_millis(
|
pimpl_->a2dp_session_metrics_.media_timer_min_ms);
|
a2dp_session->set_media_timer_max_millis(
|
pimpl_->a2dp_session_metrics_.media_timer_max_ms);
|
a2dp_session->set_media_timer_avg_millis(
|
pimpl_->a2dp_session_metrics_.media_timer_avg_ms);
|
a2dp_session->set_buffer_overruns_max_count(
|
pimpl_->a2dp_session_metrics_.buffer_overruns_max_count);
|
a2dp_session->set_buffer_overruns_total(
|
pimpl_->a2dp_session_metrics_.buffer_overruns_total);
|
a2dp_session->set_buffer_underruns_average(
|
pimpl_->a2dp_session_metrics_.buffer_underruns_average);
|
a2dp_session->set_buffer_underruns_count(
|
pimpl_->a2dp_session_metrics_.buffer_underruns_count);
|
a2dp_session->set_source_codec(
|
get_a2dp_source_codec(pimpl_->a2dp_session_metrics_.codec_index));
|
a2dp_session->set_is_a2dp_offload(
|
pimpl_->a2dp_session_metrics_.is_a2dp_offload);
|
}
|
|
void BluetoothMetricsLogger::LogHeadsetProfileRfcConnection(
|
tBTA_SERVICE_ID service_id) {
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
|
switch (service_id) {
|
case BTA_HSP_SERVICE_ID:
|
pimpl_->headset_profile_connection_counts_[HeadsetProfileType::HSP]++;
|
break;
|
case BTA_HFP_SERVICE_ID:
|
pimpl_->headset_profile_connection_counts_[HeadsetProfileType::HFP]++;
|
break;
|
default:
|
pimpl_->headset_profile_connection_counts_
|
[HeadsetProfileType::HEADSET_PROFILE_UNKNOWN]++;
|
break;
|
}
|
return;
|
}
|
|
void BluetoothMetricsLogger::WriteString(std::string* serialized) {
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
|
LOG(INFO) << __func__ << ": building metrics";
|
Build();
|
LOG(INFO) << __func__ << ": serializing metrics";
|
if (!pimpl_->bluetooth_log_->SerializeToString(serialized)) {
|
LOG(ERROR) << __func__ << ": error serializing metrics";
|
}
|
// Always clean up log objects
|
pimpl_->bluetooth_log_->Clear();
|
}
|
|
void BluetoothMetricsLogger::WriteBase64String(std::string* serialized) {
|
this->WriteString(serialized);
|
base::Base64Encode(*serialized, serialized);
|
}
|
|
void BluetoothMetricsLogger::WriteBase64(int fd) {
|
std::string protoBase64;
|
this->WriteBase64String(&protoBase64);
|
ssize_t ret;
|
OSI_NO_INTR(ret = write(fd, protoBase64.c_str(), protoBase64.size()));
|
if (ret == -1) {
|
LOG(ERROR) << __func__
|
<< ": error writing to dumpsys fd: " << strerror(errno) << " ("
|
<< std::to_string(errno) << ")";
|
}
|
}
|
|
void BluetoothMetricsLogger::CutoffSession() {
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
|
if (pimpl_->bluetooth_session_ != nullptr) {
|
BluetoothSession* new_bt_session =
|
new BluetoothSession(*pimpl_->bluetooth_session_);
|
new_bt_session->clear_a2dp_session();
|
new_bt_session->clear_rfcomm_session();
|
LogBluetoothSessionEnd(DISCONNECT_REASON_METRICS_DUMP, 0);
|
pimpl_->bluetooth_session_ = new_bt_session;
|
pimpl_->bluetooth_session_start_time_ms_ =
|
bluetooth::common::time_get_os_boottime_ms();
|
pimpl_->a2dp_session_metrics_ = A2dpSessionMetrics();
|
}
|
}
|
|
void BluetoothMetricsLogger::Build() {
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
|
CutoffSession();
|
BluetoothLog* bluetooth_log = pimpl_->bluetooth_log_;
|
while (!pimpl_->bt_session_queue_->Empty() &&
|
static_cast<size_t>(bluetooth_log->session_size()) <=
|
pimpl_->bt_session_queue_->Capacity()) {
|
bluetooth_log->mutable_session()->AddAllocated(
|
pimpl_->bt_session_queue_->Dequeue());
|
}
|
while (!pimpl_->pair_event_queue_->Empty() &&
|
static_cast<size_t>(bluetooth_log->pair_event_size()) <=
|
pimpl_->pair_event_queue_->Capacity()) {
|
bluetooth_log->mutable_pair_event()->AddAllocated(
|
pimpl_->pair_event_queue_->Dequeue());
|
}
|
while (!pimpl_->scan_event_queue_->Empty() &&
|
static_cast<size_t>(bluetooth_log->scan_event_size()) <=
|
pimpl_->scan_event_queue_->Capacity()) {
|
bluetooth_log->mutable_scan_event()->AddAllocated(
|
pimpl_->scan_event_queue_->Dequeue());
|
}
|
while (!pimpl_->wake_event_queue_->Empty() &&
|
static_cast<size_t>(bluetooth_log->wake_event_size()) <=
|
pimpl_->wake_event_queue_->Capacity()) {
|
bluetooth_log->mutable_wake_event()->AddAllocated(
|
pimpl_->wake_event_queue_->Dequeue());
|
}
|
while (!pimpl_->bt_session_queue_->Empty() &&
|
static_cast<size_t>(bluetooth_log->wake_event_size()) <=
|
pimpl_->wake_event_queue_->Capacity()) {
|
bluetooth_log->mutable_wake_event()->AddAllocated(
|
pimpl_->wake_event_queue_->Dequeue());
|
}
|
for (size_t i = 0; i < HeadsetProfileType_ARRAYSIZE; ++i) {
|
int num_times_connected = pimpl_->headset_profile_connection_counts_[i];
|
if (HeadsetProfileType_IsValid(i) && num_times_connected > 0) {
|
HeadsetProfileConnectionStats* headset_profile_connection_stats =
|
bluetooth_log->add_headset_profile_connection_stats();
|
// Able to static_cast because HeadsetProfileType_IsValid(i) is true
|
headset_profile_connection_stats->set_headset_profile_type(
|
static_cast<HeadsetProfileType>(i));
|
headset_profile_connection_stats->set_num_times_connected(
|
num_times_connected);
|
}
|
}
|
pimpl_->headset_profile_connection_counts_.fill(0);
|
}
|
|
void BluetoothMetricsLogger::ResetSession() {
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
|
if (pimpl_->bluetooth_session_ != nullptr) {
|
delete pimpl_->bluetooth_session_;
|
pimpl_->bluetooth_session_ = nullptr;
|
}
|
pimpl_->bluetooth_session_start_time_ms_ = 0;
|
pimpl_->a2dp_session_metrics_ = A2dpSessionMetrics();
|
}
|
|
void BluetoothMetricsLogger::ResetLog() {
|
std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
|
pimpl_->bluetooth_log_->Clear();
|
}
|
|
void BluetoothMetricsLogger::Reset() {
|
ResetSession();
|
ResetLog();
|
pimpl_->bt_session_queue_->Clear();
|
pimpl_->pair_event_queue_->Clear();
|
pimpl_->wake_event_queue_->Clear();
|
pimpl_->scan_event_queue_->Clear();
|
}
|
|
void LogLinkLayerConnectionEvent(const RawAddress* address,
|
uint32_t connection_handle,
|
android::bluetooth::DirectionEnum direction,
|
uint16_t link_type, uint32_t hci_cmd,
|
uint16_t hci_event, uint16_t hci_ble_event,
|
uint16_t cmd_status, uint16_t reason_code) {
|
std::string obfuscated_id;
|
if (address != nullptr) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(*address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField bytes_field(
|
address != nullptr ? obfuscated_id.c_str() : nullptr,
|
address != nullptr ? obfuscated_id.size() : 0);
|
int ret = android::util::stats_write(
|
android::util::BLUETOOTH_LINK_LAYER_CONNECTION_EVENT, bytes_field,
|
connection_handle, direction, link_type, hci_cmd, hci_event,
|
hci_ble_event, cmd_status, reason_code);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed to log status " << loghex(cmd_status)
|
<< ", reason " << loghex(reason_code) << " from cmd "
|
<< loghex(hci_cmd) << ", event " << loghex(hci_event)
|
<< ", ble_event " << loghex(hci_ble_event) << " for "
|
<< address << ", handle " << connection_handle << ", type "
|
<< loghex(link_type) << ", error " << ret;
|
}
|
}
|
|
void LogHciTimeoutEvent(uint32_t hci_cmd) {
|
int ret =
|
android::util::stats_write(android::util::BLUETOOTH_HCI_TIMEOUT_REPORTED,
|
static_cast<int64_t>(hci_cmd));
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for opcode " << loghex(hci_cmd)
|
<< ", error " << ret;
|
}
|
}
|
|
void LogRemoteVersionInfo(uint16_t handle, uint8_t status, uint8_t version,
|
uint16_t manufacturer_name, uint16_t subversion) {
|
int ret = android::util::stats_write(
|
android::util::BLUETOOTH_REMOTE_VERSION_INFO_REPORTED, handle, status,
|
version, manufacturer_name, subversion);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for handle " << handle << ", status "
|
<< loghex(status) << ", version " << loghex(version)
|
<< ", manufacturer_name " << loghex(manufacturer_name)
|
<< ", subversion " << loghex(subversion) << ", error " << ret;
|
}
|
}
|
|
void LogA2dpAudioUnderrunEvent(const RawAddress& address,
|
uint64_t encoding_interval_millis,
|
int num_missing_pcm_bytes) {
|
std::string obfuscated_id;
|
if (!address.IsEmpty()) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField bytes_field(
|
address.IsEmpty() ? nullptr : obfuscated_id.c_str(),
|
address.IsEmpty() ? 0 : obfuscated_id.size());
|
int64_t encoding_interval_nanos = encoding_interval_millis * 1000000;
|
int ret = android::util::stats_write(
|
android::util::BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED, bytes_field,
|
encoding_interval_nanos, num_missing_pcm_bytes);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for " << address
|
<< ", encoding_interval_nanos " << encoding_interval_nanos
|
<< ", num_missing_pcm_bytes " << num_missing_pcm_bytes
|
<< ", error " << ret;
|
}
|
}
|
|
void LogA2dpAudioOverrunEvent(const RawAddress& address,
|
uint64_t encoding_interval_millis,
|
int num_dropped_buffers,
|
int num_dropped_encoded_frames,
|
int num_dropped_encoded_bytes) {
|
std::string obfuscated_id;
|
if (!address.IsEmpty()) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField bytes_field(
|
address.IsEmpty() ? nullptr : obfuscated_id.c_str(),
|
address.IsEmpty() ? 0 : obfuscated_id.size());
|
int64_t encoding_interval_nanos = encoding_interval_millis * 1000000;
|
int ret = android::util::stats_write(
|
android::util::BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED, bytes_field,
|
encoding_interval_nanos, num_dropped_buffers, num_dropped_encoded_frames,
|
num_dropped_encoded_bytes);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed to log for " << address
|
<< ", encoding_interval_nanos " << encoding_interval_nanos
|
<< ", num_dropped_buffers " << num_dropped_buffers
|
<< ", num_dropped_encoded_frames "
|
<< num_dropped_encoded_frames << ", num_dropped_encoded_bytes "
|
<< num_dropped_encoded_bytes << ", error " << ret;
|
}
|
}
|
|
void LogReadRssiResult(const RawAddress& address, uint16_t handle,
|
uint32_t cmd_status, int8_t rssi) {
|
std::string obfuscated_id;
|
if (!address.IsEmpty()) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField bytes_field(
|
address.IsEmpty() ? nullptr : obfuscated_id.c_str(),
|
address.IsEmpty() ? 0 : obfuscated_id.size());
|
int ret =
|
android::util::stats_write(android::util::BLUETOOTH_DEVICE_RSSI_REPORTED,
|
bytes_field, handle, cmd_status, rssi);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for " << address << ", handle "
|
<< handle << ", status " << loghex(cmd_status) << ", rssi "
|
<< rssi << " dBm, error " << ret;
|
}
|
}
|
|
void LogReadFailedContactCounterResult(const RawAddress& address,
|
uint16_t handle, uint32_t cmd_status,
|
int32_t failed_contact_counter) {
|
std::string obfuscated_id;
|
if (!address.IsEmpty()) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField bytes_field(
|
address.IsEmpty() ? nullptr : obfuscated_id.c_str(),
|
address.IsEmpty() ? 0 : obfuscated_id.size());
|
int ret = android::util::stats_write(
|
android::util::BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED,
|
bytes_field, handle, cmd_status, failed_contact_counter);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for " << address << ", handle "
|
<< handle << ", status " << loghex(cmd_status)
|
<< ", failed_contact_counter " << failed_contact_counter
|
<< " packets, error " << ret;
|
}
|
}
|
|
void LogReadTxPowerLevelResult(const RawAddress& address, uint16_t handle,
|
uint32_t cmd_status,
|
int32_t transmit_power_level) {
|
std::string obfuscated_id;
|
if (!address.IsEmpty()) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField bytes_field(
|
address.IsEmpty() ? nullptr : obfuscated_id.c_str(),
|
address.IsEmpty() ? 0 : obfuscated_id.size());
|
int ret = android::util::stats_write(
|
android::util::BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED, bytes_field,
|
handle, cmd_status, transmit_power_level);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for " << address << ", handle "
|
<< handle << ", status " << loghex(cmd_status)
|
<< ", transmit_power_level " << transmit_power_level
|
<< " packets, error " << ret;
|
}
|
}
|
|
void LogSmpPairingEvent(const RawAddress& address, uint8_t smp_cmd,
|
android::bluetooth::DirectionEnum direction,
|
uint8_t smp_fail_reason) {
|
std::string obfuscated_id;
|
if (!address.IsEmpty()) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField obfuscated_id_field(
|
address.IsEmpty() ? nullptr : obfuscated_id.c_str(),
|
address.IsEmpty() ? 0 : obfuscated_id.size());
|
int ret = android::util::stats_write(
|
android::util::BLUETOOTH_SMP_PAIRING_EVENT_REPORTED, obfuscated_id_field,
|
smp_cmd, direction, smp_fail_reason);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for " << address << ", smp_cmd "
|
<< loghex(smp_cmd) << ", direction " << direction
|
<< ", smp_fail_reason " << loghex(smp_fail_reason)
|
<< ", error " << ret;
|
}
|
}
|
|
void LogClassicPairingEvent(const RawAddress& address, uint16_t handle, uint32_t hci_cmd, uint16_t hci_event,
|
uint16_t cmd_status, uint16_t reason_code, int64_t event_value) {
|
std::string obfuscated_id;
|
if (!address.IsEmpty()) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField obfuscated_id_field(
|
address.IsEmpty() ? nullptr : obfuscated_id.c_str(),
|
address.IsEmpty() ? 0 : obfuscated_id.size());
|
int ret = android::util::stats_write(android::util::BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED, obfuscated_id_field,
|
handle, hci_cmd, hci_event, cmd_status, reason_code, event_value);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for " << address << ", handle " << handle << ", hci_cmd " << loghex(hci_cmd)
|
<< ", hci_event " << loghex(hci_event) << ", cmd_status " << loghex(cmd_status) << ", reason "
|
<< loghex(reason_code) << ", event_value " << event_value << ", error " << ret;
|
}
|
}
|
|
void LogSdpAttribute(const RawAddress& address, uint16_t protocol_uuid,
|
uint16_t attribute_id, size_t attribute_size,
|
const char* attribute_value) {
|
std::string obfuscated_id;
|
if (!address.IsEmpty()) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField obfuscated_id_field(
|
address.IsEmpty() ? nullptr : obfuscated_id.c_str(),
|
address.IsEmpty() ? 0 : obfuscated_id.size());
|
android::util::BytesField attribute_field(attribute_value, attribute_size);
|
int ret = android::util::stats_write(
|
android::util::BLUETOOTH_SDP_ATTRIBUTE_REPORTED, obfuscated_id_field,
|
protocol_uuid, attribute_id, attribute_field);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for " << address << ", protocol_uuid "
|
<< loghex(protocol_uuid) << ", attribute_id "
|
<< loghex(attribute_id) << ", error " << ret;
|
}
|
}
|
|
void LogSocketConnectionState(
|
const RawAddress& address, int port, int type,
|
android::bluetooth::SocketConnectionstateEnum connection_state,
|
int64_t tx_bytes, int64_t rx_bytes, int uid, int server_port,
|
android::bluetooth::SocketRoleEnum socket_role) {
|
std::string obfuscated_id;
|
if (!address.IsEmpty()) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField obfuscated_id_field(
|
address.IsEmpty() ? nullptr : obfuscated_id.c_str(),
|
address.IsEmpty() ? 0 : obfuscated_id.size());
|
int ret = android::util::stats_write(
|
android::util::BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED,
|
obfuscated_id_field, port, type, connection_state, tx_bytes, rx_bytes,
|
uid, server_port, socket_role);
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for " << address << ", port " << port
|
<< ", type " << type << ", state " << connection_state
|
<< ", tx_bytes " << tx_bytes << ", rx_bytes " << rx_bytes
|
<< ", uid " << uid << ", server_port " << server_port
|
<< ", socket_role " << socket_role << ", error " << ret;
|
}
|
}
|
|
void LogManufacturerInfo(const RawAddress& address,
|
android::bluetooth::DeviceInfoSrcEnum source_type,
|
const std::string& source_name,
|
const std::string& manufacturer,
|
const std::string& model,
|
const std::string& hardware_version,
|
const std::string& software_version) {
|
std::string obfuscated_id;
|
if (!address.IsEmpty()) {
|
obfuscated_id = AddressObfuscator::GetInstance()->Obfuscate(address);
|
}
|
// nullptr and size 0 represent missing value for obfuscated_id
|
android::util::BytesField obfuscated_id_field(
|
address.IsEmpty() ? nullptr : obfuscated_id.c_str(),
|
address.IsEmpty() ? 0 : obfuscated_id.size());
|
int ret = android::util::stats_write(
|
android::util::BLUETOOTH_DEVICE_INFO_REPORTED, obfuscated_id_field,
|
source_type, source_name.c_str(), manufacturer.c_str(), model.c_str(),
|
hardware_version.c_str(), software_version.c_str());
|
if (ret < 0) {
|
LOG(WARNING) << __func__ << ": failed for " << address << ", source_type "
|
<< source_type << ", source_name " << source_name
|
<< ", manufacturer " << manufacturer << ", model " << model
|
<< ", hardware_version " << hardware_version
|
<< ", software_version " << software_version << ", error "
|
<< ret;
|
}
|
}
|
|
} // namespace common
|
|
} // namespace bluetooth
|
