Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d9fd43e6 authored by Jakub Pawlowski's avatar Jakub Pawlowski Committed by android-build-merger
Browse files

Remove unused battery level support am: 29d85a29 

am: 6a61ba13

Change-Id: I1e948147ad4247dfa902ce71cc49f918039ca673
parents 050bca0a 6a61ba13

system/stack/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -174,7 +174,6 @@ cc_library_static { 
        "smp/smp_l2c.cc",

        "smp/smp_main.cc",

        "smp/smp_utils.cc",

        "srvc/srvc_battery.cc",

        "srvc/srvc_dis.cc",

        "srvc/srvc_eng.cc",

    ],

system/stack/BUILD.gn

+0 −1
Original line number Diff line number Diff line
@@ -158,7 +158,6 @@ static_library("stack") { 
    "smp/smp_l2c.cc",

    "smp/smp_main.cc",

    "smp/smp_utils.cc",

    "srvc/srvc_battery.cc",

    "srvc/srvc_dis.cc",

    "srvc/srvc_eng.cc",

  ]

system/stack/include/srvc_api.h

+0 −31
Original line number Diff line number Diff line
@@ -165,35 +165,4 @@ extern tDIS_STATUS DIS_SrUpdate(tDIS_ATTR_BIT dis_attr_bit, tDIS_ATTR* p_info); 
extern bool DIS_ReadDISInfo(const RawAddress& peer_bda,

                            tDIS_READ_CBACK* p_cback, tDIS_ATTR_MASK mask);



/*******************************************************************************

 *      BATTERY SERVICE API

 ******************************************************************************/

/*******************************************************************************

 *

 * Function         Battery_Instantiate

 *

 * Description      Instantiate a Battery service

 *

 ******************************************************************************/

extern uint16_t Battery_Instantiate(uint8_t app_id, tBA_REG_INFO* p_reg_info);



/*******************************************************************************

 *

 * Function         Battery_Rsp

 *

 * Description      Respond to a battery service request

 *

 ******************************************************************************/

extern void Battery_Rsp(uint8_t app_id, tGATT_STATUS st, uint8_t event,

                        tBA_RSP_DATA* p_rsp);

/*******************************************************************************

 *

 * Function         Battery_Notify

 *

 * Description      Send battery level notification

 *

 ******************************************************************************/

extern void Battery_Notify(uint8_t app_id, const RawAddress& remote_bda,

                           uint8_t battery_level);



#endif

system/stack/srvc/srvc_battery.cc

deleted100644 → 0
+0 −362
Original line number Diff line number Diff line 
/******************************************************************************

 *

 *  Copyright 1999-2013 Broadcom Corporation

 *

 *  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 "bt_target.h"

#include "bt_utils.h"

#include "gatt_api.h"

#include "gatt_int.h"

#include "osi/include/osi.h"

#include "srvc_battery_int.h"

#include "srvc_eng_int.h"



#define BA_MAX_CHAR_NUM 1



/* max 3 descriptors, 1 desclration and 1 value */

#define BA_MAX_ATTR_NUM (BA_MAX_CHAR_NUM * 5 + 1)



#ifndef BATTER_LEVEL_PROP

#define BATTER_LEVEL_PROP (GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_NOTIFY)

#endif



#ifndef BATTER_LEVEL_PERM

#define BATTER_LEVEL_PERM (GATT_PERM_READ)

#endif



tBATTERY_CB battery_cb;



/*******************************************************************************

 *   battery_valid_handle_range

 *

 *   validate a handle to be a DIS attribute handle or not.

 ******************************************************************************/

bool battery_valid_handle_range(uint16_t handle) {

  uint8_t i = 0;

  tBA_INST* p_inst = &battery_cb.battery_inst[0];



  for (; i < BA_MAX_INT_NUM; i++, p_inst++) {

    if (handle == p_inst->ba_level_hdl || handle == p_inst->clt_cfg_hdl ||

        handle == p_inst->rpt_ref_hdl || handle == p_inst->pres_fmt_hdl) {

      return true;

    }

  }

  return false;

}

/*******************************************************************************

 *   battery_s_write_attr_value

 *

 *   Process write DIS attribute request.

 ******************************************************************************/

