common/metrics.h - platform/system/bt - Git at Google

 /******************************************************************************
  *
  *  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.
  *
  ******************************************************************************/

 #pragma once

 #include <android/bluetooth/hci/enums.pb.h>
 #include <bta/include/bta_api.h>
 #include <frameworks/base/core/proto/android/bluetooth/enums.pb.h>
 #include <stdint.h>
 #include <memory>
 #include <string>

 namespace bluetooth {

 namespace common {

 // Typedefs to hide protobuf definition to the rest of stack

 typedef enum {
   DEVICE_TYPE_UNKNOWN,
   DEVICE_TYPE_BREDR,
   DEVICE_TYPE_LE,
   DEVICE_TYPE_DUMO,
 } device_type_t;

 typedef enum {
   WAKE_EVENT_UNKNOWN,
   WAKE_EVENT_ACQUIRED,
   WAKE_EVENT_RELEASED,
 } wake_event_type_t;

 typedef enum {
   SCAN_TYPE_UNKNOWN,
   SCAN_TECH_TYPE_LE,
   SCAN_TECH_TYPE_BREDR,
   SCAN_TECH_TYPE_BOTH,
 } scan_tech_t;

 typedef enum {
   CONNECTION_TECHNOLOGY_TYPE_UNKNOWN,
   CONNECTION_TECHNOLOGY_TYPE_LE,
   CONNECTION_TECHNOLOGY_TYPE_BREDR,
 } connection_tech_t;

 typedef enum {
   DISCONNECT_REASON_UNKNOWN,
   DISCONNECT_REASON_METRICS_DUMP,
   DISCONNECT_REASON_NEXT_START_WITHOUT_END_PREVIOUS,
 } disconnect_reason_t;

 /* Values of A2DP metrics that we care about
  *
  *    audio_duration_ms : sum of audio duration (in milliseconds).
  *    device_class: device class of the paired device.
  *    media_timer_min_ms : minimum scheduled time (in milliseconds)
  *                         of the media timer.
  *    media_timer_max_ms: maximum scheduled time (in milliseconds)
  *                        of the media timer.
  *    media_timer_avg_ms: average scheduled time (in milliseconds)
  *                        of the media timer.
  *    buffer_overruns_max_count: TODO - not clear what this is.
  *    buffer_overruns_total : number of times the media buffer with
  *                            audio data has overrun
  *    buffer_underruns_average: TODO - not clear what this is.
  *    buffer_underruns_count: number of times there was no enough
  *                            audio data to add to the media buffer.
  * NOTE: Negative values are invalid
  */
 class A2dpSessionMetrics {
  public:
   A2dpSessionMetrics() {}

   /*
    * Update the metrics value in the current metrics object using the metrics
    * objects supplied
    */
   void Update(const A2dpSessionMetrics& metrics);

   /*
    * Compare whether two metrics objects are equal
    */
   bool operator==(const A2dpSessionMetrics& rhs) const;

   /*
    * Initialize all values to -1 which is invalid in order to make a distinction
    * between 0 and invalid values
    */
   int64_t audio_duration_ms = -1;
   int32_t media_timer_min_ms = -1;
   int32_t media_timer_max_ms = -1;
   int32_t media_timer_avg_ms = -1;
   int64_t total_scheduling_count = -1;
   int32_t buffer_overruns_max_count = -1;
   int32_t buffer_overruns_total = -1;
   float buffer_underruns_average = -1;
   int32_t buffer_underruns_count = -1;
   int64_t codec_index = -1;
   bool is_a2dp_offload = false;
 };

 class BluetoothMetricsLogger {
  public:
   static BluetoothMetricsLogger* GetInstance() {
     static BluetoothMetricsLogger* instance = new BluetoothMetricsLogger();
     return instance;
   }

   /*
    * Record a pairing event
    *
    * Parameters:
    *    timestamp_ms: Unix epoch time in milliseconds
    *    device_class: class of remote device
    *    device_type: type of remote device
    *    disconnect_reason: HCI reason for pairing disconnection.
    *                       See: stack/include/hcidefs.h
    */
   void LogPairEvent(uint32_t disconnect_reason, uint64_t timestamp_ms,
                     uint32_t device_class, device_type_t device_type);

   /*
    * Record a wake event
    *
    * Parameters:
    *    timestamp_ms: Unix epoch time in milliseconds
    *    type: whether it was acquired or released
    *    requestor: if provided is the service requesting the wake lock
    *    name: the name of the wake lock held
    */
   void LogWakeEvent(wake_event_type_t type, const std::string& requestor,
                     const std::string& name, uint64_t timestamp_ms);

   /*
    * Record a scan event
    *
    * Parameters
    *    timestamp_ms : Unix epoch time in milliseconds
    *    start : true if this is the beginning of the scan
    *    initiator: a unique ID identifying the app starting the scan
    *    type: whether the scan reports BR/EDR, LE, or both.
    *    results: number of results to be reported.
    */
   void LogScanEvent(bool start, const std::string& initator, scan_tech_t type,
                     uint32_t results, uint64_t timestamp_ms);

   /*
    * Start logging a Bluetooth session
    *
    * A Bluetooth session is defined a a connection between this device and
    * another remote device which may include multiple profiles and protocols
    *
    * Only one Bluetooth session can exist at one time. Calling this method twice
    * without LogBluetoothSessionEnd will result in logging a premature end of
    * current Bluetooth session
    *
    * Parameters:
    *    connection_tech_type : type of connection technology
    *    timestamp_ms : the timestamp for session start, 0 means now
    *
    */
   void LogBluetoothSessionStart(connection_tech_t connection_tech_type,
                                 uint64_t timestamp_ms);

   /*
    * Stop logging a Bluetooth session and pushes it to the log queue
    *
    * If no Bluetooth session exist, this method exits immediately
    *
    * Parameters:
    *    disconnect_reason : A string representation of disconnect reason
    *    timestamp_ms : the timestamp of session end, 0 means now
    *
    */
   void LogBluetoothSessionEnd(disconnect_reason_t disconnect_reason,
                               uint64_t timestamp_ms);

   /*
    * Log information about remote device in a current Bluetooth session
    *
    * If a Bluetooth session does not exist, create one with default parameter
    * and timestamp now
    *
    * Parameters:
    *    device_class : device_class defined in btm_api_types.h
    *    device_type : type of remote device
    */
   void LogBluetoothSessionDeviceInfo(uint32_t device_class,
                                      device_type_t device_type);

   /*
    * Log A2DP Audio Session Information
    *
    * - Repeated calls to this method will override previous metrics if in the
    *   same Bluetooth connection
    * - If a Bluetooth session does not exist, create one with default parameter
    *   and timestamp now
    *
    * Parameters:
    *    a2dp_session_metrics - pointer to struct holding a2dp stats
    *
    */
   void LogA2dpSession(const A2dpSessionMetrics& a2dp_session_metrics);

   /**
    * Log Headset profile RFCOMM connection event
    *
    * @param service_id the BTA service ID for this headset connection
    */
   void LogHeadsetProfileRfcConnection(tBTA_SERVICE_ID service_id);

   /*
    * Writes the metrics, in base64 protobuf format, into the descriptor FD,
    * metrics events are always cleared after dump
    */
   void WriteBase64(int fd);
   void WriteBase64String(std::string* serialized);
   void WriteString(std::string* serialized);

   /*
    * Reset the metrics logger by cleaning up its staging queues and existing
    * protobuf objects.
    */
   void Reset();

   /*
    * Maximum number of log entries for each session or event
    */
   static const size_t kMaxNumBluetoothSession = 50;
   static const size_t kMaxNumPairEvent = 50;
   static const size_t kMaxNumWakeEvent = 1000;
   static const size_t kMaxNumScanEvent = 50;

  private:
   BluetoothMetricsLogger();

   /*
    * When a Bluetooth session is on and the user initiates a metrics dump, we
    * need to be able to upload whatever we have first. This method breaks the
    * ongoing Bluetooth session into two sessions with the previous one labeled
    * as "METRICS_DUMP" for the disconnect reason.
    */
   void CutoffSession();

   /*
    * Build the internal metrics object using information gathered
    */
   void Build();

   /*
    * Reset objects related to current Bluetooth session
    */
   void ResetSession();

   /*
    * Reset the underlining BluetoothLog object
    */
   void ResetLog();

   /*
    * PIMPL style implementation to hide internal dependencies
    */
   struct impl;
   std::unique_ptr<impl> const pimpl_;
 };

 /**
  * Unknown connection handle for metrics purpose
  */
 static const uint32_t kUnknownConnectionHandle = 0xFFFF;

 /**
  * Log link layer connection event
  *
  * @param address Stack wide consistent Bluetooth address of this event,
  *                nullptr if unknown
  * @param connection_handle connection handle of this event,
  *                          {@link kUnknownConnectionHandle} if unknown
  * @param direction direction of this connection
  * @param link_type type of the link
  * @param hci_cmd HCI command opecode associated with this event, if any
  * @param hci_event HCI event code associated with this event, if any
  * @param hci_ble_event HCI BLE event code associated with this event, if any
  * @param cmd_status Command status associated with this event, if any
  * @param reason_code Reason code associated with this event, if any
  */
 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);

 /**
  * Logs when Bluetooth controller failed to reply with command status within
  * a timeout period after receiving an HCI command from the host
  *
  * @param hci_cmd opcode of HCI command that caused this timeout
  */
 void LogHciTimeoutEvent(uint32_t hci_cmd);

 /**
  * Logs when we receive Bluetooth Read Remote Version Information Complete
  * Event from the remote device, as documented by the Bluetooth Core HCI
  * specification
  *
  * Reference: 5.0 Core Specification, Vol 2, Part E, Page 1118
  *
  * @param handle handle of associated ACL connection
  * @param status HCI command status of this event
  * @param version version code from read remote version complete event
  * @param manufacturer_name manufacturer code from read remote version complete
  *                          event
  * @param subversion subversion code from read remote version complete event
  */
 void LogRemoteVersionInfo(uint16_t handle, uint8_t status, uint8_t version,
                           uint16_t manufacturer_name, uint16_t subversion);

 /**
  * Log A2DP audio buffer underrun event
  *
  * @param address A2DP device associated with this event
  * @param encoding_interval_millis encoding interval in milliseconds
  * @param num_missing_pcm_bytes number of PCM bytes that cannot be read from
  *                              the source
  */
 void LogA2dpAudioUnderrunEvent(const RawAddress& address,
                                uint64_t encoding_interval_millis,
                                int num_missing_pcm_bytes);

 /**
  * Log A2DP audio buffer overrun event
  *
  * @param address A2DP device associated with this event
  * @param encoding_interval_millis encoding interval in milliseconds
  * @param num_dropped_buffers number of encoded buffers dropped from Tx queue
  * @param num_dropped_encoded_frames number of encoded frames dropped from Tx
  *                                   queue
  * @param num_dropped_encoded_bytes number of encoded bytes dropped from Tx
  *                                  queue
  */
 void LogA2dpAudioOverrunEvent(const RawAddress& address,
                               uint64_t encoding_interval_millis,
                               int num_dropped_buffers,
                               int num_dropped_encoded_frames,
                               int num_dropped_encoded_bytes);

 /**
  * Log read RSSI result
  *
  * @param address device associated with this event
  * @param handle connection handle of this event,
  *               {@link kUnknownConnectionHandle} if unknown
  * @param cmd_status command status from read RSSI command
  * @param rssi rssi value in dBm
  */
 void LogReadRssiResult(const RawAddress& address, uint16_t handle,
                        uint32_t cmd_status, int8_t rssi);

 /**
  * Log failed contact counter report
  *
  * @param address device associated with this event
  * @param handle connection handle of this event,
  *               {@link kUnknownConnectionHandle} if unknown
  * @param cmd_status command status from read failed contact counter command
  * @param failed_contact_counter Number of consecutive failed contacts for a
  *                               connection corresponding to the Handle
  */
 void LogReadFailedContactCounterResult(const RawAddress& address,
                                        uint16_t handle, uint32_t cmd_status,
                                        int32_t failed_contact_counter);

 /**
  * Log transmit power level for a particular device after read
  *
  * @param address device associated with this event
  * @param handle connection handle of this event,
  *               {@link kUnknownConnectionHandle} if unknown
  * @param cmd_status command status from read failed contact counter command
  * @param transmit_power_level transmit power level for connection to this
  *                             device
  */
 void LogReadTxPowerLevelResult(const RawAddress& address, uint16_t handle,
                                uint32_t cmd_status,
                                int32_t transmit_power_level);

 /**
  * Logs when there is an event related to Bluetooth Security Manager Protocol
  *
  * @param address address of associated device
  * @param smp_cmd SMP command code associated with this event
  * @param direction direction of this SMP command
  * @param smp_fail_reason SMP pairing failure reason code from SMP spec
  */
 void LogSmpPairingEvent(const RawAddress& address, uint8_t smp_cmd,
                         android::bluetooth::DirectionEnum direction,
                         uint8_t smp_fail_reason);

 /**
  * Logs there is an event related Bluetooth classic pairing
  *
  * @param address address of associated device
  * @param handle connection handle of this event,
  *               {@link kUnknownConnectionHandle} if unknown
  * @param hci_cmd HCI command associated with this event
  * @param hci_event HCI event associated with this event
  * @param cmd_status Command status associated with this event
  * @param reason_code Reason code associated with this event
  * @param event_value A status value related to this specific event
  */
 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);

 /**
  * Logs when certain Bluetooth SDP attributes are discovered
  *
  * @param address address of associated device
  * @param protocol_uuid 16 bit protocol UUID from Bluetooth Assigned Numbers
  * @param attribute_id 16 bit attribute ID from Bluetooth Assigned Numbers
  * @param attribute_size size of this attribute
  * @param attribute_value pointer to the attribute data, must be larger than
  *                        attribute_size
  */
 void LogSdpAttribute(const RawAddress& address, uint16_t protocol_uuid,
                      uint16_t attribute_id, size_t attribute_size,
                      const char* attribute_value);

 /**
  * Logs when there is a change in Bluetooth socket connection state
  *
  * @param address address of associated device, empty if this is a server port
  * @param port port of this socket connection
  * @param type type of socket
  * @param connection_state socket connection state
  * @param tx_bytes number of bytes transmitted
  * @param rx_bytes number of bytes received
  * @param server_port server port of this socket, if any. When both
  *        |server_port| and |port| fields are populated, |port| must be spawned
  *        by |server_port|
  * @param socket_role role of this socket, server or connection
  * @param uid socket owner's uid
  */
 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);

 /**
  * Logs when a Bluetooth device's manufacturer information is learnt
  *
  * @param address address of associated device
  * @param source_type where is this device info obtained from
  * @param source_name name of the data source, internal or external
  * @param manufacturer name of the manufacturer of this device
  * @param model model of this device
  * @param hardware_version hardware version of this device
  * @param software_version software version of this device
  */
 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);
 }  // namespace common

 }  // namespace bluetooth
	/******************************************************************************
	*
	* 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.
	*
	******************************************************************************/

	#pragma once

	#include <android/bluetooth/hci/enums.pb.h>
	#include <bta/include/bta_api.h>
	#include <frameworks/base/core/proto/android/bluetooth/enums.pb.h>
	#include <stdint.h>
	#include <memory>
	#include <string>

	namespace bluetooth {

	namespace common {

	// Typedefs to hide protobuf definition to the rest of stack

	typedef enum {
	DEVICE_TYPE_UNKNOWN,
	DEVICE_TYPE_BREDR,
	DEVICE_TYPE_LE,
	DEVICE_TYPE_DUMO,
	} device_type_t;

	typedef enum {
	WAKE_EVENT_UNKNOWN,
	WAKE_EVENT_ACQUIRED,
	WAKE_EVENT_RELEASED,
	} wake_event_type_t;

	typedef enum {
	SCAN_TYPE_UNKNOWN,
	SCAN_TECH_TYPE_LE,
	SCAN_TECH_TYPE_BREDR,
	SCAN_TECH_TYPE_BOTH,
	} scan_tech_t;

	typedef enum {
	CONNECTION_TECHNOLOGY_TYPE_UNKNOWN,
	CONNECTION_TECHNOLOGY_TYPE_LE,
	CONNECTION_TECHNOLOGY_TYPE_BREDR,
	} connection_tech_t;

	typedef enum {
	DISCONNECT_REASON_UNKNOWN,
	DISCONNECT_REASON_METRICS_DUMP,
	DISCONNECT_REASON_NEXT_START_WITHOUT_END_PREVIOUS,
	} disconnect_reason_t;

	/* Values of A2DP metrics that we care about
	*
	* audio_duration_ms : sum of audio duration (in milliseconds).
	* device_class: device class of the paired device.
	* media_timer_min_ms : minimum scheduled time (in milliseconds)
	* of the media timer.
	* media_timer_max_ms: maximum scheduled time (in milliseconds)
	* of the media timer.
	* media_timer_avg_ms: average scheduled time (in milliseconds)
	* of the media timer.
	* buffer_overruns_max_count: TODO - not clear what this is.
	* buffer_overruns_total : number of times the media buffer with
	* audio data has overrun
	* buffer_underruns_average: TODO - not clear what this is.
	* buffer_underruns_count: number of times there was no enough
	* audio data to add to the media buffer.
	* NOTE: Negative values are invalid
	*/
	class A2dpSessionMetrics {
	public:
	A2dpSessionMetrics() {}

	/*
	* Update the metrics value in the current metrics object using the metrics
	* objects supplied
	*/
	void Update(const A2dpSessionMetrics& metrics);

	/*
	* Compare whether two metrics objects are equal
	*/
	bool operator==(const A2dpSessionMetrics& rhs) const;

	/*
	* Initialize all values to -1 which is invalid in order to make a distinction
	* between 0 and invalid values
	*/
	int64_t audio_duration_ms = -1;
	int32_t media_timer_min_ms = -1;
	int32_t media_timer_max_ms = -1;
	int32_t media_timer_avg_ms = -1;
	int64_t total_scheduling_count = -1;
	int32_t buffer_overruns_max_count = -1;
	int32_t buffer_overruns_total = -1;
	float buffer_underruns_average = -1;
	int32_t buffer_underruns_count = -1;
	int64_t codec_index = -1;
	bool is_a2dp_offload = false;
	};

	class BluetoothMetricsLogger {
	public:
	static BluetoothMetricsLogger* GetInstance() {
	static BluetoothMetricsLogger* instance = new BluetoothMetricsLogger();
	return instance;
	}

	/*
	* Record a pairing event
	*
	* Parameters:
	* timestamp_ms: Unix epoch time in milliseconds
	* device_class: class of remote device
	* device_type: type of remote device
	* disconnect_reason: HCI reason for pairing disconnection.
	* See: stack/include/hcidefs.h
	*/
	void LogPairEvent(uint32_t disconnect_reason, uint64_t timestamp_ms,
	uint32_t device_class, device_type_t device_type);

	/*
	* Record a wake event
	*
	* Parameters:
	* timestamp_ms: Unix epoch time in milliseconds
	* type: whether it was acquired or released
	* requestor: if provided is the service requesting the wake lock
	* name: the name of the wake lock held
	*/
	void LogWakeEvent(wake_event_type_t type, const std::string& requestor,
	const std::string& name, uint64_t timestamp_ms);

	/*
	* Record a scan event
	*
	* Parameters
	* timestamp_ms : Unix epoch time in milliseconds
	* start : true if this is the beginning of the scan
	* initiator: a unique ID identifying the app starting the scan
	* type: whether the scan reports BR/EDR, LE, or both.
	* results: number of results to be reported.
	*/
	void LogScanEvent(bool start, const std::string& initator, scan_tech_t type,
	uint32_t results, uint64_t timestamp_ms);

	/*
	* Start logging a Bluetooth session
	*
	* A Bluetooth session is defined a a connection between this device and
	* another remote device which may include multiple profiles and protocols
	*
	* Only one Bluetooth session can exist at one time. Calling this method twice
	* without LogBluetoothSessionEnd will result in logging a premature end of
	* current Bluetooth session
	*
	* Parameters:
	* connection_tech_type : type of connection technology
	* timestamp_ms : the timestamp for session start, 0 means now
	*
	*/
	void LogBluetoothSessionStart(connection_tech_t connection_tech_type,
	uint64_t timestamp_ms);

	/*
	* Stop logging a Bluetooth session and pushes it to the log queue
	*
	* If no Bluetooth session exist, this method exits immediately
	*
	* Parameters:
	* disconnect_reason : A string representation of disconnect reason
	* timestamp_ms : the timestamp of session end, 0 means now
	*
	*/
	void LogBluetoothSessionEnd(disconnect_reason_t disconnect_reason,
	uint64_t timestamp_ms);

	/*
	* Log information about remote device in a current Bluetooth session
	*
	* If a Bluetooth session does not exist, create one with default parameter
	* and timestamp now
	*
	* Parameters:
	* device_class : device_class defined in btm_api_types.h
	* device_type : type of remote device
	*/
	void LogBluetoothSessionDeviceInfo(uint32_t device_class,
	device_type_t device_type);

	/*
	* Log A2DP Audio Session Information
	*
	* - Repeated calls to this method will override previous metrics if in the
	* same Bluetooth connection
	* - If a Bluetooth session does not exist, create one with default parameter
	* and timestamp now
	*
	* Parameters:
	* a2dp_session_metrics - pointer to struct holding a2dp stats
	*
	*/
	void LogA2dpSession(const A2dpSessionMetrics& a2dp_session_metrics);

	/**
	* Log Headset profile RFCOMM connection event
	*
	* @param service_id the BTA service ID for this headset connection
	*/
	void LogHeadsetProfileRfcConnection(tBTA_SERVICE_ID service_id);

	/*
	* Writes the metrics, in base64 protobuf format, into the descriptor FD,
	* metrics events are always cleared after dump
	*/
	void WriteBase64(int fd);
	void WriteBase64String(std::string* serialized);
	void WriteString(std::string* serialized);

	/*
	* Reset the metrics logger by cleaning up its staging queues and existing
	* protobuf objects.
	*/
	void Reset();

	/*
	* Maximum number of log entries for each session or event
	*/
	static const size_t kMaxNumBluetoothSession = 50;
	static const size_t kMaxNumPairEvent = 50;
	static const size_t kMaxNumWakeEvent = 1000;
	static const size_t kMaxNumScanEvent = 50;

	private:
	BluetoothMetricsLogger();

	/*
	* When a Bluetooth session is on and the user initiates a metrics dump, we
	* need to be able to upload whatever we have first. This method breaks the
	* ongoing Bluetooth session into two sessions with the previous one labeled
	* as "METRICS_DUMP" for the disconnect reason.
	*/
	void CutoffSession();

	/*
	* Build the internal metrics object using information gathered
	*/
	void Build();

	/*
	* Reset objects related to current Bluetooth session
	*/
	void ResetSession();

	/*
	* Reset the underlining BluetoothLog object
	*/
	void ResetLog();

	/*
	* PIMPL style implementation to hide internal dependencies
	*/
	struct impl;
	std::unique_ptr<impl> const pimpl_;
	};

	/**
	* Unknown connection handle for metrics purpose
	*/
	static const uint32_t kUnknownConnectionHandle = 0xFFFF;

	/**
	* Log link layer connection event
	*
	* @param address Stack wide consistent Bluetooth address of this event,
	* nullptr if unknown
	* @param connection_handle connection handle of this event,
	* {@link kUnknownConnectionHandle} if unknown
	* @param direction direction of this connection
	* @param link_type type of the link
	* @param hci_cmd HCI command opecode associated with this event, if any
	* @param hci_event HCI event code associated with this event, if any
	* @param hci_ble_event HCI BLE event code associated with this event, if any
	* @param cmd_status Command status associated with this event, if any
	* @param reason_code Reason code associated with this event, if any
	*/
	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);

	/**
	* Logs when Bluetooth controller failed to reply with command status within
	* a timeout period after receiving an HCI command from the host
	*
	* @param hci_cmd opcode of HCI command that caused this timeout
	*/
	void LogHciTimeoutEvent(uint32_t hci_cmd);

	/**
	* Logs when we receive Bluetooth Read Remote Version Information Complete
	* Event from the remote device, as documented by the Bluetooth Core HCI
	* specification
	*
	* Reference: 5.0 Core Specification, Vol 2, Part E, Page 1118
	*
	* @param handle handle of associated ACL connection
	* @param status HCI command status of this event
	* @param version version code from read remote version complete event
	* @param manufacturer_name manufacturer code from read remote version complete
	* event
	* @param subversion subversion code from read remote version complete event
	*/
	void LogRemoteVersionInfo(uint16_t handle, uint8_t status, uint8_t version,
	uint16_t manufacturer_name, uint16_t subversion);

	/**
	* Log A2DP audio buffer underrun event
	*
	* @param address A2DP device associated with this event
	* @param encoding_interval_millis encoding interval in milliseconds
	* @param num_missing_pcm_bytes number of PCM bytes that cannot be read from
	* the source
	*/
	void LogA2dpAudioUnderrunEvent(const RawAddress& address,
	uint64_t encoding_interval_millis,
	int num_missing_pcm_bytes);

	/**
	* Log A2DP audio buffer overrun event
	*
	* @param address A2DP device associated with this event
	* @param encoding_interval_millis encoding interval in milliseconds
	* @param num_dropped_buffers number of encoded buffers dropped from Tx queue
	* @param num_dropped_encoded_frames number of encoded frames dropped from Tx
	* queue
	* @param num_dropped_encoded_bytes number of encoded bytes dropped from Tx
	* queue
	*/
	void LogA2dpAudioOverrunEvent(const RawAddress& address,
	uint64_t encoding_interval_millis,
	int num_dropped_buffers,
	int num_dropped_encoded_frames,
	int num_dropped_encoded_bytes);

	/**
	* Log read RSSI result
	*
	* @param address device associated with this event
	* @param handle connection handle of this event,
	* {@link kUnknownConnectionHandle} if unknown
	* @param cmd_status command status from read RSSI command
	* @param rssi rssi value in dBm
	*/
	void LogReadRssiResult(const RawAddress& address, uint16_t handle,
	uint32_t cmd_status, int8_t rssi);

	/**
	* Log failed contact counter report
	*
	* @param address device associated with this event
	* @param handle connection handle of this event,
	* {@link kUnknownConnectionHandle} if unknown
	* @param cmd_status command status from read failed contact counter command
	* @param failed_contact_counter Number of consecutive failed contacts for a
	* connection corresponding to the Handle
	*/
	void LogReadFailedContactCounterResult(const RawAddress& address,
	uint16_t handle, uint32_t cmd_status,
	int32_t failed_contact_counter);

	/**
	* Log transmit power level for a particular device after read
	*
	* @param address device associated with this event
	* @param handle connection handle of this event,
	* {@link kUnknownConnectionHandle} if unknown
	* @param cmd_status command status from read failed contact counter command
	* @param transmit_power_level transmit power level for connection to this
	* device
	*/
	void LogReadTxPowerLevelResult(const RawAddress& address, uint16_t handle,
	uint32_t cmd_status,
	int32_t transmit_power_level);

	/**
	* Logs when there is an event related to Bluetooth Security Manager Protocol
	*
	* @param address address of associated device
	* @param smp_cmd SMP command code associated with this event
	* @param direction direction of this SMP command
	* @param smp_fail_reason SMP pairing failure reason code from SMP spec
	*/
	void LogSmpPairingEvent(const RawAddress& address, uint8_t smp_cmd,
	android::bluetooth::DirectionEnum direction,
	uint8_t smp_fail_reason);

	/**
	* Logs there is an event related Bluetooth classic pairing
	*
	* @param address address of associated device
	* @param handle connection handle of this event,
	* {@link kUnknownConnectionHandle} if unknown
	* @param hci_cmd HCI command associated with this event
	* @param hci_event HCI event associated with this event
	* @param cmd_status Command status associated with this event
	* @param reason_code Reason code associated with this event
	* @param event_value A status value related to this specific event
	*/
	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);

	/**
	* Logs when certain Bluetooth SDP attributes are discovered
	*
	* @param address address of associated device
	* @param protocol_uuid 16 bit protocol UUID from Bluetooth Assigned Numbers
	* @param attribute_id 16 bit attribute ID from Bluetooth Assigned Numbers
	* @param attribute_size size of this attribute
	* @param attribute_value pointer to the attribute data, must be larger than
	* attribute_size
	*/
	void LogSdpAttribute(const RawAddress& address, uint16_t protocol_uuid,
	uint16_t attribute_id, size_t attribute_size,
	const char* attribute_value);

	/**
	* Logs when there is a change in Bluetooth socket connection state
	*
	* @param address address of associated device, empty if this is a server port
	* @param port port of this socket connection
	* @param type type of socket
	* @param connection_state socket connection state
	* @param tx_bytes number of bytes transmitted
	* @param rx_bytes number of bytes received
	* @param server_port server port of this socket, if any. When both
	* \|server_port\| and \|port\| fields are populated, \|port\| must be spawned
	* by \|server_port\|
	* @param socket_role role of this socket, server or connection
	* @param uid socket owner's uid
	*/
	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);

	/**
	* Logs when a Bluetooth device's manufacturer information is learnt
	*
	* @param address address of associated device
	* @param source_type where is this device info obtained from
	* @param source_name name of the data source, internal or external
	* @param manufacturer name of the manufacturer of this device
	* @param model model of this device
	* @param hardware_version hardware version of this device
	* @param software_version software version of this device
	*/
	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);
	} // namespace common

	} // namespace bluetooth