handle_pbap.c

藍芽電話簿範本

/****************************************************************************
Copyright (C) Cambridge Silicon Radio Limited 2006-2009
Part of BlueLab 4.1-Release

DESCRIPTION
	Implementation for handling PBAP library messages and functionality
	
FILE
	handle_pbap.c
	
*/

/****************************************************************************
    Header files
*/

#include <connection.h>
#include <pbaps.h>
#include <print.h>
#include <panic.h>
#include <pbap_common.h>
#include <stdlib.h>

#include "main.h"
#include "handle_pbap.h"
#include "handle_connection.h"
#include "folder.h"
#include "vcard_gen.h"
#include "pb_access.h"

/* Message Handler Prototypes */
static void handlePbapInitCfm(applicationTaskData *pTask, PBAPS_INIT_CFM_T *pMsg);
static void handlePbapConnectInd(applicationTaskData *pTask, PBAPS_CONNECT_IND_T *pMsg);
static void handlePbapConnectCfm(applicationTaskData *pTask, PBAPS_CONNECT_CFM_T *pMsg);
static void handlePbapDisconnectInd(applicationTaskData *pTask, PBAPS_DISCONNECT_IND_T *pMsg);

static void handlePbapSetPhoneBook(applicationTaskData *pTask, PBAPS_SET_PB_BOOK_IND_T *pMsg);
static void handlePbapSetParent(applicationTaskData *pTask, PBAPS_SET_PB_PARENT_IND_T *pMsg);
static void handlePbapSetRoot(applicationTaskData *pTask, PBAPS_SET_PB_ROOT_IND_T *pMsg);
static void handlePbapSetRepository(applicationTaskData *pTask, PBAPS_SET_PB_REPOSITORY_IND_T *pMsg);

static void handlePbapGetVCardListStartInd(applicationTaskData *pTask, PBAPS_GET_VCARD_LIST_START_IND_T *pMsg);
static void handlePbapGetVCardListNextInd(applicationTaskData *pTask, PBAPS_GET_VCARD_LIST_NEXT_IND_T *pMsg);
static void handlePbapGetVCardListCompleteInd(applicationTaskData *pTask, PBAPS_GET_VCARD_LIST_COMPLETE_IND_T *pMsg);

static void handlePbapGetVCardEntryStartInd(applicationTaskData *pTask, PBAPS_GET_VCARD_ENTRY_START_IND_T *pMsg);
static void handlePbapGetVCardEntryNextInd(applicationTaskData *pTask, PBAPS_GET_VCARD_ENTRY_NEXT_IND_T *pMsg);
static void handlePbapGetVCardEntryCompleteInd(applicationTaskData *pTask, PBAPS_GET_VCARD_ENTRY_COMPLETE_IND_T *pMsg);

static void handlePbapGetPhonebookStartInd(applicationTaskData *pTask, PBAPS_GET_PHONEBOOK_START_IND_T *pMsg);
static void handlePbapGetPhonebookNextInd(applicationTaskData *pTask, PBAPS_GET_PHONEBOOK_NEXT_IND_T *pMsg);
static void handlePbapGetPhonebookCompleteInd(applicationTaskData *pTask, PBAPS_GET_PHONEBOOK_COMPLETE_IND_T *pMsg);

/* Interface Functions */

/*
  Initialise the PBAP System
*/
void initPbap(applicationTaskData *pTask)
{
	PRINT(("initPbap\n"));
	/* Initialise the PBAP library */
	PbapsInit(&pTask->task, 1, PBAP_REP_LOCAL);
}

