#ifndef LOCKER_H
#define LOCKER_H#ifdef __cplusplus
extern "C"
{
#endif#define SERVAPP_NUM_ATTR_SUPPORTED              (1+4+3)// Simple Profile Service UUID
#define LOCKERPROFILE_SERV_UUID                 0xFFF0#define LOCKERPROFILE_NOTIFY_UUID               0xFFF1
#define LOCKERPROFILE_NOTIFY_MAX_LEN            5  #define LOCKERPROFILE_STREAM_UUID               0xFFF2
#define LOCKERPROFILE_STREAM_MAX_LEN            5  #define SIMPLEPROFILE_SERVICE               0x00000001
/********************************************************************** Profile Callbacks*/
// Callback when a characteristic value has changed
typedef void (*app_input_cb_t)( uint16 uuid ,uint8 *pdata, int len);/********************************************************************** lockerProfile_AddService- Initializes the Simple GATT Profile service by registering*          GATT attributes with the GATT server.* @param   services - services to add. This is a bit map and can contain more than one service.* @param   cb - the function will be called, while service receive a message .
* return    always return SUCCESS*/
bStatus_t lockerProfile_AddService( uint32 services ,app_input_cb_t cb);
/** lockerProfile_AddService - Set a Simple GATT Profile parameter.*    uuid - which service's uuid as sender target*    len - length of data to right*    value - pointer to data to write.  This is dependent on*          the parameter uuid and WILL be cast to the appropriate *          data type .*/
bStatus_t locker_send( uint16 uuid,void *pdata , uint8 len);
/** locker_Read - Get a Simple GATT Profile parameter by uuid.*    param - Profile uuid*    value - pointer to data to write.  This is dependent on*          the parameter ID and WILL be cast to the appropriate *          data type .
*   return : return data length, if op' failse it'll return -1;*/
int locker_Read( uint16 uuid, void *pdata );#ifdef __cplusplus
}
#endif#endif /* SIMPLEGATTPROFILE_H */

