1/******************************************************************************
2 *
3 *  Copyright 2016 Google, Inc.
4 *
5 *  Licensed under the Apache License, Version 2.0 (the "License");
6 *  you may not use this file except in compliance with the License.
7 *  You may obtain a copy of the License at:
8 *
9 *  http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 *
17 ******************************************************************************/
18#define LOG_TAG "bt_osi_metrics"
19
20#include <unistd.h>
21#include <algorithm>
22#include <array>
23#include <cerrno>
24#include <chrono>
25#include <cstdint>
26#include <cstring>
27#include <memory>
28#include <mutex>
29
30#include <base/base64.h>
31#include <base/logging.h>
32
33#include "bluetooth/metrics/bluetooth.pb.h"
34#include "osi/include/leaky_bonded_queue.h"
35#include "osi/include/log.h"
36#include "osi/include/osi.h"
37#include "osi/include/time.h"
38#include "stack/include/btm_api_types.h"
39
40#include "osi/include/metrics.h"
41
42namespace system_bt_osi {
43
44using bluetooth::metrics::BluetoothMetricsProto::A2DPSession;
45using bluetooth::metrics::BluetoothMetricsProto::BluetoothLog;
46using bluetooth::metrics::BluetoothMetricsProto::BluetoothSession;
47using bluetooth::metrics::BluetoothMetricsProto::
48    BluetoothSession_ConnectionTechnologyType;
49using bluetooth::metrics::BluetoothMetricsProto::
50    BluetoothSession_DisconnectReasonType;
51using bluetooth::metrics::BluetoothMetricsProto::DeviceInfo;
52using bluetooth::metrics::BluetoothMetricsProto::DeviceInfo_DeviceType;
53using bluetooth::metrics::BluetoothMetricsProto::PairEvent;
54using bluetooth::metrics::BluetoothMetricsProto::ScanEvent;
55using bluetooth::metrics::BluetoothMetricsProto::ScanEvent_ScanTechnologyType;
56using bluetooth::metrics::BluetoothMetricsProto::ScanEvent_ScanEventType;
57using bluetooth::metrics::BluetoothMetricsProto::WakeEvent;
58using bluetooth::metrics::BluetoothMetricsProto::WakeEvent_WakeEventType;
59using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType;
60using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType_MIN;
61using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType_MAX;
62using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType_ARRAYSIZE;
63using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileType_IsValid;
64using bluetooth::metrics::BluetoothMetricsProto::HeadsetProfileConnectionStats;
65/*
66 * Get current OS boot time in millisecond
67 */
68static int64_t time_get_os_boottime_ms(void) {
69  return time_get_os_boottime_us() / 1000;
70}
71
72static float combine_averages(float avg_a, int64_t ct_a, float avg_b,
73                              int64_t ct_b) {
74  if (ct_a > 0 && ct_b > 0) {
75    return (avg_a * ct_a + avg_b * ct_b) / (ct_a + ct_b);
76  } else if (ct_b > 0) {
77    return avg_b;
78  } else {
79    return avg_a;
80  }
81}
82
83static int32_t combine_averages(int32_t avg_a, int64_t ct_a, int32_t avg_b,
84                                int64_t ct_b) {
85  if (ct_a > 0 && ct_b > 0) {
86    return (avg_a * ct_a + avg_b * ct_b) / (ct_a + ct_b);
87  } else if (ct_b > 0) {
88    return avg_b;
89  } else {
90    return avg_a;
91  }
92}
93
94void A2dpSessionMetrics::Update(const A2dpSessionMetrics& metrics) {
95  if (metrics.audio_duration_ms >= 0) {
96    audio_duration_ms = std::max(static_cast<int64_t>(0), audio_duration_ms);
97    audio_duration_ms += metrics.audio_duration_ms;
98  }
99  if (metrics.media_timer_min_ms >= 0) {
100    if (media_timer_min_ms < 0) {
101      media_timer_min_ms = metrics.media_timer_min_ms;
102    } else {
103      media_timer_min_ms =
104          std::min(media_timer_min_ms, metrics.media_timer_min_ms);
105    }
106  }
107  if (metrics.media_timer_max_ms >= 0) {
108    media_timer_max_ms =
109        std::max(media_timer_max_ms, metrics.media_timer_max_ms);
110  }
111  if (metrics.media_timer_avg_ms >= 0 && metrics.total_scheduling_count >= 0) {
112    if (media_timer_avg_ms < 0 || total_scheduling_count < 0) {
113      media_timer_avg_ms = metrics.media_timer_avg_ms;
114      total_scheduling_count = metrics.total_scheduling_count;
115    } else {
116      media_timer_avg_ms = combine_averages(
117          media_timer_avg_ms, total_scheduling_count,
118          metrics.media_timer_avg_ms, metrics.total_scheduling_count);
119      total_scheduling_count += metrics.total_scheduling_count;
120    }
121  }
122  if (metrics.buffer_overruns_max_count >= 0) {
123    buffer_overruns_max_count =
124        std::max(buffer_overruns_max_count, metrics.buffer_overruns_max_count);
125  }
126  if (metrics.buffer_overruns_total >= 0) {
127    buffer_overruns_total =
128        std::max(static_cast<int32_t>(0), buffer_overruns_total);
129    buffer_overruns_total += metrics.buffer_overruns_total;
130  }
131  if (metrics.buffer_underruns_average >= 0 &&
132      metrics.buffer_underruns_count >= 0) {
133    if (buffer_underruns_average < 0 || buffer_underruns_count < 0) {
134      buffer_underruns_average = metrics.buffer_underruns_average;
135      buffer_underruns_count = metrics.buffer_underruns_count;
136    } else {
137      buffer_underruns_average = combine_averages(
138          buffer_underruns_average, buffer_underruns_count,
139          metrics.buffer_underruns_average, metrics.buffer_underruns_count);
140      buffer_underruns_count += metrics.buffer_underruns_count;
141    }
142  }
143}
144
145bool A2dpSessionMetrics::operator==(const A2dpSessionMetrics& rhs) const {
146  return audio_duration_ms == rhs.audio_duration_ms &&
147         media_timer_min_ms == rhs.media_timer_min_ms &&
148         media_timer_max_ms == rhs.media_timer_max_ms &&
149         media_timer_avg_ms == rhs.media_timer_avg_ms &&
150         total_scheduling_count == rhs.total_scheduling_count &&
151         buffer_overruns_max_count == rhs.buffer_overruns_max_count &&
152         buffer_overruns_total == rhs.buffer_overruns_total &&
153         buffer_underruns_average == rhs.buffer_underruns_average &&
154         buffer_underruns_count == rhs.buffer_underruns_count;
155}
156
157static DeviceInfo_DeviceType get_device_type(device_type_t type) {
158  switch (type) {
159    case DEVICE_TYPE_BREDR:
160      return DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_BREDR;
161    case DEVICE_TYPE_LE:
162      return DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_LE;
163    case DEVICE_TYPE_DUMO:
164      return DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_DUMO;
165    case DEVICE_TYPE_UNKNOWN:
166    default:
167      return DeviceInfo_DeviceType::DeviceInfo_DeviceType_DEVICE_TYPE_UNKNOWN;
168  }
169}
170
171static BluetoothSession_ConnectionTechnologyType get_connection_tech_type(
172    connection_tech_t type) {
173  switch (type) {
174    case CONNECTION_TECHNOLOGY_TYPE_LE:
175      return BluetoothSession_ConnectionTechnologyType::
176          BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_LE;
177    case CONNECTION_TECHNOLOGY_TYPE_BREDR:
178      return BluetoothSession_ConnectionTechnologyType::
179          BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_BREDR;
180    case CONNECTION_TECHNOLOGY_TYPE_UNKNOWN:
181    default:
182      return BluetoothSession_ConnectionTechnologyType::
183          BluetoothSession_ConnectionTechnologyType_CONNECTION_TECHNOLOGY_TYPE_UNKNOWN;
184  }
185}
186
187static ScanEvent_ScanTechnologyType get_scan_tech_type(scan_tech_t type) {
188  switch (type) {
189    case SCAN_TECH_TYPE_LE:
190      return ScanEvent_ScanTechnologyType::
191          ScanEvent_ScanTechnologyType_SCAN_TECH_TYPE_LE;
192    case SCAN_TECH_TYPE_BREDR:
193      return ScanEvent_ScanTechnologyType::
194          ScanEvent_ScanTechnologyType_SCAN_TECH_TYPE_BREDR;
195    case SCAN_TECH_TYPE_BOTH:
196      return ScanEvent_ScanTechnologyType::
197          ScanEvent_ScanTechnologyType_SCAN_TECH_TYPE_BOTH;
198    case SCAN_TYPE_UNKNOWN:
199    default:
200      return ScanEvent_ScanTechnologyType::
201          ScanEvent_ScanTechnologyType_SCAN_TYPE_UNKNOWN;
202  }
203}
204
205static WakeEvent_WakeEventType get_wake_event_type(wake_event_type_t type) {
206  switch (type) {
207    case WAKE_EVENT_ACQUIRED:
208      return WakeEvent_WakeEventType::WakeEvent_WakeEventType_ACQUIRED;
209    case WAKE_EVENT_RELEASED:
210      return WakeEvent_WakeEventType::WakeEvent_WakeEventType_RELEASED;
211    case WAKE_EVENT_UNKNOWN:
212    default:
213      return WakeEvent_WakeEventType::WakeEvent_WakeEventType_UNKNOWN;
214  }
215}
216
217static BluetoothSession_DisconnectReasonType get_disconnect_reason_type(
218    disconnect_reason_t type) {
219  switch (type) {
220    case DISCONNECT_REASON_METRICS_DUMP:
221      return BluetoothSession_DisconnectReasonType::
222          BluetoothSession_DisconnectReasonType_METRICS_DUMP;
223    case DISCONNECT_REASON_NEXT_START_WITHOUT_END_PREVIOUS:
224      return BluetoothSession_DisconnectReasonType::
225          BluetoothSession_DisconnectReasonType_NEXT_START_WITHOUT_END_PREVIOUS;
226    case DISCONNECT_REASON_UNKNOWN:
227    default:
228      return BluetoothSession_DisconnectReasonType::
229          BluetoothSession_DisconnectReasonType_UNKNOWN;
230  }
231}
232
233struct BluetoothMetricsLogger::impl {
234  impl(size_t max_bluetooth_session, size_t max_pair_event,
235       size_t max_wake_event, size_t max_scan_event)
236      : bt_session_queue_(
237            new LeakyBondedQueue<BluetoothSession>(max_bluetooth_session)),
238        pair_event_queue_(new LeakyBondedQueue<PairEvent>(max_pair_event)),
239        wake_event_queue_(new LeakyBondedQueue<WakeEvent>(max_wake_event)),
240        scan_event_queue_(new LeakyBondedQueue<ScanEvent>(max_scan_event)) {
241    bluetooth_log_ = BluetoothLog::default_instance().New();
242    headset_profile_connection_counts_.fill(0);
243    bluetooth_session_ = nullptr;
244    bluetooth_session_start_time_ms_ = 0;
245    a2dp_session_metrics_ = A2dpSessionMetrics();
246  }
247
248  /* Bluetooth log lock protected */
249  BluetoothLog* bluetooth_log_;
250  std::array<int, HeadsetProfileType_ARRAYSIZE>
251      headset_profile_connection_counts_;
252  std::recursive_mutex bluetooth_log_lock_;
253  /* End Bluetooth log lock protected */
254  /* Bluetooth session lock protected */
255  BluetoothSession* bluetooth_session_;
256  uint64_t bluetooth_session_start_time_ms_;
257  A2dpSessionMetrics a2dp_session_metrics_;
258  std::recursive_mutex bluetooth_session_lock_;
259  /* End bluetooth session lock protected */
260  std::unique_ptr<LeakyBondedQueue<BluetoothSession>> bt_session_queue_;
261  std::unique_ptr<LeakyBondedQueue<PairEvent>> pair_event_queue_;
262  std::unique_ptr<LeakyBondedQueue<WakeEvent>> wake_event_queue_;
263  std::unique_ptr<LeakyBondedQueue<ScanEvent>> scan_event_queue_;
264};
265
266BluetoothMetricsLogger::BluetoothMetricsLogger()
267    : pimpl_(new impl(kMaxNumBluetoothSession, kMaxNumPairEvent,
268                      kMaxNumWakeEvent, kMaxNumScanEvent)) {}
269
270void BluetoothMetricsLogger::LogPairEvent(uint32_t disconnect_reason,
271                                          uint64_t timestamp_ms,
272                                          uint32_t device_class,
273                                          device_type_t device_type) {
274  PairEvent* event = new PairEvent();
275  DeviceInfo* info = event->mutable_device_paired_with();
276  info->set_device_class(device_class);
277  info->set_device_type(get_device_type(device_type));
278  event->set_disconnect_reason(disconnect_reason);
279  event->set_event_time_millis(timestamp_ms);
280  pimpl_->pair_event_queue_->Enqueue(event);
281  {
282    std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
283    pimpl_->bluetooth_log_->set_num_pair_event(
284        pimpl_->bluetooth_log_->num_pair_event() + 1);
285  }
286}
287
288void BluetoothMetricsLogger::LogWakeEvent(wake_event_type_t type,
289                                          const std::string& requestor,
290                                          const std::string& name,
291                                          uint64_t timestamp_ms) {
292  WakeEvent* event = new WakeEvent();
293  event->set_wake_event_type(get_wake_event_type(type));
294  event->set_requestor(requestor);
295  event->set_name(name);
296  event->set_event_time_millis(timestamp_ms);
297  pimpl_->wake_event_queue_->Enqueue(event);
298  {
299    std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
300    pimpl_->bluetooth_log_->set_num_wake_event(
301        pimpl_->bluetooth_log_->num_wake_event() + 1);
302  }
303}
304
305void BluetoothMetricsLogger::LogScanEvent(bool start,
306                                          const std::string& initator,
307                                          scan_tech_t type, uint32_t results,
308                                          uint64_t timestamp_ms) {
309  ScanEvent* event = new ScanEvent();
310  if (start) {
311    event->set_scan_event_type(ScanEvent::SCAN_EVENT_START);
312  } else {
313    event->set_scan_event_type(ScanEvent::SCAN_EVENT_STOP);
314  }
315  event->set_initiator(initator);
316  event->set_scan_technology_type(get_scan_tech_type(type));
317  event->set_number_results(results);
318  event->set_event_time_millis(timestamp_ms);
319  pimpl_->scan_event_queue_->Enqueue(event);
320  {
321    std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
322    pimpl_->bluetooth_log_->set_num_scan_event(
323        pimpl_->bluetooth_log_->num_scan_event() + 1);
324  }
325}
326
327void BluetoothMetricsLogger::LogBluetoothSessionStart(
328    connection_tech_t connection_tech_type, uint64_t timestamp_ms) {
329  std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
330  if (pimpl_->bluetooth_session_ != nullptr) {
331    LogBluetoothSessionEnd(DISCONNECT_REASON_NEXT_START_WITHOUT_END_PREVIOUS,
332                           0);
333  }
334  if (timestamp_ms == 0) {
335    timestamp_ms = time_get_os_boottime_ms();
336  }
337  pimpl_->bluetooth_session_start_time_ms_ = timestamp_ms;
338  pimpl_->bluetooth_session_ = new BluetoothSession();
339  pimpl_->bluetooth_session_->set_connection_technology_type(
340      get_connection_tech_type(connection_tech_type));
341}
342
343void BluetoothMetricsLogger::LogBluetoothSessionEnd(
344    disconnect_reason_t disconnect_reason, uint64_t timestamp_ms) {
345  std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
346  if (pimpl_->bluetooth_session_ == nullptr) {
347    return;
348  }
349  if (timestamp_ms == 0) {
350    timestamp_ms = time_get_os_boottime_ms();
351  }
352  int64_t session_duration_sec =
353      (timestamp_ms - pimpl_->bluetooth_session_start_time_ms_) / 1000;
354  pimpl_->bluetooth_session_->set_session_duration_sec(session_duration_sec);
355  pimpl_->bluetooth_session_->set_disconnect_reason_type(
356      get_disconnect_reason_type(disconnect_reason));
357  pimpl_->bt_session_queue_->Enqueue(pimpl_->bluetooth_session_);
358  pimpl_->bluetooth_session_ = nullptr;
359  {
360    std::lock_guard<std::recursive_mutex> log_lock(pimpl_->bluetooth_log_lock_);
361    pimpl_->bluetooth_log_->set_num_bluetooth_session(
362        pimpl_->bluetooth_log_->num_bluetooth_session() + 1);
363  }
364}
365
366void BluetoothMetricsLogger::LogBluetoothSessionDeviceInfo(
367    uint32_t device_class, device_type_t device_type) {
368  std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
369  if (pimpl_->bluetooth_session_ == nullptr) {
370    LogBluetoothSessionStart(CONNECTION_TECHNOLOGY_TYPE_UNKNOWN, 0);
371  }
372  DeviceInfo* info = pimpl_->bluetooth_session_->mutable_device_connected_to();
373  info->set_device_class(device_class);
374  info->set_device_type(DeviceInfo::DEVICE_TYPE_BREDR);
375}
376
377void BluetoothMetricsLogger::LogA2dpSession(
378    const A2dpSessionMetrics& a2dp_session_metrics) {
379  std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
380  if (pimpl_->bluetooth_session_ == nullptr) {
381    // When no bluetooth session exist, create one on system's behalf
382    // Set connection type: for A2DP it is always BR/EDR
383    LogBluetoothSessionStart(CONNECTION_TECHNOLOGY_TYPE_BREDR, 0);
384    LogBluetoothSessionDeviceInfo(BTM_COD_MAJOR_AUDIO, DEVICE_TYPE_BREDR);
385  }
386  // Accumulate metrics
387  pimpl_->a2dp_session_metrics_.Update(a2dp_session_metrics);
388  // Get or allocate new A2DP session object
389  A2DPSession* a2dp_session =
390      pimpl_->bluetooth_session_->mutable_a2dp_session();
391  a2dp_session->set_audio_duration_millis(
392      pimpl_->a2dp_session_metrics_.audio_duration_ms);
393  a2dp_session->set_media_timer_min_millis(
394      pimpl_->a2dp_session_metrics_.media_timer_min_ms);
395  a2dp_session->set_media_timer_max_millis(
396      pimpl_->a2dp_session_metrics_.media_timer_max_ms);
397  a2dp_session->set_media_timer_avg_millis(
398      pimpl_->a2dp_session_metrics_.media_timer_avg_ms);
399  a2dp_session->set_buffer_overruns_max_count(
400      pimpl_->a2dp_session_metrics_.buffer_overruns_max_count);
401  a2dp_session->set_buffer_overruns_total(
402      pimpl_->a2dp_session_metrics_.buffer_overruns_total);
403  a2dp_session->set_buffer_underruns_average(
404      pimpl_->a2dp_session_metrics_.buffer_underruns_average);
405  a2dp_session->set_buffer_underruns_count(
406      pimpl_->a2dp_session_metrics_.buffer_underruns_count);
407}
408
409void BluetoothMetricsLogger::LogHeadsetProfileRfcConnection(
410    tBTA_SERVICE_ID service_id) {
411  std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
412  switch (service_id) {
413    case BTA_HSP_SERVICE_ID:
414      pimpl_->headset_profile_connection_counts_[HeadsetProfileType::HSP]++;
415      break;
416    case BTA_HFP_SERVICE_ID:
417      pimpl_->headset_profile_connection_counts_[HeadsetProfileType::HFP]++;
418      break;
419    default:
420      pimpl_->headset_profile_connection_counts_
421          [HeadsetProfileType::HEADSET_PROFILE_UNKNOWN]++;
422      break;
423  }
424  return;
425}
426
427void BluetoothMetricsLogger::WriteString(std::string* serialized) {
428  std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
429  LOG_DEBUG(LOG_TAG, "%s building metrics", __func__);
430  Build();
431  LOG_DEBUG(LOG_TAG, "%s serializing metrics", __func__);
432  if (!pimpl_->bluetooth_log_->SerializeToString(serialized)) {
433    LOG_ERROR(LOG_TAG, "%s: error serializing metrics", __func__);
434  }
435  // Always clean up log objects
436  pimpl_->bluetooth_log_->Clear();
437}
438
439void BluetoothMetricsLogger::WriteBase64String(std::string* serialized) {
440  this->WriteString(serialized);
441  base::Base64Encode(*serialized, serialized);
442}
443
444void BluetoothMetricsLogger::WriteBase64(int fd) {
445  std::string protoBase64;
446  this->WriteBase64String(&protoBase64);
447  ssize_t ret;
448  OSI_NO_INTR(ret = write(fd, protoBase64.c_str(), protoBase64.size()));
449  if (ret == -1) {
450    LOG_ERROR(LOG_TAG, "%s: error writing to dumpsys fd: %s (%d)", __func__,
451              strerror(errno), errno);
452  }
453}
454
455void BluetoothMetricsLogger::CutoffSession() {
456  std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
457  if (pimpl_->bluetooth_session_ != nullptr) {
458    BluetoothSession* new_bt_session =
459        new BluetoothSession(*pimpl_->bluetooth_session_);
460    new_bt_session->clear_a2dp_session();
461    new_bt_session->clear_rfcomm_session();
462    LogBluetoothSessionEnd(DISCONNECT_REASON_METRICS_DUMP, 0);
463    pimpl_->bluetooth_session_ = new_bt_session;
464    pimpl_->bluetooth_session_start_time_ms_ = time_get_os_boottime_ms();
465    pimpl_->a2dp_session_metrics_ = A2dpSessionMetrics();
466  }
467}
468
469void BluetoothMetricsLogger::Build() {
470  std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
471  CutoffSession();
472  BluetoothLog* bluetooth_log = pimpl_->bluetooth_log_;
473  while (!pimpl_->bt_session_queue_->Empty() &&
474         static_cast<size_t>(bluetooth_log->session_size()) <=
475             pimpl_->bt_session_queue_->Capacity()) {
476    bluetooth_log->mutable_session()->AddAllocated(
477        pimpl_->bt_session_queue_->Dequeue());
478  }
479  while (!pimpl_->pair_event_queue_->Empty() &&
480         static_cast<size_t>(bluetooth_log->pair_event_size()) <=
481             pimpl_->pair_event_queue_->Capacity()) {
482    bluetooth_log->mutable_pair_event()->AddAllocated(
483        pimpl_->pair_event_queue_->Dequeue());
484  }
485  while (!pimpl_->scan_event_queue_->Empty() &&
486         static_cast<size_t>(bluetooth_log->scan_event_size()) <=
487             pimpl_->scan_event_queue_->Capacity()) {
488    bluetooth_log->mutable_scan_event()->AddAllocated(
489        pimpl_->scan_event_queue_->Dequeue());
490  }
491  while (!pimpl_->wake_event_queue_->Empty() &&
492         static_cast<size_t>(bluetooth_log->wake_event_size()) <=
493             pimpl_->wake_event_queue_->Capacity()) {
494    bluetooth_log->mutable_wake_event()->AddAllocated(
495        pimpl_->wake_event_queue_->Dequeue());
496  }
497  while (!pimpl_->bt_session_queue_->Empty() &&
498         static_cast<size_t>(bluetooth_log->wake_event_size()) <=
499             pimpl_->wake_event_queue_->Capacity()) {
500    bluetooth_log->mutable_wake_event()->AddAllocated(
501        pimpl_->wake_event_queue_->Dequeue());
502  }
503  for (size_t i = 0; i < HeadsetProfileType_ARRAYSIZE; ++i) {
504    int num_times_connected = pimpl_->headset_profile_connection_counts_[i];
505    if (HeadsetProfileType_IsValid(i) && num_times_connected > 0) {
506      HeadsetProfileConnectionStats* headset_profile_connection_stats =
507          bluetooth_log->add_headset_profile_connection_stats();
508      // Able to static_cast because HeadsetProfileType_IsValid(i) is true
509      headset_profile_connection_stats->set_headset_profile_type(
510          static_cast<HeadsetProfileType>(i));
511      headset_profile_connection_stats->set_num_times_connected(
512          num_times_connected);
513    }
514  }
515  pimpl_->headset_profile_connection_counts_.fill(0);
516}
517
518void BluetoothMetricsLogger::ResetSession() {
519  std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_session_lock_);
520  if (pimpl_->bluetooth_session_ != nullptr) {
521    delete pimpl_->bluetooth_session_;
522    pimpl_->bluetooth_session_ = nullptr;
523  }
524  pimpl_->bluetooth_session_start_time_ms_ = 0;
525  pimpl_->a2dp_session_metrics_ = A2dpSessionMetrics();
526}
527
528void BluetoothMetricsLogger::ResetLog() {
529  std::lock_guard<std::recursive_mutex> lock(pimpl_->bluetooth_log_lock_);
530  pimpl_->bluetooth_log_->Clear();
531}
532
533void BluetoothMetricsLogger::Reset() {
534  ResetSession();
535  ResetLog();
536  pimpl_->bt_session_queue_->Clear();
537  pimpl_->pair_event_queue_->Clear();
538  pimpl_->wake_event_queue_->Clear();
539  pimpl_->scan_event_queue_->Clear();
540}
541
542}  // namespace system_bt_osi
543