void handlePbapMessages(applicationTaskData *pTask, MessageId pId, Message pMessage)
{
	switch (pId)
	{
	case PBAPS_INIT_CFM:
		handlePbapInitCfm(pTask, (PBAPS_INIT_CFM_T *)pMessage);
		break;
	case PBAPS_CONNECT_IND:
		handlePbapConnectInd(pTask, (PBAPS_CONNECT_IND_T *)pMessage);
		break;
	case PBAPS_CONNECT_CFM:
		handlePbapConnectCfm(pTask, (PBAPS_CONNECT_CFM_T *)pMessage);
		break;
	case PBAPS_DISCONNECT_IND:
		handlePbapDisconnectInd(pTask, (PBAPS_DISCONNECT_IND_T *)pMessage);
		break;
		
	case PBAPS_SET_PB_ROOT_IND:
		handlePbapSetRoot(pTask, (PBAPS_SET_PB_ROOT_IND_T *)pMessage);
		break;
	case PBAPS_SET_PB_REPOSITORY_IND:
		handlePbapSetRepository(pTask, (PBAPS_SET_PB_REPOSITORY_IND_T *)pMessage);
		break;
	case PBAPS_SET_PB_BOOK_IND:
		handlePbapSetPhoneBook(pTask, (PBAPS_SET_PB_BOOK_IND_T *)pMessage);
		break;
	case PBAPS_SET_PB_PARENT_IND:
		handlePbapSetParent(pTask, (PBAPS_SET_PB_PARENT_IND_T *)pMessage);
		break;

	case PBAPS_GET_VCARD_LIST_START_IND:
		handlePbapGetVCardListStartInd(pTask, (PBAPS_GET_VCARD_LIST_START_IND_T *)pMessage);
		break;
	case PBAPS_GET_VCARD_LIST_NEXT_IND:
		handlePbapGetVCardListNextInd(pTask, (PBAPS_GET_VCARD_LIST_NEXT_IND_T *)pMessage);
		break;
	case PBAPS_GET_VCARD_LIST_COMPLETE_IND:
		handlePbapGetVCardListCompleteInd(pTask, (PBAPS_GET_VCARD_LIST_COMPLETE_IND_T *)pMessage);
		break;

	case PBAPS_GET_VCARD_ENTRY_START_IND:
		handlePbapGetVCardEntryStartInd(pTask, (PBAPS_GET_VCARD_ENTRY_START_IND_T *)pMessage);
		break;
	case PBAPS_GET_VCARD_ENTRY_NEXT_IND:
		handlePbapGetVCardEntryNextInd(pTask, (PBAPS_GET_VCARD_ENTRY_NEXT_IND_T *)pMessage);
		break;
	case PBAPS_GET_VCARD_ENTRY_COMPLETE_IND:
		handlePbapGetVCardEntryCompleteInd(pTask, (PBAPS_GET_VCARD_ENTRY_COMPLETE_IND_T *)pMessage);
		break;

	case PBAPS_GET_PHONEBOOK_START_IND:
		handlePbapGetPhonebookStartInd(pTask, (PBAPS_GET_PHONEBOOK_START_IND_T *)pMessage);
		break;
	case PBAPS_GET_PHONEBOOK_NEXT_IND:
		handlePbapGetPhonebookNextInd(pTask, (PBAPS_GET_PHONEBOOK_NEXT_IND_T *)pMessage);
		break;
	case PBAPS_GET_PHONEBOOK_COMPLETE_IND:
		handlePbapGetPhonebookCompleteInd(pTask, (PBAPS_GET_PHONEBOOK_COMPLETE_IND_T *)pMessage);
		break;

	default:
		PRINT(("Unhandled PBAP Message\n"));
		break;
	}
}


/* Message Handlers */

static void handlePbapInitCfm(applicationTaskData *pTask, PBAPS_INIT_CFM_T *pMsg)
{
	PRINT(("PBAPS_INIT_CFM : "));

	if (pMsg->status == pbaps_success)
	{
		PRINT(("success\n"));
		pTask->pbapData.pbaps = pMsg->pbaps;
		
		/* Enable discoverability */
		conSetDiscoverability(TRUE);
		
		/* Initialise folder sub-system */
		folderInit(pTask);
		
		setState(&pTask->appState, AppStateAppIdle);
	}
	else
	{ /* Failed to initialise PBAPS */
		PRINT(("failure\n"));
		PRINT(("    Status : %d\n", pMsg->status));	
		Panic();
	}
}