/********************************************************************** INCLUDES*/
#include "bcomdef.h"
#include "OSAL.h"
#include "linkdb.h"
#include "att.h"
#include "gatt.h"
#include "gatt_uuid.h"
#include "gattservapp.h"
#include "gapbondmgr.h"#include "locker.h"
#include "stdio.h"/********************************************************************** GLOBAL VARIABLES*/
// Simple GATT Profile Service UUID: 0xFFF0
CONST uint8 lockerSvrUUID[ATT_BT_UUID_SIZE] =
{ LO_UINT16(LOCKERPROFILE_SERV_UUID), HI_UINT16(LOCKERPROFILE_SERV_UUID)
};
// notify UUID: 0xFFF1
CONST uint8 lockerNotifyUUID[ATT_BT_UUID_SIZE] =
{ LO_UINT16(LOCKERPROFILE_NOTIFY_UUID), HI_UINT16(LOCKERPROFILE_NOTIFY_UUID)
};
// stream UUID: 0xFFF2
CONST uint8 lockerStreamUUID[ATT_BT_UUID_SIZE] =
{ LO_UINT16(LOCKERPROFILE_STREAM_UUID), HI_UINT16(LOCKERPROFILE_STREAM_UUID)
};
/********************************************************************** LOCAL VARIABLES*/
static app_input_cb_t app_input_cb = NULL;
/********************************************************************** Profile Attributes - variables*/
// locker Profile Service attribute
static CONST gattAttrType_t lockerProfileService = { ATT_BT_UUID_SIZE, lockerSvrUUID };// locker Profile Notify Properties
static uint8 lockerNotifyProps = GATT_PROP_NOTIFY;
static uint8 lockerNotifyStream[LOCKERPROFILE_NOTIFY_MAX_LEN];
static uint8 lockerNotifyDesp[17] = "notify\0";
static gattCharCfg_t lockerNotifyConfig[GATT_MAX_NUM_CONN];    // locker Profile Stream Properties
static uint8 lockerStreamProps = GATT_PROP_READ | GATT_PROP_WRITE;
static uint8 lockerStream[LOCKERPROFILE_STREAM_MAX_LEN];
static uint8 lockerStreamDesp[17] = "stream\0";
/********************************************************************** Profile Attributes - Table*/static gattAttribute_t LockerProfileAttrTbl[SERVAPP_NUM_ATTR_SUPPORTED] =
{// Simple Profile Service{ { ATT_BT_UUID_SIZE, primaryServiceUUID }, /* type */GATT_PERMIT_READ,                         /* permissions */0,                                        /* handle */(uint8 *)&lockerProfileService            /* pValue */},/**************notify attribute**********************/// notify  Declaration{ { ATT_BT_UUID_SIZE, characterUUID },GATT_PERMIT_READ, 0,&lockerNotifyProps },// notify stream buffer { { ATT_BT_UUID_SIZE, lockerNotifyUUID },0, 0, lockerNotifyStream },// notify stream  configuration{ { ATT_BT_UUID_SIZE, clientCharCfgUUID },GATT_PERMIT_READ | GATT_PERMIT_WRITE, 0, (uint8 *)lockerNotifyConfig },// notify stream  Description{ { ATT_BT_UUID_SIZE, charUserDescUUID },GATT_PERMIT_READ, 0, lockerNotifyDesp },     /************************stream buffer attribute***********************/// stream  Declaration{ { ATT_BT_UUID_SIZE, characterUUID },GATT_PERMIT_READ, 0,&lockerStreamProps },// stream buffer { { ATT_BT_UUID_SIZE, lockerStreamUUID },GATT_PERMIT_READ | GATT_PERMIT_WRITE, 0, lockerStream },//  stream  Description{ { ATT_BT_UUID_SIZE, charUserDescUUID },GATT_PERMIT_READ, 0, lockerStreamDesp },
};/********************************************************************** LOCAL FUNCTIONS*/
static uint8 lockerReadAttrCB( uint16 connHandle, gattAttribute_t *pAttr, uint8 *pValue, uint8 *pLen, uint16 offset, uint8 maxLen );
static bStatus_t lockerWriteAttrCB( uint16 connHandle, gattAttribute_t *pAttr,uint8 *pValue, uint8 len, uint16 offset );static void lockerHandleConnStatusCB( uint16 connHandle, uint8 changeType );/********************************************************************** PROFILE CALLBACKS*/
// Simple Profile Service Callbacks
CONST gattServiceCBs_t lockerProfileCBs =
{lockerReadAttrCB,  // Read callback function pointerlockerWriteAttrCB, // Write callback function pointerNULL                       // Authorization callback function pointer
};bStatus_t lockerProfile_AddService( uint32 services ,app_input_cb_t cb)
{uint8 status = SUCCESS;printf("lockerProfile_AddService:  \n");// Initialize Client Characteristic Configuration attributesGATTServApp_InitCharCfg( INVALID_CONNHANDLE, lockerNotifyConfig );// Register with Link DB to receive link status change callbackVOID linkDB_Register( lockerHandleConnStatusCB );  if ( services & SIMPLEPROFILE_SERVICE ){// Register GATT attribute list and CBs with GATT Server Appstatus = GATTServApp_RegisterService( LockerProfileAttrTbl, GATT_NUM_ATTRS( LockerProfileAttrTbl ),&lockerProfileCBs );}app_input_cb = cb;return ( status );
}
bStatus_t locker_send( uint16 uuid,void *pdata , uint8 len)
{bStatus_t ret = SUCCESS;switch ( uuid ){case LOCKERPROFILE_NOTIFY_UUID:if ( len <= LOCKERPROFILE_NOTIFY_MAX_LEN) {printf("locker_send: uuid:%04x notify app \n",uuid);osal_memcpy(lockerNotifyStream,pdata,len);GATTServApp_ProcessCharCfg(lockerNotifyConfig,lockerNotifyStream, FALSE,LockerProfileAttrTbl, GATT_NUM_ATTRS( LockerProfileAttrTbl ),INVALID_TASK_ID );}else{ret = bleInvalidRange;}break;case LOCKERPROFILE_STREAM_UUID:if ( len <= LOCKERPROFILE_STREAM_MAX_LEN) {printf("locker_Send: uuid:%04x write to stream buffer and waite to read \n",uuid);osal_memcpy(lockerStream,pdata,len);}else{ret = bleInvalidRange;}    default:ret = INVALIDPARAMETER;break;}return ( ret );
}int locker_Read( uint16 uuid, void *pdata )
{int ret;printf("locker_Read: uuid:%04x \n",uuid);switch ( uuid ){case LOCKERPROFILE_NOTIFY_UUID:osal_memcpy(pdata,lockerNotifyStream,LOCKERPROFILE_NOTIFY_MAX_LEN);ret = LOCKERPROFILE_NOTIFY_MAX_LEN;break;case LOCKERPROFILE_STREAM_UUID:osal_memcpy(pdata,lockerStream,LOCKERPROFILE_STREAM_MAX_LEN);ret = LOCKERPROFILE_NOTIFY_MAX_LEN;break;default:ret = -1;break;}return ( ret );
}static uint8 lockerReadAttrCB( uint16 connHandle, gattAttribute_t *pAttr, uint8 *pValue, uint8 *pLen, uint16 offset, uint8 maxLen )
{bStatus_t status = SUCCESS;// If attribute permissions require authorization to read, return errorif ( gattPermitAuthorRead( pAttr->permissions ) ){// Insufficient authorizationreturn ( ATT_ERR_INSUFFICIENT_AUTHOR );}// Make sure it's not a blob operation (no attributes in the profile are long)if ( offset > 0 ){return ( ATT_ERR_ATTR_NOT_LONG );}if ( pAttr->type.len == ATT_BT_UUID_SIZE ){// 16-bit UUIDuint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);printf("lockerProfile_ReadAttrCB: uuid:%04x \n",uuid);switch ( uuid ){// No need for "GATT_SERVICE_UUID" or "GATT_CLIENT_CHAR_CFG_UUID" cases;// gattserverapp handles those reads// characteristics 1 and 2 have read permissions//   can be sent as a notification, it is included herecase LOCKERPROFILE_NOTIFY_UUID:*pLen = LOCKERPROFILE_NOTIFY_MAX_LEN;osal_memcpy(pValue,pAttr->pValue,LOCKERPROFILE_NOTIFY_MAX_LEN);break;    case LOCKERPROFILE_STREAM_UUID:*pLen = LOCKERPROFILE_STREAM_MAX_LEN;osal_memcpy(pValue,pAttr->pValue,LOCKERPROFILE_STREAM_MAX_LEN);break;default:// Should never get here! (characteristics 3 and 4 do not have read permissions)*pLen = 0;status = ATT_ERR_ATTR_NOT_FOUND;break;}}else{// 128-bit UUID*pLen = 0;status = ATT_ERR_INVALID_HANDLE;}return ( status );
}static bStatus_t lockerWriteAttrCB( uint16 connHandle, gattAttribute_t *pAttr,uint8 *pValue, uint8 len, uint16 offset )
{bStatus_t status = SUCCESS;// If attribute permissions require authorization to write, return errorif ( gattPermitAuthorWrite( pAttr->permissions ) ){// Insufficient authorizationreturn ( ATT_ERR_INSUFFICIENT_AUTHOR );}if ( pAttr->type.len == ATT_BT_UUID_SIZE ){// 16-bit UUIDuint16 uuid = BUILD_UINT16( pAttr->type.uuid[0], pAttr->type.uuid[1]);printf("lockerProfile_WriteAttrCB: uuid:%04x \n",uuid);switch ( uuid ){case LOCKERPROFILE_NOTIFY_UUID:status = ATT_ERR_INVALID_HANDLE;//Write the value           break;case LOCKERPROFILE_STREAM_UUID:if((offset==0)&(app_input_cb!=NULL)){if(len<=LOCKERPROFILE_STREAM_MAX_LEN)osal_memcpy(lockerStream,pValue,len);app_input_cb(LOCKERPROFILE_STREAM_UUID,pValue,len);}break;case GATT_CLIENT_CHAR_CFG_UUID:status = GATTServApp_ProcessCCCWriteReq( connHandle, pAttr, pValue, len,offset, GATT_CLIENT_CFG_NOTIFY );break;       default:// Should never get here! (characteristics 2 and 4 do not have write permissions)status = ATT_ERR_ATTR_NOT_FOUND;break;}}else{// 128-bit UUIDstatus = ATT_ERR_INVALID_HANDLE;}return ( status );
}
static void lockerHandleConnStatusCB( uint16 connHandle, uint8 changeType )
{ // Make sure this is not loopback connectionif ( connHandle != LOOPBACK_CONNHANDLE ){// Reset Client Char Config if connection has droppedif ( ( changeType == LINKDB_STATUS_UPDATE_REMOVED )      ||( ( changeType == LINKDB_STATUS_UPDATE_STATEFLAGS ) && ( !linkDB_Up( connHandle ) ) ) ){ printf("lockerProfile_HandleConnStatusCB: Reset Client Char Config if connection has dropped \n");GATTServApp_InitCharCfg( connHandle, lockerNotifyConfig );}}
}/*********************************************************************
*********************************************************************/