uint8_t battery_s_write_attr_value(uint8_t clcb_idx, tGATT_WRITE_REQ* p_value,

                                   tGATT_STATUS* p_status) {

  uint8_t *p = p_value->value, i;

  uint16_t handle = p_value->handle;

  tBA_INST* p_inst = &battery_cb.battery_inst[0];

  tGATT_STATUS st = GATT_NOT_FOUND;

  tBA_WRITE_DATA cfg;

  uint8_t act = SRVC_ACT_RSP;



  for (i = 0; i < BA_MAX_INT_NUM; i++, p_inst++) {

    /* read battery level */

    if (handle == p_inst->clt_cfg_hdl) {

      cfg.remote_bda = srvc_eng_cb.clcb[clcb_idx].bda;

      STREAM_TO_UINT16(cfg.clt_cfg, p);



      if (p_inst->p_cback) {

        p_inst->pending_clcb_idx = clcb_idx;

        p_inst->pending_evt = BA_WRITE_CLT_CFG_REQ;

        p_inst->pending_handle = handle;

        cfg.need_rsp = p_value->need_rsp;

        act = SRVC_ACT_PENDING;



        (*p_inst->p_cback)(p_inst->app_id, BA_WRITE_CLT_CFG_REQ, &cfg);

      }

    } else /* all other handle is not writable */

    {

      st = GATT_WRITE_NOT_PERMIT;

      break;

    }

  }

  *p_status = st;



  return act;

}

/*******************************************************************************

 *   BA Attributes Database Server Request callback

 ******************************************************************************/

uint8_t battery_s_read_attr_value(uint8_t clcb_idx, uint16_t handle,

                                  UNUSED_ATTR tGATT_VALUE* p_value,

                                  bool is_long, tGATT_STATUS* p_status) {

  uint8_t i;

  tBA_INST* p_inst = &battery_cb.battery_inst[0];

  tGATT_STATUS st = GATT_NOT_FOUND;

  uint8_t act = SRVC_ACT_RSP;



  for (i = 0; i < BA_MAX_INT_NUM; i++, p_inst++) {

    /* read battery level */

    if (handle == p_inst->ba_level_hdl || handle == p_inst->clt_cfg_hdl ||

        handle == p_inst->rpt_ref_hdl || handle == p_inst->pres_fmt_hdl) {

      if (is_long) st = GATT_NOT_LONG;



      if (p_inst->p_cback) {

        if (handle == p_inst->ba_level_hdl)

          p_inst->pending_evt = BA_READ_LEVEL_REQ;

        if (handle == p_inst->clt_cfg_hdl)

          p_inst->pending_evt = BA_READ_CLT_CFG_REQ;

        if (handle == p_inst->pres_fmt_hdl)

          p_inst->pending_evt = BA_READ_PRE_FMT_REQ;

        if (handle == p_inst->rpt_ref_hdl)

          p_inst->pending_evt = BA_READ_RPT_REF_REQ;



        p_inst->pending_clcb_idx = clcb_idx;

        p_inst->pending_handle = handle;

        act = SRVC_ACT_PENDING;



        (*p_inst->p_cback)(p_inst->app_id, p_inst->pending_evt, NULL);

      } else /* application is not registered */

        st = GATT_ERR_UNLIKELY;

      break;

    }

    /* else attribute not found */

  }



  *p_status = st;

  return act;

}



/*******************************************************************************

 *

 * Function         battery_gatt_c_read_ba_req

 *

 * Description      Read remote device BA level attribute request.

 *

 * Returns          void

 *

 ******************************************************************************/

bool battery_gatt_c_read_ba_req(UNUSED_ATTR uint16_t conn_id) { return true; }



/*******************************************************************************

 *

 * Function         battery_c_cmpl_cback

 *

 * Description      Client operation complete callback.

 *

 * Returns          void

 *

 ******************************************************************************/

void battery_c_cmpl_cback(UNUSED_ATTR tSRVC_CLCB* p_clcb,

                          UNUSED_ATTR tGATTC_OPTYPE op,

                          UNUSED_ATTR tGATT_STATUS status,

                          UNUSED_ATTR tGATT_CL_COMPLETE* p_data) {}



/*******************************************************************************

 *

 * Function         Battery_Instantiate

 *

 * Description      Instantiate a Battery service

 *

 ******************************************************************************/