static void handlePbapConnectInd(applicationTaskData *pTask, PBAPS_CONNECT_IND_T *pMsg)
{
	bool lAuth = FALSE;
	
	PRINT(("PBAPS_CONNECT_IND\n"));
	PRINT(("    BD Addr : 0x%X 0x%X 0x%X,%X\n", pMsg->bd_addr.nap, pMsg->bd_addr.uap, (uint16)(pMsg->bd_addr.lap>>16), (uint16)(pMsg->bd_addr.lap&0xFFFF)));
	if (pTask->appState == AppStateConnecting)
	{ /* Application idle, we can accept a connection */
		PRINT(("    Accepting connection\n"));
		lAuth = TRUE;
	}
	else
	{ /* Application busy, reject the connection */
		PRINT(("    Rejecting Connection [State = %d]\n", pTask->appState));
	}
	PbapsConnectResponse(pTask->pbapData.pbaps, lAuth, PBAP_DEF_PACKET);
}

static void handlePbapConnectCfm(applicationTaskData *pTask, PBAPS_CONNECT_CFM_T *pMsg)
{
	PRINT(("PBAPS_CONNECT_CFM\n"));
	
	if (pMsg->status == pbaps_success)
	{
		PRINT(("    Connection Successfull\n"));
		PRINT(("    Max Packet Size = %d bytes\n",pMsg->maxPacketLen));
		setState(&pTask->appState, AppStateConnected);
		conSetDiscoverability(FALSE);
		pTask->pbapData.pktSize = pMsg->maxPacketLen;
	}
	else
	{
		PRINT(("    Connection Failed\n"));
		setState(&pTask->appState, AppStateAppIdle);
	}
}

static void handlePbapDisconnectInd(applicationTaskData *pTask, PBAPS_DISCONNECT_IND_T *pMsg)
{
	PRINT(("PBAPS_DISCONNECT_IND\n"));
	setState(&pTask->appState, AppStateAppIdle);
	conSetDiscoverability(TRUE);
}