void input(uint16 uuid, uint8 *pdata , int  len)
{int i;printf("input from uuid: %04x len:%d data:",uuid,len);for(i=0;i<len;i++)printf("%02x ",pdata[i]);printf("\n");
}

void SimpleBLEPeripheral_Init( uint8 task_id )
{simpleBLEPeripheral_TaskID = task_id;// Setup the GAPVOID GAP_SetParamValue( TGAP_CONN_PAUSE_PERIPHERAL, DEFAULT_CONN_PAUSE_PERIPHERAL );// Setup the GAP Peripheral Role Profile{uint8 initial_advertising_enable = TRUE;// By setting this to zero, the device will go into the waiting state after// being discoverable for 30.72 second, and will not being advertising again// until the enabler is set back to TRUEuint16 gapRole_AdvertOffTime = 0;uint8 enable_update_request = DEFAULT_ENABLE_UPDATE_REQUEST;uint16 desired_min_interval = DEFAULT_DESIRED_MIN_CONN_INTERVAL;uint16 desired_max_interval = DEFAULT_DESIRED_MAX_CONN_INTERVAL;uint16 desired_slave_latency = DEFAULT_DESIRED_SLAVE_LATENCY;uint16 desired_conn_timeout = DEFAULT_DESIRED_CONN_TIMEOUT;// Set the GAP Role ParametersGAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &initial_advertising_enable );GAPRole_SetParameter( GAPROLE_ADVERT_OFF_TIME, sizeof( uint16 ), &gapRole_AdvertOffTime );GAPRole_SetParameter( GAPROLE_SCAN_RSP_DATA, sizeof ( scanRspData ), scanRspData );GAPRole_SetParameter( GAPROLE_ADVERT_DATA, sizeof( advertData ), advertData );GAPRole_SetParameter( GAPROLE_PARAM_UPDATE_ENABLE, sizeof( uint8 ), &enable_update_request );GAPRole_SetParameter( GAPROLE_MIN_CONN_INTERVAL, sizeof( uint16 ), &desired_min_interval );GAPRole_SetParameter( GAPROLE_MAX_CONN_INTERVAL, sizeof( uint16 ), &desired_max_interval );GAPRole_SetParameter( GAPROLE_SLAVE_LATENCY, sizeof( uint16 ), &desired_slave_latency );GAPRole_SetParameter( GAPROLE_TIMEOUT_MULTIPLIER, sizeof( uint16 ), &desired_conn_timeout );}// Set the GAP CharacteristicsGGS_SetParameter( GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, attDeviceName );// Set advertising interval{uint16 advInt = DEFAULT_ADVERTISING_INTERVAL;GAP_SetParamValue( TGAP_LIM_DISC_ADV_INT_MIN, advInt );GAP_SetParamValue( TGAP_LIM_DISC_ADV_INT_MAX, advInt );GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, advInt );GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, advInt );}// Setup the GAP Bond Manager{uint32 passkey = 0; // passkey "000000"uint8 pairMode = GAPBOND_PAIRING_MODE_WAIT_FOR_REQ;uint8 mitm = TRUE;uint8 ioCap = GAPBOND_IO_CAP_DISPLAY_ONLY;uint8 bonding = TRUE;GAPBondMgr_SetParameter( GAPBOND_DEFAULT_PASSCODE, sizeof ( uint32 ), &passkey );GAPBondMgr_SetParameter( GAPBOND_PAIRING_MODE, sizeof ( uint8 ), &pairMode );GAPBondMgr_SetParameter( GAPBOND_MITM_PROTECTION, sizeof ( uint8 ), &mitm );GAPBondMgr_SetParameter( GAPBOND_IO_CAPABILITIES, sizeof ( uint8 ), &ioCap );GAPBondMgr_SetParameter( GAPBOND_BONDING_ENABLED, sizeof ( uint8 ), &bonding );}// Initialize GATT attributesGGS_AddService( GATT_ALL_SERVICES );            // GAPGATTServApp_AddService( GATT_ALL_SERVICES );    // GATT attributesDevInfo_AddService();                           // Device Information ServicelockerProfile_AddService( GATT_ALL_SERVICES,input);  // Simple GATT Profile// Register for all key events - This app will handle all key eventsRegisterForKeys( simpleBLEPeripheral_TaskID );// Enable clock divide on halt// This reduces active current while radio is active and CC254x MCU// is haltedHCI_EXT_ClkDivOnHaltCmd( HCI_EXT_ENABLE_CLK_DIVIDE_ON_HALT );// Setup a delayed profile startuposal_set_event( simpleBLEPeripheral_TaskID, SBP_START_DEVICE_EVT );}