uint16_t Battery_Instantiate(uint8_t app_id, tBA_REG_INFO* p_reg_info) {

  uint16_t srvc_hdl = 0;

  tGATT_STATUS status = GATT_ERROR;

  tBA_INST* p_inst;



  if (battery_cb.inst_id == BA_MAX_INT_NUM) {

    LOG(ERROR) << "MAX battery service has been reached";

    return 0;

  }



  p_inst = &battery_cb.battery_inst[battery_cb.inst_id];



  btgatt_db_element_t service[BA_MAX_ATTR_NUM] = {};



  bluetooth::Uuid service_uuid =

      bluetooth::Uuid::From16Bit(UUID_SERVCLASS_BATTERY);

  service[0].type = /* p_reg_info->is_pri */ BTGATT_DB_PRIMARY_SERVICE;

  service[0].uuid = service_uuid;



  bluetooth::Uuid char_uuid =

      bluetooth::Uuid::From16Bit(GATT_UUID_BATTERY_LEVEL);

  service[1].type = BTGATT_DB_CHARACTERISTIC;

  service[1].uuid = char_uuid;

  service[1].properties = GATT_CHAR_PROP_BIT_READ;

  if (p_reg_info->ba_level_descr & BA_LEVEL_NOTIFY)

    service[1].properties |= GATT_CHAR_PROP_BIT_NOTIFY;



  int i = 2;

  if (p_reg_info->ba_level_descr & BA_LEVEL_NOTIFY) {

    bluetooth::Uuid desc_uuid =

        bluetooth::Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG);



    service[i].type = BTGATT_DB_DESCRIPTOR;

    service[i].uuid = desc_uuid;

    service[i].permissions = (GATT_PERM_READ | GATT_PERM_WRITE);

    i++;

  }



  /* need presentation format descriptor? */

  if (p_reg_info->ba_level_descr & BA_LEVEL_PRE_FMT) {

    bluetooth::Uuid desc_uuid =

        bluetooth::Uuid::From16Bit(GATT_UUID_CHAR_PRESENT_FORMAT);



    service[i].type = BTGATT_DB_DESCRIPTOR;

    service[i].uuid = desc_uuid;

    service[i].permissions = GATT_PERM_READ;

    i++;

  }



  /* need presentation format descriptor? */

  if (p_reg_info->ba_level_descr & BA_LEVEL_RPT_REF) {

    bluetooth::Uuid desc_uuid =

        bluetooth::Uuid::From16Bit(GATT_UUID_RPT_REF_DESCR);



    service[i].type = BTGATT_DB_DESCRIPTOR;

    service[i].uuid = desc_uuid;

    service[i].permissions = GATT_PERM_READ;

    i++;

  }



  GATTS_AddService(srvc_eng_cb.gatt_if, service, i);



  if (status != GATT_SUCCESS) {

    battery_cb.inst_id--;

    LOG(ERROR) << __func__ << " Failed to add battery servuce!";

  }



  battery_cb.inst_id++;



  p_inst->app_id = app_id;

  p_inst->p_cback = p_reg_info->p_cback;



  srvc_hdl = service[0].attribute_handle;

  p_inst->ba_level_hdl = service[1].attribute_handle;



  i = 2;

  if (p_reg_info->ba_level_descr & BA_LEVEL_NOTIFY) {

    p_inst->clt_cfg_hdl = service[i].attribute_handle;

    i++;

  }



  if (p_reg_info->ba_level_descr & BA_LEVEL_PRE_FMT) {

    p_inst->pres_fmt_hdl = service[i].attribute_handle;

    i++;

  }



  if (p_reg_info->ba_level_descr & BA_LEVEL_RPT_REF) {

    p_inst->rpt_ref_hdl = service[i].attribute_handle;

    i++;

  }



  return srvc_hdl;

}

/*******************************************************************************

 *

 * Function         Battery_Rsp

 *

 * Description      Respond to a battery service request

 *

 ******************************************************************************/