static void handlePbapSetPhoneBook(applicationTaskData *pTask, PBAPS_SET_PB_BOOK_IND_T *pMsg)
{
	pbaps_set_phonebook_result lRes;
	
	PRINT(("PBAPS_SET_PB_BOOK_IND\n"));
	PRINT(("    Phonebook %d\n",pMsg->book));
	
	if (pTask->appState == AppStateConnected)
	{
		lRes = folderSetChild(pTask, pMsg->book);
		PbapsSetPhonebookBookResponse(pTask->pbapData.pbaps, lRes);
	}
	else
	{
		PRINT(("    NOT Idle - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapSetParent(applicationTaskData *pTask, PBAPS_SET_PB_PARENT_IND_T *pMsg)
{
	pbaps_set_phonebook_result lRes;
	
	PRINT(("PBAPS_SET_PB_PARENT_IND\n"));
	
	if (pTask->appState == AppStateConnected)
	{
		lRes = folderSetParent(pTask);
		PbapsSetPhonebookParentResponse(pTask->pbapData.pbaps, lRes);
	}
	else
	{
		PRINT(("    NOT Idle - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapSetRoot(applicationTaskData *pTask, PBAPS_SET_PB_ROOT_IND_T *pMsg)
{
	pbaps_set_phonebook_result lRes;
	
	PRINT(("PBAPS_SET_PB_ROOT_IND\n"));
	
	if (pTask->appState == AppStateConnected)
	{
		lRes = folderSetRoot(pTask);
		PbapsSetPhonebookRootResponse(pTask->pbapData.pbaps, lRes);
	}
	else
	{
		PRINT(("    NOT Idle - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapSetRepository(applicationTaskData *pTask, PBAPS_SET_PB_REPOSITORY_IND_T *pMsg)
{
	pbaps_set_phonebook_result lRes;
	
	PRINT(("PBAPS_SET_PB_REPOSITORY_IND\n"));
	PRINT(("    Repository %d\n",pMsg->repository));
	
	if (pTask->appState == AppStateConnected)
	{
		if (pMsg->repository == pbap_sim1)
		{
			PRINT(("    No Such Repository\n"));
			lRes = pbaps_spb_no_repository;
		}
		else
		{
			lRes = pbaps_spb_ok; 
		}
		PbapsSetPhonebookRepositoryResponse(pTask->pbapData.pbaps, lRes);
	}
	else
	{
		PRINT(("    NOT Idle - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapGetVCardListStartInd(applicationTaskData *pTask, PBAPS_GET_VCARD_LIST_START_IND_T *pMsg)
{
	PRINT(("PBAPS_GET_VCARD_LIST_START_IND\n"));

	if (pTask->appState == AppStateConnected)
	{
		bool lComplete = FALSE;
		setState(&pTask->appState, AppStatePullvCardList);
		
		pTask->srchData.srchAttr = pMsg->srchAttr;
		pTask->srchData.srchVal = pMsg->srchVal;
		pTask->srchData.maxList	= pMsg->maxList;
		
		lComplete = folderGetFirstListBuffer(pTask, pMsg->listStart);
		PbapsGetvCardListFirstPacket(pTask->pbapData.pbaps, pbaps_get_ok, 0, pTask->buffer.buffer, pTask->buffer.used, lComplete);
	}
	else
	{
		PRINT(("    NOT Idle - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapGetVCardListNextInd(applicationTaskData *pTask, PBAPS_GET_VCARD_LIST_NEXT_IND_T *pMsg)
{
	PRINT(("PBAPS_GET_VCARD_LIST_NEXT_IND\n"));

	if (pTask->appState == AppStatePullvCardList)
	{
		bool lComplete;
		
		lComplete = folderGetNextListBuffer(pTask);
		PbapsGetvCardListNextPacket(pTask->pbapData.pbaps, pTask->buffer.used,  pTask->buffer.buffer, lComplete);
	}
	else
	{
		PRINT(("    NOT Pulling vCard List - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapGetVCardListCompleteInd(applicationTaskData *pTask, PBAPS_GET_VCARD_LIST_COMPLETE_IND_T *pMsg)
{
	PRINT(("PBAPS_GET_VCARD_LIST_COMPLETE_IND\n"));

	if (pTask->appState == AppStatePullvCardList)
	{
		setState(&pTask->appState, AppStateConnected);
		
		free(pTask->srchData.srchVal);
		pTask->srchData.srchAttr = 0;
		pTask->srchData.srchVal = NULL;
		pTask->srchData.maxList	= 0;
		
		folderCleanupListBuffer(pTask);
	}
	else
	{
		PRINT(("    NOT Pulling vCard List - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapGetVCardEntryStartInd(applicationTaskData *pTask, PBAPS_GET_VCARD_ENTRY_START_IND_T *pMsg)
{
	PRINT(("PBAPS_GET_VCARD_ENTRY_START_IND\n"));
	PRINT(("    Entry : %d\n",pMsg->entry));
	PRINT(("    Format : %d\n",pMsg->format));

	if (pTask->appState == AppStateConnected)
	{
		bool lComplete = FALSE;
		setState(&pTask->appState, AppStatePullvCardEntry);
		
		
		lComplete = vcgGetFirstEntryBuffer(pTask, pMsg->entry, pMsg->format);
		PbapsGetvCardEntryFirstPacket(pTask->pbapData.pbaps, pbaps_get_ok, 0, pTask->buffer.buffer, pTask->buffer.used, lComplete);
	}
	else
	{
		PRINT(("    NOT Idle - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapGetVCardEntryNextInd(applicationTaskData *pTask, PBAPS_GET_VCARD_ENTRY_NEXT_IND_T *pMsg)
{
	PRINT(("PBAPS_GET_VCARD_ENTRY_NEXT_IND\n"));
	if (pTask->appState == AppStatePullvCardEntry)
	{
		bool lComplete;
		
		lComplete = vcgGetNextEntryBuffer(pTask);
		PbapsGetvCardEntryNextPacket(pTask->pbapData.pbaps, pTask->buffer.used,  pTask->buffer.buffer, lComplete);
	}
	else
	{
		PRINT(("    NOT Pulling vCard Entry - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapGetVCardEntryCompleteInd(applicationTaskData *pTask, PBAPS_GET_VCARD_ENTRY_COMPLETE_IND_T *pMsg)
{
	PRINT(("PBAPS_GET_VCARD_ENTRY_COMPLETE_IND\n"));
	if (pTask->appState == AppStatePullvCardEntry)
	{
		setState(&pTask->appState, AppStateConnected);
		
		vcgCleanupListBuffer(pTask);
	}
	else
	{
		PRINT(("    NOT Pulling vCard Entry - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapGetPhonebookStartInd(applicationTaskData *pTask, PBAPS_GET_PHONEBOOK_START_IND_T *pMsg)
{
	PRINT(("PBAPS_GET_PHONEBOOK_START_IND\n"));
	PRINT(("    Repository : %d\n",pMsg->repository));
	PRINT(("    Phonebook : %d\n",pMsg->phonebook));
	PRINT(("    Format : %d\n",pMsg->format));
	PRINT(("    Max List : %d\n",pMsg->maxList));
	PRINT(("    List Start : %d\n",pMsg->listStart));

	if (pTask->appState == AppStateConnected)
	{
		setState(&pTask->appState, AppStatePullPhonebook);
		if ((pMsg->repository != pbap_current) && (pMsg->repository != pbap_local))
		{ /* Request for an invalid repository */
			PbapsGetPhonebookFirstPacket(pTask->pbapData.pbaps, pbaps_get_eol, 0, NULL, 0, TRUE);
		}
		else if (!pbaPhoneBookSupported(pMsg->phonebook))
		{ /* Request for an unsupported phonebook */
			PbapsGetPhonebookFirstPacket(pTask->pbapData.pbaps, pbaps_get_eol, 0, NULL, 0, TRUE);
		}
		else if (pMsg->maxList == 0)
		{ /* Client interested in how big the phonebook is */
			uint16 lNumEntries;
			
			setState(&pTask->appState, AppStatePullPhonebookSize);
			/* Get number of entries */
			lNumEntries = pbaGetNumberElements(pTask, pMsg->phonebook);
			
			PbapsGetPhonebookFirstPacketParams(pTask->pbapData.pbaps, pbaps_get_ok, 0, lNumEntries, 0);
		}
		else
		{
			bool lComplete = FALSE;
		
			lComplete = vcgGetFirstPhonebookBuffer(pTask, pMsg->phonebook, pMsg->listStart, pMsg->format, pMsg->maxList);
			PbapsGetPhonebookFirstPacket(pTask->pbapData.pbaps, pbaps_get_ok, 0, pTask->buffer.buffer, pTask->buffer.used, lComplete);
		}
	}
	else
	{
		PRINT(("    NOT Idle - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapGetPhonebookNextInd(applicationTaskData *pTask, PBAPS_GET_PHONEBOOK_NEXT_IND_T *pMsg)
{
	PRINT(("PBAPS_GET_PHONEBOOK_NEXT_IND\n"));
	if (pTask->appState == AppStatePullPhonebook)
	{
		bool lComplete;
		
		lComplete = vcgGetNextPhonebookBuffer(pTask);
		PbapsGetPhonebookNextPacket(pTask->pbapData.pbaps, pTask->buffer.used,  pTask->buffer.buffer, lComplete);
	}
	else if (pTask->appState == AppStatePullPhonebookSize)
	{
		PbapsGetPhonebookNextPacket(pTask->pbapData.pbaps, 0, NULL, TRUE);
	}
	else
	{
		PRINT(("    NOT Pulling Phonebook - Should not be possible\n"));
		Panic();
	}
}

static void handlePbapGetPhonebookCompleteInd(applicationTaskData *pTask, PBAPS_GET_PHONEBOOK_COMPLETE_IND_T *pMsg)
{
	PRINT(("PBAPS_GET_PHONEBOOK_COMPLETE_IND\n"));
	if ((pTask->appState == AppStatePullPhonebook) || (pTask->appState == AppStatePullPhonebookSize))
	{
		setState(&pTask->appState, AppStateConnected);
		
		vcgCleanupListBuffer(pTask);
	}
	else
	{
		PRINT(("    NOT Pulling Phonebook - Should not be possible\n"));
		Panic();
	}
}