void Battery_Rsp(uint8_t app_id, tGATT_STATUS st, uint8_t event,

                 tBA_RSP_DATA* p_rsp) {

  tBA_INST* p_inst = &battery_cb.battery_inst[0];

  tGATTS_RSP rsp;

  uint8_t* pp;



  uint8_t i = 0;

  while (i < BA_MAX_INT_NUM) {

    if (p_inst->app_id == app_id && p_inst->ba_level_hdl != 0) break;

    i++;

  }



  if (i == BA_MAX_INT_NUM) return;



  memset(&rsp, 0, sizeof(tGATTS_RSP));



  if (p_inst->pending_evt == event) {

    switch (event) {

      case BA_READ_CLT_CFG_REQ:

        rsp.attr_value.handle = p_inst->pending_handle;

        rsp.attr_value.len = 2;

        pp = rsp.attr_value.value;

        UINT16_TO_STREAM(pp, p_rsp->clt_cfg);

        srvc_sr_rsp(p_inst->pending_clcb_idx, st, &rsp);

        break;



      case BA_READ_LEVEL_REQ:

        rsp.attr_value.handle = p_inst->pending_handle;

        rsp.attr_value.len = 1;

        pp = rsp.attr_value.value;

        UINT8_TO_STREAM(pp, p_rsp->ba_level);

        srvc_sr_rsp(p_inst->pending_clcb_idx, st, &rsp);

        break;



      case BA_WRITE_CLT_CFG_REQ:

        srvc_sr_rsp(p_inst->pending_clcb_idx, st, NULL);

        break;



      case BA_READ_RPT_REF_REQ:

        rsp.attr_value.handle = p_inst->pending_handle;

        rsp.attr_value.len = 2;

        pp = rsp.attr_value.value;

        UINT8_TO_STREAM(pp, p_rsp->rpt_ref.rpt_id);

        UINT8_TO_STREAM(pp, p_rsp->rpt_ref.rpt_type);

        srvc_sr_rsp(p_inst->pending_clcb_idx, st, &rsp);

        break;



      default:

        break;

    }

    p_inst->pending_clcb_idx = 0;

    p_inst->pending_evt = 0;

    p_inst->pending_handle = 0;

  }

  return;

}

/*******************************************************************************

 *

 * Function         Battery_Notify

 *

 * Description      Send battery level notification

 *

 ******************************************************************************/

void Battery_Notify(uint8_t app_id, const RawAddress& remote_bda,

                    uint8_t battery_level) {

  tBA_INST* p_inst = &battery_cb.battery_inst[0];

  uint8_t i = 0;



  while (i < BA_MAX_INT_NUM) {

    if (p_inst->app_id == app_id && p_inst->ba_level_hdl != 0) break;

    i++;

  }



  if (i == BA_MAX_INT_NUM || p_inst->clt_cfg_hdl == 0) return;



  srvc_sr_notify(remote_bda, p_inst->ba_level_hdl, 1, &battery_level);

}

/*******************************************************************************

 *

 * Function         Battery_ReadBatteryLevel

 *

 * Description      Read remote device Battery Level information.

 *

 * Returns          void

 *

 ******************************************************************************/

bool Battery_ReadBatteryLevel(const RawAddress&) {

  /* to be implemented */

  return true;

}

system/stack/srvc/srvc_battery_int.h

deleted100644 → 0
+0 −66
Original line number Diff line number Diff line 
/******************************************************************************

 *

 *  Copyright 1999-2012 Broadcom Corporation

 *

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

 *

 ******************************************************************************/



#ifndef SRVC_BATTERY_INT_H

#define SRVC_BATTERY_INT_H



#include "bt_target.h"

#include "gatt_api.h"

#include "srvc_api.h"



#ifndef BA_MAX_INT_NUM

#define BA_MAX_INT_NUM 4

#endif



#define BATTERY_LEVEL_SIZE 1



typedef struct {

  uint8_t app_id;

  uint16_t ba_level_hdl;

  uint16_t clt_cfg_hdl;

  uint16_t rpt_ref_hdl;

  uint16_t pres_fmt_hdl;



  tBA_CBACK* p_cback;



  uint16_t pending_handle;

  uint8_t pending_clcb_idx;

  uint8_t pending_evt;



} tBA_INST;



typedef struct {

  tBA_INST battery_inst[BA_MAX_INT_NUM];

  uint8_t inst_id;

  bool enabled;



} tBATTERY_CB;



/* Global GATT data */

extern tBATTERY_CB battery_cb;



extern bool battery_valid_handle_range(uint16_t handle);



extern uint8_t battery_s_write_attr_value(uint8_t clcb_idx,

                                          tGATT_WRITE_REQ* p_value,

                                          tGATT_STATUS* p_status);

extern uint8_t battery_s_read_attr_value(uint8_t clcb_idx, uint16_t handle,

                                         tGATT_VALUE* p_value, bool is_long,

                                         tGATT_STATUS* p_status);



#endif