fc-magnetite: src/aci2/bmi/mmiBluetooth.c comparison

comparison src/aci2/bmi/mmiBluetooth.c @ 3:93999a60b835

src/aci2, src/condat2: import of g23m/condat source pieces from TCS211

author	Mychaela Falconia <falcon@freecalypso.org>
date	Mon, 26 Sep 2016 00:29:36 +0000
parents
children

comparison

equal deleted inserted replaced

-:c41a534f33c6
+:93999a60b835
+/*
++-------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8445)		$Workfile:: mmiBluetooth.c			$|
+| $Author:: NDH						$Revision::  1						$|
+| CREATED: 26.04.04					$Modtime:: 26.04.04 10:21			$|
+| STATE  : code														 |
++-------------------------------------------------------------------+
+MODULE  : MFW_BT
+PURPOSE : This module contains the functions for MFW Bluetooth Management
+*/
+#define ENTITY_MFW
+#include <string.h>
+#if defined (NEW_FRAME)
+#include "typedefs.h"
+#include "vsi.h"
+#include "pei.h"
+#include "custom.h"
+#include "gsm.h"
+#include "prim.h"
+#else
+#include "STDDEFS.H"
+#include "custom.h"
+#include "gsm.h"
+#include "vsi.h"
+#endif
+#include "message.h" /* included for aci_cmh.h .... */
+//#include "prim.h" /* included for aci_cmh.h .... */
+#include "aci_cmh.h" /* included for mfw_sat.h, included for MmiDummy.h, included for MmiMenu.h */
+#include "mfw_mfw.h"
+#include "mfw_win.h"
+#include "mfw_icn.h"	/* included for mfw_mnu.h */
+#include "mfw_mnu.h"
+#include "mfw_tim.h"
+#include "mfw_kbd.h"
+#include "mfw_sat.h" /* included for MmiDummy.h, included for MmiMenu.h */
+#include "mfw_bte.h"
+#include "mfw_bt_dm.h"
+#include "mfw_bt_dg.h"
+#include "mfw_bt_ag.h"
+#include "mfw_bt_op.h"
+#include "mfw_bt_ft.h"
+#include "mfw_bt_geh.h"
+//#include "mfw_bt_temp.h"
+#include "MmiBlkLangDB.h"
+#include "mmiColours.h"
+#include "MmiDialogs.h"
+#include "mmiBluetooth.h"
+#include "MmiDummy.h" /* included for MmiMenu.h */
+#include "MmiLists.h"
+#include "MmiMenu.h"
+#include "MmiSoftKeys.h"
+#include "AUIEditor.h"
+/*
+** Local Typedefs
+*/
+typedef struct{
+	MfwHnd			bt_win;
+	MfwHnd			bt_dev_name_win;
+	MfwHnd			bt_pin_req_win;
+	MfwHnd			bt_authorize_win;
+	MfwHnd			bt_discoverable_timer;
+	MfwHnd			bt_connection_timer;
+	BOOL			bt_isEnabled;
+	BOOL			bt_isActive;
+	BOOL			bt_stopBtOnDiscoverableTimeout;
+	BOOL			bt_DevNameForStartup;
+	UBYTE			bt_num_active_connections;
+}	T_MMI_BtData;
+typedef struct{
+	T_MMI_CONTROL	mmi_control;
+	MfwHnd			win;
+	MfwHnd			bt_auth_info_win;
+	MfwHnd			bt_auth_info_editor;
+	MfwHnd			bt_auth_menu;
+	T_MFW_BT_DM_AUTHORIZE_REQ	*bt_auth_req_param;
+	UBYTE						*bt_auth_info_text;
+	USHORT						bt_auth_info_text_size;
+}	T_MMI_BT_Authorise_Data;
+typedef struct{
+	T_MMI_CONTROL	mmi_control;
+	MfwHnd			win;
+	MfwHnd			bt_dev_name_editor;
+	UBYTE			bt_device_name[MFW_BT_NAME_LENGTH+1];
+	T_MFW_BT_DM_DEV_ADDR	bt_dev_address;			/* CQ21843 - Bt Addr of remote device */
+	T_MFW_BT_REM_DEVICE_INFO *rem_device_info;		/* CQ21843 - Global information about the remote device*/
+}	T_MMI_BT_Dev_Name_Data;
+typedef struct{
+	T_MMI_CONTROL	mmi_control;
+	MfwHnd			win;
+	MfwHnd			bt_pin_req_editor;
+	MfwHnd			bt_please_wait_dialog;
+	T_MFW_BT_DM_DEV_ADDR	bt_pin_req_dev;
+	UBYTE			bt_pin_req_buf[MFW_BT_MAX_PIN_CODE_LEN+1];
+	T_BT_REQ_RESP	bt_required_response;
+}	T_MMI_BT_PIN_Req_Data;
+#if 0
+typedef struct {
+	T_MFW_BT_DM_DEV_ADDR	bd_addr;
+	UBYTE					bd_name[MFW_BT_NAME_LENGTH + 1];
+	T_MFW_BT_SERVICE_MASK	services;
+	BOOL					isPaired;
+	BOOL					isKnown;
+	BOOL					isTrustued;
+	T_MFW_BT_SERVICE_MASK	trustedServices;
+} T_MMI_BtDevDetails;
+#endif
+typedef struct{
+	T_MMI_CONTROL				srch_bt_control;
+	MfwHnd						win;
+	MfwHnd						srch_bt_cmpnt;
+	MfwHnd						srch_bt_pairing_pin_editor;
+	MfwHnd						srch_bt_please_wait_dialog;
+	MfwHnd						srch_bt_dev_list_win;
+	MfwHnd						srch_bt_show_services_win;
+	MfwHnd						srch_bt_search_timer;
+	T_BT_SEARCH_MODE			srch_bt_mode;
+	UBYTE						bt_pairing_pin_buf[MFW_BT_MAX_PIN_CODE_LEN+1];
+	T_BT_REQ_RESP				srch_bt_req_resp;
+	ListMenuData    				srch_bt_list_devices_menu_data;
+	ListMenuData    				srch_bt_show_services_menu_data;
+	UBYTE						srch_bt_num_devices;
+	UBYTE						srch_bt_device_count;
+	ListCbFunc					srch_bt_dev_list_cb;
+	T_MFW_BT_REM_DEVICE_INFO	*srch_bt_dev_list;
+	UBYTE						srch_bt_cur_dev_idx;
+	ULONG						srch_bt_cur_dev_serv_list[BTA_MAX_SERVICE_ID-1];
+}	T_MMI_BtSearchData;
+typedef struct
+{
+T_MMI_CONTROL   mmi_control;
+T_MFW_HND       win;
+T_MFW_HND       kbd;
+T_MFW_HND       kbd_long;
+T_MFW_HND       menu;
+T_VOID_FUNC     func_cb;
+T_VOID_FUNC	cancel_cb;
+/*
+* internal data
+*/
+}T_bt_menu;
+/*
+** Local Defines
+*/
+#define BT_MAX_DISPLAY_DEV_NAME_LENGTH	20
+#define BT_INFO_SCRN_TIMEOUT		1500
+#define BT_SEARCH_RESP_TIMEOUT       15000		/* 15 seconds */
+#define BT_AUTHORISE_RESP_TIMEOUT 30000		/* 30 seconds */
+#define BT_DISCOVERABLE_DURATION	180000		/* 3 minutes */
+#define BT_CONNECTION_DURATION	60000		/* 1 minute */
+/*
+** Local Function Prototypes
+*/
+static int  mmi_bluetooth_device_mnu_cb(MfwMnu * mnu, MfwMnuItem * item);
+static void mmi_bluetooth_editor_cb(T_MFW_HND win, USHORT identifier, SHORT reason);
+static int mmi_bluetooth_search_cb(T_MFW_EVENT evnt, void* para);
+static int mmi_bluetooth_root_cb(T_MFW_EVENT evnt, void* para);
+static int mmi_bluetooth_search_timer_cb(MfwEvt e, MfwTim *t);
+static int mmi_bluetooth_discovery_timer_cb(MfwEvt e, MfwTim *t);
+static int mmi_bluetooth_connection_timer_cb(MfwEvt e, MfwTim *t);
+static void mmi_bluetooth_dlg_cb(void);
+static void mmi_bt_srch_no_device_found_dlg_cb(void);
+static MfwHnd mmi_bluetooth_show_please_wait(T_MFW_HND parent);
+static MfwHnd mmi_bluetooth_show_info_callback(T_MFW_HND parent, int str1, int str2, T_VOID_FUNC callback);
+static MfwHnd mmi_bluetooth_show_info(T_MFW_HND parent, int str1, int str2);
+T_MFW_HND bt_menu_start(MfwHnd parent,MfwMnuAttr* menuAttr,T_VOID_FUNC func_cb);
+static T_MFW_HND bt_menu_create(MfwHnd parent);
+static void bt_menu_destroy(MfwHnd window);
+static void bt_menu (T_MFW_HND win, USHORT event, SHORT value, void * parameter);
+static int bt_menu_mnu_cb (MfwEvt e, MfwMnu *m);
+static int bt_menu_win_cb (MfwEvt e, MfwWin *w);
+static int bt_menu_kbd_cb (MfwEvt e, MfwKbd *k);
+static int bt_menu_kbd_long_cb (MfwEvt e, MfwKbd *k);
+static void mmi_bt_authorize_editor_cb(T_MFW_HND win, USHORT identifier, SHORT reason);
+static int mmi_bt_authorize_display_info(MfwMnu* m, MfwMnuItem* i);
+static int mmi_bt_authorize_once(MfwMnu* m, MfwMnuItem* i);
+static int mmi_bt_authorize_always(MfwMnu* m, MfwMnuItem* i);
+static int mmi_bt_dont_authorize(MfwMnu* m, MfwMnuItem* i);
+static void mmi_bt_authorize_rsk(void);
+static int bt_srch_dev_pair (MfwMnu * mnu, MfwMnuItem * item);
+static int bt_srch_dev_show_services (MfwMnu * mnu, MfwMnuItem * item);
+static int bt_srch_dev_set_name (MfwMnu * mnu, MfwMnuItem * item);		/* CQ21843 - Menu Action Function to set Friendly name for Remote device */
+static int bt_srch_dev_add_known (MfwMnu * mnu, MfwMnuItem * item);
+static int bt_srch_dev_rem_known (MfwMnu * mnu, MfwMnuItem * item);
+static void bt_srch_dev_list_searching_cb(T_MFW_HND Parent, ListMenuData *ListData);
+static void bt_srch_dev_list_listmnu_cb(T_MFW_HND Parent, ListMenuData * ListData);
+static void bt_srch_service_list_listmnu_cb(T_MFW_HND Parent, ListMenuData * ListData);
+static int bt_count_dev_services(T_MFW_BT_SERVICE_MASK services, T_MFW_BT_SERVICE_MASK *srv_mask_arry);
+static int bt_get_TxtId_for_service(T_MFW_BT_SERVICE_MASK service);
+/*
+** Local Static Data
+*/
+static  MfwMnuItem menuBtAuthorizeItems[] =
+{
+	{0,0,0, (char*) TxtBtInfo,  		0, (MenuFunc)mmi_bt_authorize_display_info,	item_flag_none},
+	{0,0,0, (char*) TxtBtYesOnce,	0, (MenuFunc)mmi_bt_authorize_once,			item_flag_none},
+	{0,0,0, (char*) TxtBtYesAlways,	0, (MenuFunc)mmi_bt_authorize_always,			item_flag_none},
+	{0,0,0, (char*) TxtNo,			0, (MenuFunc)mmi_bt_dont_authorize,			item_flag_none }
+};
+static const MfwMnuAttr menuBtAuthorize =
+{
+	&menuArea,
+	MNU_LEFT | MNU_LIST | MNU_CUR_LINE,					/* centered page menu       */
+	-1,													/* use default font         */
+	(MfwMnuItem*)menuBtAuthorizeItems,				/* with these items         */
+	sizeof(menuBtAuthorizeItems)/sizeof(MfwMnuItem),	/* number of items          */
+	COLOUR_LIST_XX,										/* Colour */
+	TxtBtAuthorize,										/* Hdr Id */
+	NULL,												/* Background */
+	MNUATTRSPARE										/* unused */
+};
+static MfwMnuAttr menuBtSearchListAttr =
+{
+	&menuArea,
+	MNU_LEFT | MNU_LIST | MNU_CUR_LINE,		/* centered page menu       */
+	-1,										/* use default font         */
+	NULL,									/* with these items (filled in later)  */
+	0,										/* number of items (filled in leter)  */
+	COLOUR_LIST_XX,							/* Colour */
+	TxtNull,									/* Hdr Id */
+	NULL,									/* Background */
+	MNUATTRSPARE							/* unused */
+};
+static MfwMnuAttr menuBtShowServicesListAttr =
+{
+	&menuArea,
+	MNU_LEFT | MNU_LIST | MNU_CUR_LINE,		/* centered page menu       */
+	-1,										/* use default font         */
+	NULL,									/* with these items (filled in later)  */
+	0,										/* number of items (filled in leter)  */
+	COLOUR_LIST_XX,							/* Colour */
+	TxtNull,									/* Hdr Id */
+	NULL,									/* Background */
+	MNUATTRSPARE							/* unused */
+};
+static  MfwMnuItem menuBtDeviceOptionsItems[] =
+{
+	{0,0,0, (char*) 0,  	0, (MenuFunc)bt_srch_dev_pair,			isBtDevicePaired},
+	{0,0,0, (char*) 0,	0, (MenuFunc)bt_srch_dev_pair,			isBtDeviceUnPaired},
+	{0,0,0, (char*) 0,	0, (MenuFunc)bt_srch_dev_show_services,	item_flag_none},
+	{0,0,0, (char*) 0,	0, (MenuFunc)bt_srch_dev_set_name,		isBtDeviceUnknown},		/* CQ21843 - Added Menu option*/
+	{0,0,0, (char*) 0,	0, (MenuFunc)bt_srch_dev_add_known,		isBtDeviceKnown},
+	{0,0,0, (char*) 0,	0, (MenuFunc)bt_srch_dev_rem_known,		isBtDeviceUnknown},
+};
+/*
+** CQ22023 : The Menu attributes should not be const, because the Header Id is to change depending on the Device Name
+**			Also MNU_HDRFORMAT_STR has to be added to the Menu Mode to allow a Real-Time string to be used as
+**			the Header Id.
+*/
+static MfwMnuAttr menuBtDeviceOptions =
+{
+	&menuArea,
+	MNU_LEFT | MNU_LIST | MNU_CUR_LINE | MNU_HDRFORMAT_STR, 	/* centered page menu       */
+	-1,													/* use default font         */
+	(MfwMnuItem*)menuBtDeviceOptionsItems,				/* with these items         */
+	sizeof(menuBtDeviceOptionsItems)/sizeof(MfwMnuItem),	/* number of items          */
+	COLOUR_LIST_XX,										/* Colour */
+	TxtNull,												/* Hdr Id */
+	NULL,												/* Background */
+	MNUATTRSPARE										/* unused */
+};
+#if 0
+static  MfwMnuItem menuBtServiceOptionsItems[] =
+{
+	{0,0,0, (char*) TxtBtAuthorize,  		0, (MenuFunc)bt_srch_serv_authorize,				isBtServiceTrusted},
+	{0,0,0, (char*) TxtBtUnAuthorize,		0, (MenuFunc)bt_srch_serv_revoke_authorization,	isBtServiceNotTrusted},
+};
+static const MfwMnuAttr menuBtServiceOptions =
+{
+	&menuArea,
+	MNU_LEFT | MNU_LIST | MNU_CUR_LINE,					/* centered page menu       */
+	-1,													/* use default font         */
+	(MfwMnuItem*)menuBtServiceOptionsItems,				/* with these items         */
+	sizeof(menuBtServiceOptionsItems)/sizeof(MfwMnuItem),	/* number of items          */
+	COLOUR_LIST_XX,										/* Colour */
+	TxtNull,												/* Hdr Id */
+	NULL,												/* Background */
+	MNUATTRSPARE										/* unused */
+};
+#endif
+/*
+** Bluetooth defined Global Data
+*/
+T_MMI_BtData		bt_data = {0};
+T_MMI_BtSearchData bt_srch_data = {0};
+extern MfwHnd mainMmiLng;
+#if 0
+/*
+** Test Specific Local Typedefs
+*/
+typedef void (*MfwBtCb) (int, void *);
+/*
+** Test Specific Local Defines
+*/
+#define mmiBtModTestDevMngr		1
+#define mmiBtModTestDevMngrSrch	2
+#define mmiBtModTestDevMngrSec		3
+#define mmiBtModTestDataGw			4
+#define mmiBtModTestAudioGw		5
+#define mmiBtModTestObjPush		6
+#define mmiBtModTestObjPushClient	7
+#define mmiBtModTestObjPushServer	8
+#define mmiBtModTestFileTxfr			9
+#define mmiBtModTestFileTxfrClient	10
+#define mmiBtModTestFileTxfrServer	11
+/*
+** Test Specific Local Static Data
+*/
+static int btModuleUnderTest = 0;
+static MfwBtCb btModuleUnderTestCb = 0;
+/*
+** Module Test Function Definitoins
+*/
+/*******************************************************************************
+$Function:		bluetoothTestDevMngr
+$Description:		This function sets a flag for the Test Menu to indicate that it is the Device Manager
+				profile which is under test
+$Returns:		None
+$Arguments:		None
+*******************************************************************************/
+void bluetoothTestDevMngr (void)
+{
+	TRACE_EVENT("bluetoothTestDevMngr");
+}
+/*******************************************************************************
+$Function:		bluetoothTestDevMngrSrch
+$Description:		This function sets a flag for the Test Menu to indicate that it is the Device Manager
+				(Search) profile which is under test
+$Returns:		None
+$Arguments:		None
+*******************************************************************************/
+void bluetoothTestDevMngrSrch (void)
+{
+	TRACE_EVENT("bluetoothTestDevMngr");
+	btModuleUnderTest = mmiBtModTestDevMngrSrch;
+	btModuleUnderTestCb = (MfwBtCb)mfw_bt_Dm_Search_Cb;
+}
+/*******************************************************************************
+$Function:		bluetoothTestDevMngrSec
+$Description:		This function sets a flag for the Test Menu to indicate that it is the Device Manager
+				(Security) profile which is under test
+$Returns:		None
+$Arguments:		None
+*******************************************************************************/
+void bluetoothTestDevMngrSec (void)
+{
+	TRACE_EVENT("bluetoothTestDevMngr");
+	btModuleUnderTest = mmiBtModTestDevMngrSec;
+	btModuleUnderTestCb = (MfwBtCb)mfw_bt_Dm_Security_Cb;
+}
+/*******************************************************************************
+$Function:		bluetoothTestDataGw
+$Description:		This function sets a flag for the Test Menu to indicate that it is the Data Gateway
+				profile which is under test
+$Returns:		None
+$Arguments:		None
+*******************************************************************************/
+void bluetoothTestDataGw (void)
+{
+	TRACE_EVENT("bluetoothTestDataGw");
+	btModuleUnderTest = mmiBtModTestDataGw;
+}
+/*******************************************************************************
+$Function:		bluetoothTestAudioGw
+$Description:		This function sets a flag for the Test Menu to indicate that it is the Audion Gateway
+				profile which is under test
+$Returns:		None
+$Arguments:		None
+*******************************************************************************/
+void bluetoothTestAudioGw (void)
+{
+	TRACE_EVENT("bluetoothTestAudioGw");
+	btModuleUnderTest = mmiBtModTestAudioGw;
+}
+/*******************************************************************************
+$Function:		bluetoothTestObjPush
+$Description:		This function sets a flag for the Test Menu to indicate that it is the Object Push
+				profile which is under test
+$Returns:		None
+$Arguments:		None
+*******************************************************************************/
+void bluetoothTestObjPush (void)
+{
+	TRACE_EVENT("bluetoothTestObjPush");
+	btModuleUnderTest = mmiBtModTestObjPush;
+}
+/*******************************************************************************
+$Function:		bluetoothTestFileTxfr
+$Description:		This function sets a flag for the Test Menu to indicate that it is the File Transfer
+				profile which is under test
+$Returns:		None
+$Arguments:		None
+*******************************************************************************/
+void bluetoothTestFileTxfr (void)
+{
+	TRACE_EVENT("bluetoothTestFileTxfr");
+	btModuleUnderTest = mmiBtModTestFileTxfr;
+}
+/*******************************************************************************
+$Function:		bluetoothTestClient
+$Description:		This function sets a flag for the Test Menu to indicate that it is either the
+				Object Push or File Transfer Client profiles which are under test
+$Returns:		None
+$Arguments:		None
+*******************************************************************************/
+void bluetoothTestClient (void)
+{
+	TRACE_EVENT("bluetoothTestClient");
+	if (btModuleUnderTest == mmiBtModTestObjPush)
+	{
+		btModuleUnderTest = mmiBtModTestObjPushClient;
+		btModuleUnderTestCb = (MfwBtCb)mfw_bt_Opc_Cb;
+	}
+	else
+	{
+		btModuleUnderTest = mmiBtModTestFileTxfrClient;
+		btModuleUnderTestCb = (MfwBtCb)mfw_bt_Ftc_Cb;
+	}
+}
+/*******************************************************************************
+$Function:		bluetoothTestServer
+$Description:		This function sets a flag for the Test Menu to indicate that it is either the
+				Object Push or File Transfer Server profiles which are under test
+$Returns:		None
+$Arguments:		None
+*******************************************************************************/
+void bluetoothTestServer (void)
+{
+	TRACE_EVENT("bluetoothTestServer");
+	if (btModuleUnderTest == mmiBtModTestObjPush)
+	{
+		btModuleUnderTest = mmiBtModTestObjPushServer;
+		btModuleUnderTestCb = (MfwBtCb)mfw_bt_Ops_Cb;
+	}
+	else
+	{
+		btModuleUnderTest = mmiBtModTestFileTxfrServer;
+		btModuleUnderTestCb = (MfwBtCb)mfw_bt_Fts_Cb;
+	}
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_test_single_msg
+$Description:		This function test the sending of a single event via the appropriate profile callback
+$Returns:		None
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_test_single_msg (MfwMnu* mnu, MfwMnuItem* item)
+{
+	int event;
+	U8 *sigData = mfwAlloc(sizeof(T_MFW_BT_SIG_DATA));
+	TRACE_EVENT("mmi_bluetooth_test_single_msg");
+	memset(sigData, 0x37, sizeof(T_MFW_BT_SIG_DATA));
+	switch (btModuleUnderTest)
+	{
+		case mmiBtModTestDevMngrSrch:
+			event = BTA_DM_INQ_RES_EVT;
+			break;
+		case mmiBtModTestDevMngrSec:
+			event = BTA_DM_ENABLE_EVT;
+			break;
+		case mmiBtModTestDataGw:
+			event = BTA_DG_LISTEN_EVT;
+			break;
+		case mmiBtModTestAudioGw:
+			event = BTA_AG_OPEN_EVT;
+			break;
+		case mmiBtModTestObjPushClient:
+			event = BTA_OPC_OBJECT_EVT;
+			break;
+		case mmiBtModTestObjPushServer:
+			event = BTA_OPS_CLOSE_EVT;
+			break;
+		case mmiBtModTestFileTxfrClient:
+			event = BTA_FTC_ENABLE_EVT;
+			break;
+		case mmiBtModTestFileTxfrServer:
+			event = BTA_FTS_AUTH_EVT;
+			break;
+		default:
+			TRACE_EVENT("mmi_bluetooth_test_single_msg > Invalid Test Module");
+			mfwFree(sigData, sizeof(T_MFW_BT_SIG_DATA));
+			return 1;
+	}
+	btModuleUnderTestCb(BTA_DG_LISTEN_EVT, sigData);
+	mfwFree(sigData, sizeof(T_MFW_BT_SIG_DATA));
+	return 1;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_test_multi_msg
+$Description:		This function test the sending of a multiple events via the appropriate profile callback
+$Returns:		None
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_test_multi_msg (MfwMnu* mnu, MfwMnuItem* item)
+{
+	U8 *sigData = mfwAlloc(sizeof(T_MFW_BT_SIG_DATA));
+	int	iLoop, iLoopMaxVal;
+	unsigned char chInit;
+	TRACE_EVENT("mmi_bluetooth_test_multi_msg");
+	chInit = 0x41;
+	switch (btModuleUnderTest)
+	{
+		case mmiBtModTestDevMngrSrch:
+			iLoopMaxVal = BTA_DM_DISC_CMPL_EVT;
+			break;
+		case mmiBtModTestDevMngrSec:
+			iLoopMaxVal = BTA_DM_SIG_STRENGTH_EVT;
+			break;
+		case mmiBtModTestDataGw:
+			iLoopMaxVal = BTA_DG_CLOSE_EVT;
+			break;
+		case mmiBtModTestAudioGw:
+			iLoopMaxVal = BTA_AG_AT_CNUM_EVT;
+			break;
+		case mmiBtModTestObjPushClient:
+			iLoopMaxVal = BTA_OPC_CLOSE_EVT;
+			break;
+		case mmiBtModTestObjPushServer:
+			iLoopMaxVal = BTA_OPS_CLOSE_EVT;
+			break;
+		case mmiBtModTestFileTxfrClient:
+			iLoopMaxVal = BTA_FTC_GETFILE_EVT;
+			break;
+		case mmiBtModTestFileTxfrServer:
+			iLoopMaxVal = BTA_FTS_AUTH_EVT;
+			break;
+		default:
+			TRACE_EVENT("mmi_bluetooth_test_multi_msg > Invalid Test Module");
+			mfwFree(sigData, sizeof(T_MFW_BT_SIG_DATA));
+			return 1;
+	}
+	for (iLoop = 0; iLoop <= iLoopMaxVal; iLoop++)
+	{
+		chInit++;
+		memset(sigData, chInit, sizeof(T_MFW_BT_SIG_DATA));
+		btModuleUnderTestCb(iLoop, sigData);
+	}
+	mfwFree(sigData, sizeof(T_MFW_BT_SIG_DATA));
+	return 1;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_test_buf_ovrflow
+$Description:		This function testS the sending of a multiple events via the appropriate profile callback,
+				causing a buf overflow of the event buffer
+$Returns:		None
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_test_buf_ovrflow(MfwMnu* mnu, MfwMnuItem* item)
+{
+	int event;
+	U8 *sigData = mfwAlloc(sizeof(T_MFW_BT_SIG_DATA));
+	int	iLoop, iLoopMaxVal;
+	unsigned char chInit;
+	TRACE_EVENT("mmi_bluetooth_test_multi_msg");
+	chInit = 0x61;
+	switch (btModuleUnderTest)
+	{
+		case mmiBtModTestDevMngrSrch:
+			iLoopMaxVal = BTA_DM_DISC_CMPL_EVT;
+			break;
+		case mmiBtModTestDevMngrSec:
+			iLoopMaxVal = BTA_DM_SIG_STRENGTH_EVT;
+			break;
+		case mmiBtModTestDataGw:
+			iLoopMaxVal = BTA_DG_CLOSE_EVT;
+			break;
+		case mmiBtModTestAudioGw:
+			iLoopMaxVal = BTA_AG_AT_CNUM_EVT;
+			break;
+		case mmiBtModTestObjPushClient:
+			iLoopMaxVal = BTA_OPC_CLOSE_EVT;
+			break;
+		case mmiBtModTestObjPushServer:
+			iLoopMaxVal = BTA_OPS_CLOSE_EVT;
+			break;
+		case mmiBtModTestFileTxfrClient:
+			iLoopMaxVal = BTA_FTC_GETFILE_EVT;
+			break;
+		case mmiBtModTestFileTxfrServer:
+			iLoopMaxVal = BTA_FTS_AUTH_EVT;
+			break;
+		default:
+			TRACE_EVENT("mmi_bluetooth_test_multi_msg > Invalid Test Module");
+			mfwFree(sigData, sizeof(T_MFW_BT_SIG_DATA));
+			return 1;
+	}
+	event  = 0;
+	for (iLoop = 0; iLoop <= MFW_BT_MAX_SIG_Q_ENTRIES+1; iLoop++)
+	{
+		chInit++;
+		memset(sigData, chInit, sizeof(T_MFW_BT_SIG_DATA));
+		btModuleUnderTestCb(event, sigData);
+		event++;
+		if (event > iLoopMaxVal)
+			event = 0;
+	}
+	mfwFree(sigData, sizeof(T_MFW_BT_SIG_DATA));
+	return 1;
+}
+#endif
+/*
+** Module Function Definitions
+*/
+/*******************************************************************************
+$Function:		isBluetoothActive
+$Description:		This function checks to determine whether Bluetooth is enabled
+$Returns:		USHORT : 1 is Bluetooth is Enabled, 0 otherwise
+$Arguments:		Not Used.
+*******************************************************************************/
+USHORT isBluetoothActive( struct MfwMnuTag *m, struct MfwMnuAttrTag *ma, struct MfwMnuItemTag *mi )
+{
+	MFW_BT_TRACE("isBluetoothActive()");
+	if (bt_data.bt_isActive)
+		return 1;
+	return 0;
+}
+/*******************************************************************************
+$Function:		isBluetoothInactive
+$Description:		This function checks to determine whether Bluetooth is disabled
+$Returns:		USHORT : 1 is Bluetooth is Disabled, 0 otherwise
+$Arguments:		Not Used.
+*******************************************************************************/
+USHORT isBluetoothInactive ( struct MfwMnuTag *m, struct MfwMnuAttrTag *ma, struct MfwMnuItemTag *mi )
+{
+	MFW_BT_TRACE("isBluetoothInactive()");
+	if (bt_data.bt_isActive == FALSE)
+		return 1;
+	return 0;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_automatic
+$Description:		This function performs the necessary steps to enable bluetooth. It creates a dialog,
+				with the MfwRoot as the parent, and calls the MFW BT functions
+$Returns:		Always returnd MFW_EVENT_CONSUMED (1)
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int mmi_bluetooth_automatic (MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_HND win = mfw_parent(mfw_header());
+	MFW_BT_TRACE("mmi_bluetooth_automatic()");
+	/*
+	** Create a timed dialog to display the Message "Bluetooth Failed"
+	*/
+	mmi_bluetooth_show_info(win, TxtNotAvailable, TxtNull);
+}
+/*******************************************************************************
+$Function:		isBtDevicePaired
+$Description:		This function checks to determine whether the active device is Paired or not.
+$Returns:		USHORT : 1 is Device is Paired, 0 otherwise
+$Arguments:		Not Used.
+*******************************************************************************/
+USHORT isBtDevicePaired ( MfwMnu *m, MfwMnuAttr *ma, MfwMnuItem *mi )
+{
+	T_MFW_BT_REM_DEVICE_INFO *cur_device = &bt_srch_data.srch_bt_dev_list[bt_srch_data.srch_bt_cur_dev_idx];
+	MFW_BT_TRACE("isBtDevicePaired()");
+	if (cur_device->link_key_present != FALSE)
+		return 1;
+	return 0;
+}
+/*******************************************************************************
+$Function:		isBtDeviceUnPaired
+$Description:		This function is the opposite of isBtDevicePaired (above)
+$Returns:		USHORT : 1 is Device is Not Paired, 0 otherwise
+$Arguments:		Not Used.
+*******************************************************************************/
+USHORT isBtDeviceUnPaired( MfwMnu *m, MfwMnuAttr *ma, MfwMnuItem *mi )
+{
+	T_MFW_BT_REM_DEVICE_INFO *cur_device = &bt_srch_data.srch_bt_dev_list[bt_srch_data.srch_bt_cur_dev_idx];
+	MFW_BT_TRACE("isBtDeviceUnPaired()");
+	if (cur_device->link_key_present != FALSE)
+		return 0;
+	return 1;
+}
+/*******************************************************************************
+$Function:		isBtDeviceKnown
+$Description:		This function checks to determine whether the active device is Known or not.
+$Returns:		USHORT : 1 is Device is Known, 0 otherwise
+$Arguments:		Not Used.
+*******************************************************************************/
+USHORT isBtDeviceKnown( MfwMnu *m, MfwMnuAttr *ma, MfwMnuItem *mi )
+{
+	T_MFW_BT_REM_DEVICE_INFO *cur_device = &bt_srch_data.srch_bt_dev_list[bt_srch_data.srch_bt_cur_dev_idx];
+	MFW_BT_TRACE("isBtDeviceKnown()");
+	if (cur_device->is_new == FALSE)
+		return 1;
+	return 0;
+}
+/*******************************************************************************
+$Function:		isBtDeviceUnknown
+$Description:		This function is the opposite of isBtDeviceKnown (above).
+$Returns:		USHORT : 1 is Device is Not Known, 0 otherwise
+$Arguments:		Not Used.
+*******************************************************************************/
+USHORT isBtDeviceUnknown( MfwMnu *m, MfwMnuAttr *ma, MfwMnuItem *mi )
+{
+	T_MFW_BT_REM_DEVICE_INFO *cur_device = &bt_srch_data.srch_bt_dev_list[bt_srch_data.srch_bt_cur_dev_idx];
+	MFW_BT_TRACE("isBtDeviceUnknown()");
+	if (cur_device->is_new == FALSE)
+		return 0;
+	return 1;
+}
+/*
+** CQ 21834 : The following function is required to hide a Known Device in the List whem it is removed
+** 			 from the Known Devices Database
+*/
+/*******************************************************************************
+$Function:		isListDeviceUnknown
+$Description:		This function is determines whether the current device in the known device list
+				is still in the Known Devices Database.
+$Returns:		USHORT : 1 is Device is Not Known, 0 otherwise
+$Arguments:		Not Used.
+*******************************************************************************/
+USHORT isListDeviceUnknown( MfwMnu *m, MfwMnuAttr *ma, MfwMnuItem *mi )
+{
+	int index;
+	int indexFound = 0;
+	MfwMnuItem *mItem;
+	T_MFW_BT_REM_DEVICE_INFO *cur_device;
+	index = 0;
+	while ((indexFound == 0) && (index < ma->nItems))
+	{
+		mItem = &(ma->items[index]);
+		if (mItem == mi)
+			indexFound = 1;
+		else
+			index++;
+	}
+	if (indexFound == 1)
+	{
+		MFW_BT_TRACE_P1("isListDeviceUnknown()  index = %d", index);
+	}
+	else
+	{
+		MFW_BT_TRACE("isListDeviceUnknown()  : Unable to determine Index");
+	}
+	cur_device = &bt_srch_data.srch_bt_dev_list[index];
+	if (cur_device->is_new == FALSE)
+		return 0;
+	return 1;
+}
+/*
+** CQ 21834 : The following function is required to determine whether a "No Devices" entry in the
+**			 Known Devices list should be visible. Without the "No Devices" Entry the list would
+**			 be empty, and this is not handled correctly in the BMI.
+*/
+/*******************************************************************************
+$Function:		isDeviceListEmpty
+$Description:		This function determines whether there are any entries in the known devices
+				database.
+$Returns:		USHORT : 0 if the Known Device Database is Empty, 1 otherwise.
+$Arguments:		Not Used.
+*******************************************************************************/
+USHORT isDeviceListEmpty( MfwMnu *m, MfwMnuAttr *ma, MfwMnuItem *mi )
+{
+	int index;
+	T_MFW_BT_REM_DEVICE_INFO *cur_device;
+	T_MFW_WIN	* win_data;
+	ListWinInfo	* data;
+	MFW_BT_TRACE("isDeviceListEmpty()");
+	for (index = 0; index < (ma->nItems -1); index++)
+	{
+		cur_device = &bt_srch_data.srch_bt_dev_list[index];
+		if (cur_device->is_new == FALSE)
+			return 1;
+	}
+	/*
+	** The list is otherwise empty so :
+	** 	1. remove the left soft key
+	**	2. ensure that the "No Devices" entry is displayed
+	*/
+	win_data = ((T_MFW_HDR *)bt_srch_data.srch_bt_dev_list_win)->data;
+	data = (ListWinInfo *)win_data->user;
+	data->MenuData.LeftSoftKey = TxtNull;
+	return 0;
+}
+/*******************************************************************************
+$Function:		mmi_bt_init
+$Description:		This function initializes the Bluetooth functionality on MMI startup
+$Returns:		none
+$Arguments:		none.
+*******************************************************************************/
+void  mmi_bt_exit (void)
+{
+	T_MMI_BtData		*data = &bt_data;
+	MFW_BT_TRACE("mmi_bt_exit()");
+	if (data->bt_isEnabled == FALSE)
+		return;
+	mfw_bt_delete(data->bt_win);
+	timDelete(data->bt_discoverable_timer);
+	timDelete(data->bt_connection_timer);
+	mfw_bt_exit();
+	return;
+}
+/*******************************************************************************
+$Function:		mmi_bt_init
+$Description:		This function initializes the Bluetooth functionality on MMI startup
+$Returns:		none
+$Arguments:		none.
+*******************************************************************************/
+void mmi_bt_init (void)
+{
+	T_MMI_BtData		*data = &bt_data;
+	MFW_BT_TRACE("mmi_bt_init()");
+	mfw_bt_init();			/* Initialize Bluetooth Module */
+	data->bt_isEnabled = TRUE;
+	/*
+	** Create a Bluetooth component
+	*/
+	MFW_BT_TRACE("mmi_bt_init > Creating the MFW_BT component");
+	if (data->bt_win == (void *)0)
+	{
+		data->bt_win = mfw_bt_create(0, E_BT_ALL_SERVICES, (MfwCb)mmi_bluetooth_root_cb);
+	}
+	if (data->bt_win == (void *)0)
+	{
+		MFW_BT_TRACE("mmi_bt_init > MFW_BT Component Failure");
+		data->bt_isEnabled = FALSE;
+	}
+	else
+	{
+		/*
+		** Create a Timer component for the "Discoverable" Timeout
+		*/
+		MFW_BT_TRACE("mmi_bt_init > Creating the discoverable timer");
+		if (data->bt_discoverable_timer == (void *)0)
+			data->bt_discoverable_timer = timCreate(0,
+												BT_DISCOVERABLE_DURATION,
+												(MfwCb)mmi_bluetooth_discovery_timer_cb);
+		if (data->bt_discoverable_timer == (void *)0)
+		{
+			MFW_BT_TRACE("mmi_bt_init > Discoverable timer creation failed ");
+			data->bt_isEnabled = FALSE;
+			/*
+			** Timer Compnonent Failed to start, delete previous components
+			*/
+			mfw_bt_delete(data->bt_win);
+		}
+		else
+		{
+			/*
+			** Create a Timer component for the "Connection" Timeout, when the timeout expires
+			** for the device being discoverable, but the is still a BT connection in progress
+			*/
+			MFW_BT_TRACE("mmi_bt_init > Creating the connection timer");
+			if (data->bt_connection_timer == (void *)0)
+				data->bt_connection_timer = timCreate(0,
+												     BT_CONNECTION_DURATION,
+												     (MfwCb)mmi_bluetooth_connection_timer_cb);
+			if (data->bt_connection_timer == (void *)0)
+			{
+				MFW_BT_TRACE("mmi_bt_init > Connection Timer creation failure");
+				data->bt_isEnabled = FALSE;
+				/*
+				** Timer Compnonent Failed to start, delete previous components
+				*/
+				mfw_bt_delete(data->bt_win);
+				timDelete(data->bt_discoverable_timer);
+			}
+			else
+			{
+				menuBtDeviceOptionsItems[0].str = MmiRsrcGetText(TxtBtPairDevice);
+				menuBtDeviceOptionsItems[1].str = MmiRsrcGetText(TxtBtChangePassKey);
+				menuBtDeviceOptionsItems[2].str = MmiRsrcGetText(TxtBtShowServices);
+				menuBtDeviceOptionsItems[3].str = MmiRsrcGetText(TxtBtSetLocalName);	/* CQ21843 - Menu Entry to Allow setting the Friendly Name */
+				menuBtDeviceOptionsItems[4].str = MmiRsrcGetText(TxtBtAddToKnown);
+				menuBtDeviceOptionsItems[5].str = MmiRsrcGetText(TxtBtRemoveDevice);
+			}
+		}
+	}
+	return;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_on
+$Description:		This function performs the necessary steps to turn on bluetooth. It will create the
+				root window if required
+$Returns:		Always returnd MFW_EVENT_CONSUMED (1)
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_on (MfwMnu* mnu, MfwMnuItem* item)
+{
+#if 1 /* Disable this while developing the test harness ... it'll come later */
+	T_MFW_BT_STATUS btRetVal;
+	MFW_BT_TRACE("mmi_bluetooth_on()");
+	if (bt_data.bt_isEnabled == FALSE)
+	{
+		/*
+		** Create a timed dialog to display the Message "Bluetooth DeActivated"
+		*/
+		mmi_bluetooth_show_info(0, TxtBluetooth, TxtDeActivated);
+	}
+	else
+	{
+		btRetVal = mfw_bt_enable(MFW_BT_DEFAULT_VIS);
+		if (btRetVal != MFW_BT_SUCCESS)
+		{
+			MFW_BT_TRACE_P1("mmi_bluetooth() : Attempt to enable Bluetooth Failed with %d", btRetVal);
+			/*
+			** Create a timed dialog to display the Message "Bluetooth Failed"
+			*/
+			mmi_bluetooth_show_info(0, TxtBluetooth, TxtFailed);
+		}
+	}
+#else
+	T_MFW_BT_STATUS mfwBtRetVal;
+	mfwBtRetVal = mfw_bt_ge_enable();
+	if (mfwBtRetVal <= 0)
+	{
+		/*
+		** Create a timed dialog to display the Message "Bluetooth Failed"
+		*/
+		mmi_bluetooth_show_info(TxtBluetooth, TxtFailed);
+	}
+	else
+	{
+		/*
+		** Create a timed dialog to display the Message "Bluetooth Activated"
+		*/
+		mmi_bluetooth_show_info(TxtBluetooth, TxtActivated);
+	}
+#endif
+	return MFW_EVENT_CONSUMED;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_off
+$Description:		This function performs the necessary steps to turn off bluetooth
+$Returns:		MFW_EVENT_CONSUMED
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_off (MfwMnu* mnu, MfwMnuItem* item)
+{
+#if 1	/* Disable this while developing the test harness ... it'll come later */
+	T_MMI_BtData		*data = &bt_data;
+	MFW_BT_TRACE("mmi_bluetooth_off()");
+	if (data->bt_isEnabled == FALSE)
+	{
+		return MFW_EVENT_CONSUMED;
+	}
+	else
+	{
+		if (data->bt_isActive != FALSE)
+		{
+			/*
+			** Disable the Bluetooth module
+			*/
+			mfw_bt_disable();
+			timStop(data->bt_discoverable_timer);
+			timStop(data->bt_connection_timer);
+		}
+	}
+#else
+	mfw_bt_Ge_Disable();
+	/*
+	** Create a timed dialog to display the Message "Bluetooth DeActivated"
+	*/
+	mmi_bluetooth_show_info(TxtBluetooth, TxtDeActivated);
+#endif
+	return MFW_EVENT_CONSUMED;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_change_name
+$Description:		This function performs the necessary steps to change the name of the local device.
+				It will start an editor to prompt for the name, and allow the user to cancel the input.
+$Returns:		MFW_EVENT_CONSUMED
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_change_name(MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_BT_STATUS btRetVal;
+	T_MMI_BtData *data = &bt_data;
+	MfwHnd win = mfw_parent(mfw_header());
+	MFW_BT_TRACE("mmi_bluetooth_change_name()");	/* CQ21835 */
+	if (data->bt_isEnabled == FALSE)
+	{
+		/*
+		** Create a timed dialog to display the Message "Bluetooth DeActivated"
+		*/
+		mmi_bluetooth_show_info(0, TxtBluetooth, TxtDeActivated);
+	}
+	else if (data->bt_dev_name_win == (void *)0)
+	{
+		data->bt_DevNameForStartup = FALSE;
+		data->bt_dev_name_win = mmi_bt_dev_name_create(win);
+		if (data->bt_dev_name_win != (void *)0)
+		{
+			SEND_EVENT(data->bt_dev_name_win, BT_DEV_NAME_REQ, 0, (void *)0);
+		}
+		else
+		{
+			MFW_BT_TRACE("mmi_bluetooth_root_cb() : Unable to create Device Name Win!");
+		}
+	}
+	else
+	{
+		MFW_BT_TRACE("mmi_bluetooth_root_cb() : Device Name Win already active");
+	}
+	return MFW_EVENT_CONSUMED;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_set_discoverable_on
+$Description:		This function performs the necessary steps to make this device discoverable, it
+				will turn on Bluetooth if it is currently off.
+$Returns:		MFW_EVENT_CONSUMED
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_set_discoverable_on(MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_BT_STATUS btRetVal;
+	T_MMI_BtData *data = &bt_data;
+	MFW_BT_TRACE("mmi_bluetooth_set_discoverable_on()");
+	if (data->bt_isEnabled == FALSE)
+	{
+		/*
+		** Create a timed dialog to display the Message "Bluetooth DeActivated"
+		*/
+		mmi_bluetooth_show_info(0, TxtBluetooth, TxtDeActivated);
+	}
+	else
+	{
+		timStop(data->bt_discoverable_timer);
+		timStop(data->bt_connection_timer);
+		btRetVal = mfw_bt_dm_set_visibility(TRUE, FALSE);	/* Shown, and permanently on */
+		if (btRetVal != MFW_BT_SUCCESS)
+		{
+			MFW_BT_TRACE_P1("mmi_bluetooth_set_discoverable_on() : Set Visibility (TRUE) failed with status : %d", btRetVal);
+			/*
+			** Create a timed dialog to display the Message "Failed"
+			*/
+			mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+		}
+		else
+		{
+			if (data->bt_isActive == FALSE)
+			{
+				/*
+				** Enable Bluetooth with the appropriate Visibility Mask
+				*/
+				btRetVal = mfw_bt_enable(MFW_BT_SHOWN);
+				if (btRetVal != MFW_BT_SUCCESS)
+				{
+					MFW_BT_TRACE_P1("mmi_bluetooth_set_discoverable_on() : Attempt to enable Bluetooth Failed with %d", btRetVal);
+					/*
+					** Create a timed dialog to display the Message "Failed"
+					*/
+					mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+				}
+			}
+			else
+			{
+				/*
+				** Create a timed dialog to display the Message "Device Discoverable"
+				*/
+				mmi_bluetooth_show_info(0, TxtBtDevice, TxtBtDiscoverable);
+			}
+		}
+	}
+	return MFW_EVENT_CONSUMED;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_set_discoverable_timed
+$Description:		This function performs the necessary steps to make this device discoverable
+				for a preconfigured amount of time. It bluetooth is Off, it will be started. When
+				the time expiures, thew devicde will become hidden. If there is a connection
+				open, and bluetooth was started as a result of this request, the timer will be reset,
+				and when it expires with no connection active, bluetooth will be deactivated.
+$Returns:		MFW_EVENT_CONSUMED
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_set_discoverable_timed(MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_BT_STATUS btRetVal;
+	T_MMI_BtData *data = &bt_data;
+	MFW_BT_TRACE("mmi_bluetooth_set_discoverable_timed()");
+	if (data->bt_isEnabled == FALSE)
+	{
+		/*
+		** Create a timed dialog to display the Message "Bluetooth DeActivated"
+		*/
+		mmi_bluetooth_show_info(0, TxtBluetooth, TxtDeActivated);
+	}
+	else if (data->bt_isActive == FALSE)
+	{
+		/*
+		** Enable Bluetooth with the appropriate Visibility Mask
+		*/
+		btRetVal = mfw_bt_enable(MFW_BT_SHOWN);
+		if (btRetVal != MFW_BT_SUCCESS)
+		{
+			MFW_BT_TRACE_P1("mmi_bluetooth_set_discoverable_timed() : Attempt to enable Bluetooth Failed with %d", btRetVal);
+			/*
+			** Create a timed dialog to display the Message "Failed"
+			*/
+			mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+		}
+		else
+			data->bt_stopBtOnDiscoverableTimeout = TRUE;
+	}
+	else
+	{
+		btRetVal = mfw_bt_dm_set_visibility(TRUE, TRUE);
+		if (btRetVal != MFW_BT_SUCCESS)
+		{
+			MFW_BT_TRACE_P1("mmi_bluetooth_set_discoverable_timed() : Set Visibility (TRUE) failed with status : %d", btRetVal);
+			/*
+			** Create a timed dialog to display the Message "Failed"
+			*/
+			mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+		}
+		else
+		{
+			/*
+			** Create a timed dialog to display the Message "Device Discoverable"
+			*/
+			mmi_bluetooth_show_info(0, TxtBtDevice, TxtBtDiscoverable);
+			data->bt_stopBtOnDiscoverableTimeout = FALSE;
+		}
+	}
+	timStart(data->bt_discoverable_timer);
+	return MFW_EVENT_CONSUMED;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_set_discoverable_off
+$Description:		This function performs the necessary steps to make this device hidden. It
+				will not change the state of Bluetooth, if it is on, it will remain on, but hidden,
+				if it is Off it will remain off.
+$Returns:		MFW_EVENT_CONSUMED
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_set_discoverable_off(MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_BT_STATUS btRetVal;
+	T_MMI_BtData *data = &bt_data;
+	MFW_BT_TRACE("mmi_bluetooth_set_discoverable_off()");
+	if (data->bt_isEnabled == FALSE)
+	{
+		/*
+		** Create a timed dialog to display the Message "Bluetooth DeActivated"
+		*/
+		mmi_bluetooth_show_info(0, TxtBluetooth, TxtDeActivated);
+	}
+	else
+	{
+		timStop(data->bt_discoverable_timer);
+		timStop(data->bt_connection_timer);
+		btRetVal = mfw_bt_dm_set_visibility(FALSE, FALSE);
+		if (btRetVal != MFW_BT_SUCCESS)
+		{
+			MFW_BT_TRACE_P1("mmi_bluetooth() : Set Visibility (FALSE) failed with status : %d", btRetVal);
+			/*
+			** Create a timed dialog to display the Message "Failed"
+			*/
+			mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+		}
+		else
+		{
+			mmi_bluetooth_show_info(0, TxtBtDevice, TxtBtHidden);
+		}
+	}
+	return MFW_EVENT_CONSUMED;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_device_search
+$Description:		This function performs the necessary steps to search for local bluetooth devices.
+				It will only be avaiable if in the menu Bluetooth is active. It will start a new window
+				to specifically handle the search.
+$Returns:		MFW_EVENT_CONSUMED
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_device_search(MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_HND win;
+	T_MFW_BT_STATUS btRetVal;
+	T_MMI_BtData *data = &bt_data;
+	T_MMI_BtSearchData *srch_data = &bt_srch_data;
+	MFW_BT_TRACE("mmi_bluetooth_device_search()");
+	if (data->bt_isActive == FALSE)
+	{
+		/*
+		** Create a timed dialog to display the Message "Bluetooth DeActivated"
+		*/
+		mmi_bluetooth_show_info(0, TxtBluetooth, TxtDeActivated);
+		return MFW_EVENT_CONSUMED;
+	}
+	if (srch_data->win == (void *)0)
+	{
+		win = mfw_parent(mfw_header());
+		if (mmi_bt_search_create(win) == FALSE)
+		{
+			/*
+			** Create a timed dialog to display the Message "Failed"
+			*/
+			mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+			return MFW_EVENT_CONSUMED;
+		}
+		SEND_EVENT(srch_data->win, BT_DEVICE_SEARCH, 0, 0);
+	}
+	else
+	{
+		MFW_BT_TRACE("mmi_bluetooth_device_search > win not NULL!!!");
+	}
+	return MFW_EVENT_CONSUMED;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_list_known_devices
+$Description:		This function performs the necessary steps to search for local bluetooth devices.
+				It will only be avaiable if in the menu Bluetooth is active. It will start a new window
+				to specifically handle the search.
+$Returns:		MFW_EVENT_CONSUMED
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_list_known_devices(MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_HND win;
+	T_MFW_BT_STATUS btRetVal;
+	T_MMI_BtData *data = &bt_data;
+	T_MMI_BtSearchData *srch_data = &bt_srch_data;
+	MFW_BT_TRACE("mmi_bluetooth_list_known_devices()");
+	if (data->bt_isEnabled == FALSE)
+	{
+		/*
+		** Create a timed dialog to display the Message "Bluetooth DeActivated"
+		*/
+		mmi_bluetooth_show_info(0, TxtBluetooth, TxtDeActivated);
+		return MFW_EVENT_CONSUMED;
+	}
+	if (srch_data->win == (void *)0)
+	{
+		win = mfw_parent(mfw_header());
+		if (mmi_bt_search_create(win) == FALSE)
+		{
+			/*
+			** Create a timed dialog to display the Message "Failed"
+			*/
+			mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+			return MFW_EVENT_CONSUMED;
+		}
+	}
+	SEND_EVENT(srch_data->win, BT_LIST_KNOWN_DEVICES, 0, 0);
+	return MFW_EVENT_CONSUMED;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_clear_all_stored_devices
+$Description:		This function clears all stored devices from FFS.
+$Returns:		MFW_EVENT_CONSUMED
+$Arguments:		mnu : pointer to the mnu data for the menu which caused this function to be called.
+				item : pointer to the item data from the menu.
+*******************************************************************************/
+GLOBAL int  mmi_bluetooth_clear_all_stored_devices(MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_BT_STATUS btRetVal;
+	T_MFW_BT_REM_DEVICE *cur_device;
+	T_MFW_BT_REM_DEVICE *ptr_db_device[MFW_BT_NUM_REM_DEVICE];
+	UINT8 dev_index;
+	UINT8 num_of_known_devices;
+	MFW_BT_TRACE("mmi_bluetooth_clear_all_stored_devices()");
+	if (bt_data.bt_isEnabled == FALSE)
+	{
+		/*
+		** Create a timed dialog to display the Message "Bluetooth DeActivated"
+		*/
+		mmi_bluetooth_show_info(0, TxtBluetooth, TxtDeActivated);
+		return MFW_EVENT_CONSUMED;
+	}
+	mfw_bt_get_device_by_service(BTA_ALL_SERVICE_MASK, &ptr_db_device[0], &num_of_known_devices);
+	for (dev_index = 0; dev_index < num_of_known_devices; dev_index++)
+	{
+		cur_device = ptr_db_device[dev_index];
+		btRetVal = mfw_bt_dm_delete_device(cur_device->bd_addr);
+		if (btRetVal != MFW_BT_SUCCESS)
+		{
+			MFW_BT_TRACE_P1("mfw_bt_dm_clear_all_stored_dev returned error : %d", btRetVal);
+			mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+			return MFW_EVENT_CONSUMED;
+		}
+	}
+	mmi_bluetooth_show_info(0, TxtBtKnownDevices, TxtDeleted);
+	return MFW_EVENT_CONSUMED;
+}
+/*******************************************************************************
+$Function:		mmi_bt_pin_request_create
+$Description:		This function performs the necessary steps to create the a window to handle the
+				PIN Request, pairing process. It will be removed, or rather remove itself on receipt
+				of the AUTH_CMPL event
+$Returns:		T_MFW_HND : Window Handle to th eNew Window, Null if failed.
+$Arguments:		parent : pointer to the parent window.
+*******************************************************************************/
+T_MFW_HND mmi_bt_pin_request_create(T_MFW_HND parent)
+{
+	T_MMI_BT_PIN_Req_Data *data;
+	T_MFW_WIN * win;
+	data = (T_MMI_BT_PIN_Req_Data *)mfwAlloc((U16)sizeof(T_MMI_BT_PIN_Req_Data));
+	if (data == (void *)0)
+		return data;
+	data->win = winCreate(parent, 0, E_WIN_VISIBLE, mmi_bluetooth_win_cb);
+	if (data->win == (void *)0)
+	{
+		/*
+		** Failed to start : Free Memory, and exit
+		*/
+		mfwFree((U8 *)data, (U16)sizeof(T_MMI_BT_PIN_Req_Data));
+		data = (void *)0;
+		return data;
+	}
+	else
+	{
+		/*
+		** Setup the Dialog control functions
+		*/
+		data->mmi_control.dialog = (T_DIALOG_FUNC)mmi_bt_pin_req_cntrl;
+		data->mmi_control.data = data;
+		win = ((T_MFW_HDR *)data->win)->data;
+		win->user = (void *)data;
+	}
+	bt_data.bt_pin_req_win = data->win;
+	return data->win;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_pin_request_destroy
+$Description:		This function performs the necessary steps to remove the window handling the
+				PIN request, tidying up all allocated resources.
+$Returns:		MfwResOk : Success
+				MfwResIllHnd : Illegal Window Handler provided
+$Arguments:		win : Window to be destroyed
+*******************************************************************************/
+MfwRes mmi_bt_pin_request_destroy(T_MFW_HND win)
+{
+	T_MFW_WIN * win_data;
+	T_MMI_BT_PIN_Req_Data * data;
+	if (win == (void *)0)
+		return MfwResIllHnd;
+	win_data = ((T_MFW_HDR *) win)->data;
+	data = (T_MMI_BT_PIN_Req_Data *)win_data->user;
+	/*
+	** Destroy the Window
+	*/
+	win_delete(data->win);
+	/*
+	** Free the dynamically allocated memory
+	*/
+	mfwFree((U8 *)data, (U16)sizeof(T_MMI_BT_PIN_Req_Data));
+	bt_data.bt_pin_req_win = (void *)0;
+	return MfwResOk;
+}
+/*******************************************************************************
+$Function:		mmi_bt_pin_req_cntrl
+$Description:		This is the dialog control function for the Pin REquest Window. It receives the signals
+				from the MFW and determines what action, if any, to take.
+$Returns:		None
+$Arguments:		win :		The pointer to the window handler, so the function can reference the
+							dynamic user data, if any.
+				event :		The incoming event
+				value :		Generic incoming Parameter, it will be 'event' dependant
+				parameter :	Generic incoming Parameter, it will be 'event' dependant
+*******************************************************************************/
+void mmi_bt_pin_req_cntrl (T_MFW_HND win, USHORT event, SHORT value, void * parameter)
+{
+	T_MFW_WIN			* win_data = ((T_MFW_HDR *) win)->data;
+	T_MMI_BT_PIN_Req_Data * data = (T_MMI_BT_PIN_Req_Data *)win_data->user;
+	T_AUI_EDITOR_DATA	editor_data;
+	T_MFW_BT_STATUS		btRetVal;
+	T_MFW_BT_DM_PIN_REQ	*pin_req_param;
+	T_MFW_BT_DM_AUTH_CMPL	*auth_cmpl_param;
+	MFW_BT_TRACE_P1("mmi_bt_pin_req_cntrl() : Event Received : %d", event);
+	switch (event)
+	{
+		case BT_PIN_REQ:
+#ifdef NEW_EDITOR
+			/*
+			** Initialise the editor
+			*/
+			AUI_edit_SetDefault(&editor_data);
+			AUI_edit_SetMode(&editor_data, ED_MODE_HIDDEN, ED_CURSOR_BAR);
+			AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, data->bt_pin_req_buf, MFW_BT_MAX_PIN_CODE_LEN);
+			AUI_edit_SetTextStr(&editor_data, TxtSoftSelect, TxtSoftBack, TxtBtEnterPassKey, TxtNull);
+			AUI_edit_SetAltTextStr(&editor_data, 1, TxtNull, TRUE, TxtCancel);
+			AUI_edit_SetEvents(&editor_data, BT_PIN_REQ_EDITOR, TRUE, FOREVER, (T_AUI_EDIT_CB)mmi_bluetooth_editor_cb);
+			pin_req_param = (T_MFW_BT_DM_PIN_REQ *)parameter;
+			memcpy(&data->bt_pin_req_dev, &pin_req_param->bd_addr, sizeof(T_MFW_BT_DM_DEV_ADDR));
+			data->bt_pin_req_editor = AUI_edit_Start(data->win, &editor_data);
+#endif
+			break;
+		case BT_AUTH_COMPLETE:
+			auth_cmpl_param = (T_MFW_BT_DM_AUTH_CMPL *)parameter;
+			if (memcmp(auth_cmpl_param->bd_addr, data->bt_pin_req_dev, sizeof(T_MFW_BT_DM_DEV_ADDR)) != 0)
+			{
+				MFW_BT_TRACE("mmi_bt_pin_req_cntrl() > AUTH Complete event with invalid BD Address");
+				return;
+			}
+			if (data->bt_please_wait_dialog != (void *)0)
+			{
+				SEND_EVENT(data->bt_please_wait_dialog, DIALOG_DESTROY, 0, 0);
+				data->bt_please_wait_dialog = (void *)0;
+			}
+			if (data->bt_pin_req_editor != (void *)0)
+			{
+				/*
+				** Destory the current Pin Entry Window, as Bluetooth has timed out the request
+				*/
+				AUI_edit_Destroy(data->bt_pin_req_editor);
+				data->bt_pin_req_editor = (void *)0;
+				memset(data->bt_pin_req_buf, 0x00, MFW_BT_MAX_PIN_CODE_LEN+1);
+				/*
+				** Create a timed dialog to display the Message "Failed"
+				*/
+				mmi_bluetooth_show_info(0, TxtBtPassKey, TxtBtTimeout);
+			}
+			else if (data->bt_required_response == BT_SUCCESS_FAIL_RESP)
+			{
+				if (auth_cmpl_param->is_success == FALSE)
+				{
+						/*
+						** Create a timed dialog to display the Message "Failed"
+						*/
+						mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+				}
+				else
+				{
+					/*
+					** Create a timed dialog to display the Message "Pin OK"
+					*/
+					mmi_bluetooth_show_info(0, TxtPINOK, TxtNull);
+				}
+			}
+			/*
+			** Destory the PIN Request Window, the editor has been destroyed and the last response received.
+			*/
+			mmi_bt_pin_request_destroy(data->win);
+			break;
+		case BT_EDITOR_CANCEL:
+			data->bt_required_response = BT_NO_RESP;
+			if (value == BT_PIN_REQ_EDITOR)
+			{
+				/*
+				** The User has cancelled the input from a Pin request,
+				** return a FALSE value to the MFW as an indication. Not bothered about the
+				** return value as this is a fail anyway!
+				*/
+				(void)mfw_bt_dm_pin_code((void *)0, 0);
+				/*
+				** The editor will have been destroyed. Reset the Window handler
+				*/
+				data->bt_pin_req_editor = (void *)0;
+			}
+			else
+				MFW_BT_TRACE_P1("mmi_bt_pin_req_cntrl(), BT_EDITOR_CANCEL event received with unexpected value %d", value);
+			break;
+		case BT_EDITOR_SELECT:
+			if (value == BT_PIN_REQ_EDITOR)
+			{
+				data->bt_required_response = BT_SUCCESS_FAIL_RESP;
+				/*
+				** The user has entered a Pin Key, pass it to the MFW for processing
+				*/
+				btRetVal = mfw_bt_dm_pin_code((void *)&data->bt_pin_req_buf, strlen((void *)&data->bt_pin_req_buf));
+				/*
+				** CQ21957 : The editor will have been destroyed. Reset the Window handler
+				*/
+				data->bt_pin_req_editor = (void *)0;
+				if (btRetVal != MFW_BT_SUCCESS)
+				{
+					MFW_BT_TRACE_P1("mmi_bt_pin_req_cntrl() : Attempt to set return Pin Code Failed with %d", btRetVal);
+				}
+				else
+					data->bt_please_wait_dialog = mmi_bluetooth_show_please_wait(data->win);
+			}
+			else
+			{
+				MFW_BT_TRACE_P1("mmi_bt_pin_req_cntrl(), BT_EDITOR_SELECT event received with unexpected value %d", value);
+			}
+			break;
+		default:
+			MFW_BT_TRACE("mmi_bt_pin_req_cntrl() : Unexpected Event!");
+	}
+	return;
+}
+/*******************************************************************************
+$Function:		mmi_bt_dev_name_create
+$Description:		This function performs the necessary steps to create the a window to handle the
+				Device Name Request. It will be removed, or rather remove itself on returning the
+				data to the Mfw.
+$Returns:		T_MFW_HND : Window Handle to the New Window, Null if failed.
+$Arguments:		parent : pointer to the parent window.
+*******************************************************************************/
+T_MFW_HND mmi_bt_dev_name_create(T_MFW_HND parent)
+{
+	T_MMI_BT_Dev_Name_Data *data;
+	T_MFW_WIN * win;
+	data = (T_MMI_BT_Dev_Name_Data *)mfwAlloc((U16)sizeof(T_MMI_BT_Dev_Name_Data));
+	if (data == (void *)0)
+		return data;
+	data->win = winCreate(parent, 0, E_WIN_VISIBLE, mmi_bluetooth_win_cb);
+	if (data->win == (void *)0)
+	{
+		/*
+		** Failed to start : Free Memory, and exit
+		*/
+		mfwFree((U8 *)data, (U16)sizeof(T_MMI_BT_Dev_Name_Data));
+		data = (void *)0;
+		return data;
+	}
+	else
+	{
+		/*
+		** Setup the Dialog control functions
+		*/
+		data->mmi_control.dialog = (T_DIALOG_FUNC)mmi_bt_dev_name_cntrl;
+		data->mmi_control.data = data;
+		win = ((T_MFW_HDR *)data->win)->data;
+		win->user = (void *)data;
+	}
+	bt_data.bt_dev_name_win = data->win;
+	return data->win;
+}
+/*******************************************************************************
+$Function:		mmi_bt_dev_name_destroy
+$Description:		This function performs the necessary steps to remove the window handling the
+				Device Name request, tidying up all allocated resources.
+$Returns:		MfwResOk : Success
+				MfwResIllHnd : Illegal Window Handler provided
+$Arguments:		win : Window to be destroyed
+*******************************************************************************/
+MfwRes mmi_bt_dev_name_destroy(T_MFW_HND win)
+{
+	T_MFW_WIN * win_data;
+	T_MMI_BT_Dev_Name_Data * data;
+	if (win == (void *)0)
+		return MfwResIllHnd;
+	win_data = ((T_MFW_HDR *) win)->data;
+	data = (T_MMI_BT_Dev_Name_Data *)win_data->user;
+	/*
+	** Destroy the Window
+	*/
+	win_delete(data->win);
+	/*
+	** Free the dynamically allocated memory
+	*/
+	mfwFree((U8 *)data, (U16)sizeof(T_MMI_BT_Dev_Name_Data));
+	bt_data.bt_dev_name_win = (void *)0;
+	return MfwResOk;
+}
+/*******************************************************************************
+$Function:		mmi_bt_dev_name_cntrl
+$Description:		This is the dialog control function for the Device Name Request Window. It
+				receives the signals from the MFW and determines what action, if any, to take.
+$Returns:		None
+$Arguments:		win :		The pointer to the window handler, so the function can reference the
+							dynamic user data, if any.
+				event :		The incoming event
+				value :		Generic incoming Parameter, it will be 'event' dependant
+				parameter :	Generic incoming Parameter, it will be 'event' dependant
+*******************************************************************************/
+void mmi_bt_dev_name_cntrl (T_MFW_HND win, USHORT event, SHORT value, void * parameter)
+{
+	T_MFW_WIN			* win_data = ((T_MFW_HDR *) win)->data;
+	T_MMI_BT_Dev_Name_Data * data = (T_MMI_BT_Dev_Name_Data *)win_data->user;
+	T_AUI_EDITOR_DATA	editor_data;
+	UBYTE				*ptr_device_name;
+	T_MFW_BT_STATUS		btRetVal;
+	MFW_BT_TRACE_P1("mmi_bt_dev_name_cntrl() : Event Received : %d", event);
+	switch (event)
+	{
+		case BT_DEV_NAME_REQ:
+#ifdef NEW_EDITOR
+			/*
+			** Get the current Device Name from the MFW
+			*/
+			ptr_device_name = mfw_bt_dm_get_local_name();
+			memcpy(&data->bt_device_name, ptr_device_name, MFW_BT_NAME_LENGTH);
+			/*
+			** Initialise the editor
+			*/
+			AUI_edit_SetDefault(&editor_data);
+			AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, data->bt_device_name, MFW_BT_NAME_LENGTH);
+			AUI_edit_SetTextStr(&editor_data, TxtSoftSelect, TxtSoftBack, TxtBtEnterDeviceName, TxtNull);
+			AUI_edit_SetAltTextStr(&editor_data, 1, TxtNull, TRUE, TxtCancel);
+			AUI_edit_SetEvents(&editor_data, BT_DEV_NAME_EDITOR, TRUE, FOREVER, (T_AUI_EDIT_CB)mmi_bluetooth_editor_cb);
+			data->bt_dev_name_editor = AUI_edit_Start(data->win, &editor_data);
+#endif
+			break;
+		case BT_SET_REM_DEV_NAME:		/* CQ21843 : Get a Friendly name for a remote device */
+#ifdef NEW_EDITOR
+			data->rem_device_info = (T_MFW_BT_REM_DEVICE_INFO *)parameter;
+			memcpy(&data->bt_dev_address, &data->rem_device_info->bd_addr, sizeof(T_MFW_BT_DM_DEV_ADDR));
+			memcpy(&data->bt_device_name, data->rem_device_info->name, MFW_BT_NAME_LENGTH);
+			/*
+			** Initialise the editor
+			*/
+			AUI_edit_SetDefault(&editor_data);
+			AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, data->bt_device_name, MFW_BT_NAME_LENGTH);
+			AUI_edit_SetTextStr(&editor_data, TxtSoftSelect, TxtSoftBack, TxtBtEnterDeviceName, TxtNull);
+			AUI_edit_SetAltTextStr(&editor_data, 1, TxtNull, TRUE, TxtCancel);
+			AUI_edit_SetEvents(&editor_data, BT_REM_DEV_NAME_EDITOR, TRUE, FOREVER, (T_AUI_EDIT_CB)mmi_bluetooth_editor_cb);
+			data->bt_dev_name_editor = AUI_edit_Start(data->win, &editor_data);
+#endif
+			break;
+		case BT_EDITOR_CANCEL:
+			if (value == BT_DEV_NAME_EDITOR)
+			{
+				if (bt_data.bt_DevNameForStartup)
+				{
+					/*
+					** The User has cancelled the input from a "Device Name" request, which was
+					** requested as a result of the startup sequence. Return a FALSE value to the
+					** MFW as an indication. Not bothered about the return value as this is a fail anyway!
+					*/
+					(void)mfw_bt_dm_set_local_name((void *)0);
+				}
+				/*
+				** The editor will have been destroyed. Reset the Window handler
+				*/
+				data->bt_dev_name_editor = (void *)0;
+			}
+			else if (value == BT_REM_DEV_NAME_EDITOR)	/* CQ21843 : Add Editor processing for new action */
+			{
+				/*
+				** The editor will have been destroyed. Reset the Window handler
+				*/
+				data->bt_dev_name_editor = (void *)0;
+			}
+			else
+			{
+				MFW_BT_TRACE_P1("mmi_bt_dev_name_cntrl(), BT_EDITOR_CANCEL event received with unexpected value %d", value);
+			}
+			/*
+			** Destroy the Device Name Request Window
+			*/
+			mmi_bt_dev_name_destroy(data->win);
+			break;
+		case BT_EDITOR_SELECT:
+			if (value == BT_DEV_NAME_EDITOR)
+			{
+				/*
+				** The user has entered a Device Name, pass it to the MFW for processing
+				*/
+				btRetVal = mfw_bt_dm_set_local_name((void *)&data->bt_device_name);
+				if (btRetVal != MFW_BT_SUCCESS)
+				{
+					MFW_BT_TRACE_P1("mmi_bt_dev_name_cntrl() : Attempt to set Device Name Failed with %d", btRetVal);
+				}
+				else
+				{
+					/*
+					** Create a timed dialog to display the Message "Device Name Set"
+					*/
+					mmi_bluetooth_show_info(0, TxtBtDeviceName, TxtBtSet);
+				}
+				/*
+				** CQ21957 : The editor will have been destroyed. Reset the Window handler
+				*/
+				data->bt_dev_name_editor = (void *)0;
+			}
+			else if (value == BT_REM_DEV_NAME_EDITOR)	/* CQ21843 : Add Editor processing for new action */
+			{
+				/*
+				** The user has entered a Device Name, pass it to the MFW for processing
+				*/
+				btRetVal = mfw_bt_dm_rename_device(data->bt_dev_address, data->bt_device_name);
+				if (btRetVal != MFW_BT_SUCCESS)
+				{
+					MFW_BT_TRACE_P1("mmi_bt_dev_name_cntrl() : Attempt to set Remote Device Name Failed with %d", btRetVal);
+				}
+				else
+				{
+					/*
+					** Create a timed dialog to display the Message "Device Name Set"
+					*/
+					mmi_bluetooth_show_info(0, TxtBtDeviceName, TxtBtSet);
+					/*
+					** Set the Name in the local Device list, so that the Menu will be updated
+					*/
+					memcpy(&data->rem_device_info->name, &data->bt_device_name, MFW_BT_NAME_LENGTH);
+				}
+				/*
+				** CQ21957 : The editor will have been destroyed. Reset the Window handler
+				*/
+				data->bt_dev_name_editor = (void *)0;
+			}
+			else
+			{
+				MFW_BT_TRACE_P1("mmi_bt_dev_name_cntrl(), BT_EDITOR_SELECT event received with unexpected value %d", value);
+			}
+			/*
+			** Destroy the Device Name Request Window
+			*/
+			mmi_bt_dev_name_destroy(data->win);
+			break;
+		default:
+			MFW_BT_TRACE("mmi_bt_dev_name_cntrl() : Unexpected Event!");
+	}
+	return;
+}
+/*******************************************************************************
+$Function:		mmi_bt_authorize_create
+$Description:		This function performs the necessary steps to create the a window to handle the
+				Authorize Request. It will be removed, or rather remove itself on returning the
+				data to the Mfw.
+$Returns:		T_MFW_HND : Window Handle to the New Window, Null if failed.
+$Arguments:		parent : pointer to the parent window.
+*******************************************************************************/
+T_MFW_HND mmi_bt_authorize_create(T_MFW_HND parent)
+{
+	T_MMI_BT_Authorise_Data *data;
+	T_MFW_WIN * win;
+	data = (T_MMI_BT_Authorise_Data *)mfwAlloc((U16)sizeof(T_MMI_BT_Authorise_Data));
+	if (data == (void *)0)
+		return data;
+	data->win = winCreate(parent, 0, E_WIN_VISIBLE, mmi_bluetooth_win_cb);
+	if (data->win == (void *)0)
+	{
+		/*
+		** Failed to start : Free Memory, and exit
+		*/
+		mfwFree((U8 *)data, (U16)sizeof(T_MMI_BT_Authorise_Data));
+		data = (void *)0;
+		return data;
+	}
+	else
+	{
+		/*
+		** Setup the Dialog control functions
+		*/
+		data->mmi_control.dialog = (T_DIALOG_FUNC)mmi_bt_authorize_cntrl;
+		data->mmi_control.data = data;
+		win = ((T_MFW_HDR *)data->win)->data;
+		win->user = (void *)data;
+	}
+	bt_data.bt_authorize_win = data->win;
+	return data->win;
+}
+/*******************************************************************************
+$Function:		mmi_bt_authorize_destroy
+$Description:		This function performs the necessary steps to remove the window handling for the
+				Authorize request, tidying up all allocated resources.
+$Returns:		MfwResOk : Success
+				MfwResIllHnd : Illegal Window Handler provided
+$Arguments:		win : Window to be destroyed
+*******************************************************************************/
+MfwRes mmi_bt_authorize_destroy(T_MFW_HND win)
+{
+	T_MFW_WIN * win_data;
+	T_MMI_BT_Authorise_Data * data;
+	if (win == (void *)0)
+		return MfwResIllHnd;
+	win_data = ((T_MFW_HDR *) win)->data;
+	data = (T_MMI_BT_Authorise_Data *)win_data->user;
+	/*
+	** Destroy the Window
+	*/
+	win_delete(data->win);
+	/*
+	** Free the dynamically allocated memory
+	*/
+	mfwFree((U8 *)data, (U16)sizeof(T_MMI_BT_Authorise_Data));
+	bt_data.bt_authorize_win = (void *)0;
+	return MfwResOk;
+}
+/*******************************************************************************
+$Function:		mmi_bt_authorize_cntrl
+$Description:		This is the dialog control function for the Authorise Request Window. It receives
+				the signals from the MFW and determines what action, if any, to take.
+$Returns:		None
+$Arguments:		win :		The pointer to the window handler, so the function can reference the
+							dynamic user data, if any.
+				event :		The incoming event
+				value :		Generic incoming Parameter, it will be 'event' dependant
+				parameter :	Generic incoming Parameter, it will be 'event' dependant
+*******************************************************************************/
+void mmi_bt_authorize_cntrl (T_MFW_HND win, USHORT event, SHORT value, void * parameter)
+{
+	T_MFW_WIN			* win_data = ((T_MFW_HDR *) win)->data;
+	T_MMI_BT_Authorise_Data * data = (T_MMI_BT_Authorise_Data *)win_data->user;
+	T_DISPLAY_DATA		display_info;
+	T_MFW_BT_STATUS		btRetVal;
+	MFW_BT_TRACE_P1("mmi_bluetooth() : Event Received : %d", event);
+	switch (event)
+	{
+		case BT_AUTHORIZE_REQ:
+			data->bt_auth_req_param = (T_MFW_BT_DM_AUTHORIZE_REQ *)mfwAlloc(sizeof(T_MFW_BT_DM_AUTHORIZE_REQ));
+			if (data->bt_auth_req_param == (T_MFW_BT_DM_AUTHORIZE_REQ *)0)
+			{
+				/*
+				** Problems with Memory Allocation, so reject the request this time
+				*/
+				btRetVal = mfw_bt_dm_authorize_resp(MFW_BT_AUTH_FAIL);
+				mfwFree((void *)data->bt_auth_req_param, (U16)sizeof(T_MFW_BT_DM_AUTHORIZE_REQ));
+				mmi_bt_authorize_destroy(data->win);
+				return;
+			}
+			memcpy(data->bt_auth_req_param, parameter, sizeof(T_MFW_BT_DM_AUTHORIZE_REQ));
+			/*
+			** if the length of the Device Name is greater than a predefined limit, truncate it :o)
+			*/
+			if (strlen((char *)(data->bt_auth_req_param)->bd_name) > BT_MAX_DISPLAY_DEV_NAME_LENGTH)
+			{
+				/*
+				** Terminate the device name at this maximum length!
+				** It will be used for display purposes only!
+				*/
+				data->bt_auth_req_param->bd_name[BT_MAX_DISPLAY_DEV_NAME_LENGTH] = 0x00;
+			}
+			/*
+			** Create a popup dialog to prompt the user whether to proceed with the authorization.
+			** CQ22022 : Call to dlg_initDisplayData_TextId removed, and dlg_initDisplayData_TextStr updated.
+			*/
+			dlg_initDisplayData_TextStr( &display_info, TxtSoftOptions, TxtNo, MmiRsrcGetText(TxtBtAuthorize), (char *)(data->bt_auth_req_param)->bd_name, COLOUR_STATUS);
+			dlg_initDisplayData_events(&display_info, (T_VOID_FUNC)mmi_bt_authorize_dlg_cb, BT_AUTHORISE_RESP_TIMEOUT, KEY_HUP | KEY_LEFT| KEY_RIGHT);
+			data->bt_auth_info_win = info_dialog(data->win, &display_info);
+			break;
+		default:
+			MFW_BT_TRACE("mmi_bluetooth() : Unexpected Event!");
+	}
+	return;
+}
+/*******************************************************************************
+$Function:		mmi_bt_authorize_dlg_cb
+$Description:		This function is the windows callback function for the Authorize Request Dialog.
+$Returns:		None
+$Arguments:		win : The pointer to the window handler, so the function can reference the
+				dynamic user data, if any.
+				identifier : is a flag set during Dialog Create.
+				reason : is the event to be processed
+*******************************************************************************/
+void mmi_bt_authorize_dlg_cb(T_MFW_HND win, UBYTE identifier, UBYTE reason)
+{
+	T_MFW_HND	parent = bt_data.bt_authorize_win;
+	T_MFW_WIN   * win_data = ((T_MFW_HDR *) parent)->data;
+	T_MMI_BT_Authorise_Data * data = (T_MMI_BT_Authorise_Data *)win_data->user;
+	T_MFW_BT_STATUS	btRetVal;
+	MFW_BT_TRACE("mmi_bt_authorize_dlg_cb()");
+	switch (reason)
+	{
+		case INFO_KCD_LEFT:
+			/*
+			** Create an Authorize Menu and get the Response (Once, Always or No)
+			*/
+			data->bt_auth_menu = bt_menu_start(data->win, (MfwMnuAttr *)&menuBtAuthorize, (T_VOID_FUNC)mmi_bt_authorize_rsk);
+			/*
+			** CQ22021 : The Dialog is destroyed automatically, reset the win value to NULL
+			*/
+			data->bt_auth_info_win = 0;
+			break;
+		case INFO_KCD_HUP:
+		case INFO_KCD_RIGHT:
+			btRetVal = mfw_bt_dm_authorize_resp((U8)MFW_BT_AUTH_FAIL);
+			mfwFree((void *)data->bt_auth_req_param, (U16)sizeof(T_MFW_BT_DM_AUTHORIZE_REQ));
+			/*
+			** CQ22021 : The Dialog is destroyed automatically, reset the win value to NULL
+			*/
+			data->bt_auth_info_win = 0;
+			mmi_bt_authorize_destroy(data->win);
+			break;
+	}
+	return;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_search_create
+$Description:		This function performs the necessary steps to create the bluetooth search window,
+				set up the dialog, and create a Bluetooth Entity within that window. The Bt Search window
+				is a child of the Bt Root Window, and is used to manage the search for local devices or
+				the listing of known devices and the subsequent functions available after that
+$Returns:		BOOL - True is successful, otherwise FALSE
+$Arguments:		None
+*******************************************************************************/
+BOOL mmi_bt_search_create (T_MFW_HND parent)
+{
+	T_MMI_BtSearchData *data = &bt_srch_data;
+	T_MFW_WIN		    *win;
+	BOOL retVal = TRUE;
+	MFW_BT_TRACE("mmi_bt_search_create()");
+	/*
+	** If the Bluetooth Search is already created then there is nothing to do.
+	*/
+	if ((data->win == (void *)0) ||
+	     (data->srch_bt_cmpnt == (void *)0))
+	{
+		/*
+		** Create the Bluetooth Search Window
+		*/
+		MFW_BT_TRACE("mmi_bt_search_create >> Creating BT Search Window");
+		if (data->win == (void *)0)
+			data->win = win_create(parent, 0, E_WIN_VISIBLE, (MfwCb)mmi_bluetooth_win_cb);
+		if (data->win == (void *)0)
+		{
+			MFW_BT_TRACE("mmi_bt_search_create >> Create BT Search Window FAILED");
+			/*
+			** Bluetooth Search Failed to start
+			*/
+			retVal = FALSE;
+		}
+		else
+		{
+			MFW_BT_TRACE("mmi_bt_search_create >> Configuring Window Dialog");
+			/*
+			** Setup the Dialog control functions
+			*/
+			data->srch_bt_control.dialog = (T_DIALOG_FUNC)mmi_bt_search_cntrl;
+			data->srch_bt_control.data = data;
+			win = ((T_MFW_HDR *)data->win)->data;
+			win->user = (void *)data;
+			/*
+			** Create a Bluetooth component
+			*/
+			if (data->srch_bt_cmpnt == (void *)0)
+			{
+				MFW_BT_TRACE("mmi_bt_search_create >> Creating MFW_BT Component");
+				data->srch_bt_cmpnt = mfw_bt_create(data->win, E_BT_ALL_SERVICES, (MfwCb)mmi_bluetooth_search_cb);
+			}
+			else
+			{
+				MFW_BT_TRACE("mmi_bt_search_create >> MFW_BT Component Already EXISTS????");
+			}
+			if (data->srch_bt_cmpnt == (void *)0)
+			{
+				retVal = FALSE;
+				/*
+				** Bluetooth Search Compnonent Failed to start
+				*/
+				winDelete(data->win);
+			}
+			else
+			{
+				/*
+				** Create a Timer component to Timeout a Device Search if no response from BT_Mobile
+				*/
+				MFW_BT_TRACE("mmi_bt_search_create > Creating the search timer");
+				if (data->srch_bt_search_timer == (void *)0)
+					data->srch_bt_search_timer = timCreate(data->win,
+														BT_SEARCH_RESP_TIMEOUT,
+														(MfwCb)mmi_bluetooth_search_timer_cb);
+				if (data->srch_bt_search_timer == (void *)0)
+				{
+					MFW_BT_TRACE("mmi_bt_search_create > search timer creation failed ");
+					/*
+					** Timer Compnonent Failed to start, delete previous components
+					*/
+					mfw_bt_delete(data->srch_bt_cmpnt);
+					winDelete(data->win);
+				}
+				else
+				{
+					timStart(data->srch_bt_search_timer);
+				}
+			}
+		}
+	}
+	return retVal;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_destroy
+$Description:		This function performs the necessary steps to remove the bluetooth, search window
+				tidying up all allocated resources.
+$Returns:		None
+$Arguments:		None
+*******************************************************************************/
+GLOBAL void  mmi_bt_search_destroy (void)
+{
+	T_MMI_BtSearchData * data = &bt_srch_data;
+	MFW_BT_TRACE("mmi_bluetooth_search_destroy()");
+	if (data->win == (void *)0)
+		return;
+	if (data->srch_bt_pairing_pin_editor != (void *)0)
+		SEND_EVENT(data->srch_bt_pairing_pin_editor, E_ED_DEINIT, 0, 0);
+	if (data->srch_bt_please_wait_dialog != (void *)0)
+		SEND_EVENT(data->srch_bt_please_wait_dialog, DIALOG_DESTROY, 0, 0);
+	if (data->srch_bt_cmpnt != (void *)0)
+		mfw_bt_delete(data->srch_bt_cmpnt);
+	if (data->srch_bt_search_timer != (void *)0)
+		timDelete(data->srch_bt_search_timer);
+	winDelete(data->win);
+	data->win = (void *)0;
+	data->srch_bt_pairing_pin_editor = (void *)0;
+	data->srch_bt_please_wait_dialog = (void *)0;
+	data->srch_bt_dev_list_win = (void *)0;
+	data->srch_bt_show_services_win = (void *)0;
+	data->srch_bt_cmpnt = (void *)0;
+	data->srch_bt_search_timer = (void *)0;
+	return;
+}
+/*******************************************************************************
+$Function:		mmi_bt_search_cntrl
+$Description:		This is the dialog control function for the Bluetooth Search Window. It receives the signals
+				from the MFW or BMI and determines what action, if any, to take.
+$Returns:		None
+$Arguments:		win :		The pointer to the window handler, so the function can reference the
+							dynamic user data, if any.
+				event :		The incoming event
+				value :		Generic incoming Parameter, it will be 'event' dependant
+				parameter :	Generic incoming Parameter, it will be 'event' dependant
+*******************************************************************************/
+void mmi_bt_search_cntrl (T_MFW_HND win, USHORT event, SHORT value, void * parameter)
+{
+	T_MFW_WIN			* win_data = ((T_MFW_HDR *) win)->data;
+	T_MMI_BtSearchData	* data = (T_MMI_BtSearchData *)win_data->user;
+	T_DISPLAY_DATA		display_info;
+	T_AUI_EDITOR_DATA	editor_data;
+	BOOL				valid;
+	BOOL				btIsDiscoverable;
+	UBYTE				*ptr_device_name;
+	T_MFW_BT_STATUS			btRetVal;
+	T_MFW_BT_DM_AUTH_CMPL		*auth_cmpl_param;
+	T_MFW_BT_DM_INQ_CMPL		*inq_cmpl_param;
+	T_MFW_BT_DM_DISC_RES		*disc_res_param;
+	T_MFW_BT_REM_DEVICE_INFO	*cur_device;
+	MfwMnuItem *listItem;
+	T_MFW_BT_REM_DEVICE_INFO *device;
+	MfwMnuItem			*ptr_tempListItem;
+	T_MFW_BT_REM_DEVICE_INFO	*ptr_tempDevDb;
+	UINT8 num_of_services;
+	int  iLoop;
+	MFW_BT_TRACE_P1("mmi_bt_search_cntrl() : Event Received : %d", event);
+	switch (event)
+	{
+		case BT_EDITOR_CANCEL:
+			if ((value == BT_DEV_NAME_EDITOR) ||
+			     (value == BT_REM_DEV_NAME_EDITOR) ||		/* CQ21843 : Editor Identier has another value */
+			     (value == BT_PIN_REQ_EDITOR))
+			{
+				/*
+				** Not handled by this window, pass to the root window.
+				*/
+				MFW_BT_TRACE_P1("mmi_bt_search_cntrl() : Unexpected Editor Cancel Event : value = %d!", value);
+			}
+			else if (value == BT_PAIRING_EDITOR)
+			{
+				data->srch_bt_req_resp = BT_NOT_EXPECTED;
+				/*
+				** The User has cancelled the input from a Pairing  Pin request,
+				** the process has not been started. Don't proceed.
+				*/
+				/*
+				** The editor will have been destroyed. Reset the Window handler
+				*/
+				data->srch_bt_pairing_pin_editor = (void *)0;
+			}
+			else
+			{
+				MFW_BT_TRACE_P1("mmi_bt_search_cntrl(), BT_EDITOR_CANCEL event received with unknown value %d", value);
+			}
+			break;
+		case BT_EDITOR_SELECT:
+			if ((value == BT_DEV_NAME_EDITOR) ||
+			     (value == BT_REM_DEV_NAME_EDITOR) ||		/* CQ21843 : Editor Identier has another value */
+			     (value == BT_PIN_REQ_EDITOR))
+			{
+				/*
+				** Not handled by this window, pass to the root window.
+				*/
+				MFW_BT_TRACE_P1("mmi_bt_search_cntrl() : Unexpected Editor Select Event : value = %d!", value);
+			}
+			else if (value == BT_PAIRING_EDITOR)
+			{
+				/*
+				** The editor will have been destroyed. Reset the Window handler
+				*/
+				data->srch_bt_pairing_pin_editor = (void *)0;
+				data->srch_bt_req_resp = BT_PAIRED_NOT_RESP;
+				/*
+				**The user has entered a Pin Key, now use it in the pairing process
+				*/
+				cur_device = &data->srch_bt_dev_list[data->srch_bt_cur_dev_idx];
+				btRetVal = mfw_bt_dm_bond(cur_device->bd_addr,
+										     (void *)&data->bt_pairing_pin_buf,
+										     strlen((void *)&data->bt_pairing_pin_buf));
+				if (btRetVal != MFW_BT_SUCCESS)
+				{
+					MFW_BT_TRACE_P1("mmi_bt_search_cntrl() : Attempt to start Pairing process Failed with %d", btRetVal);
+				}
+				else
+					data->srch_bt_please_wait_dialog = mmi_bluetooth_show_please_wait(data->win);
+			}
+			else
+			{
+				MFW_BT_TRACE_P1("mmi_bt_search_cntrl(), BT_EDITOR_SELECT event received with unknown value %d", value);
+			}
+			break;
+		case BT_AUTH_COMPLETE:
+			auth_cmpl_param = (T_MFW_BT_DM_AUTH_CMPL *)parameter;
+			if (data->srch_bt_req_resp == BT_NOT_EXPECTED)
+			{
+				/*
+				** Not handled by this window, pass to the root window.
+				*/
+				MFW_BT_TRACE("mmi_bt_search_cntrl() : Unexpected Auth_Complete Event");
+			}
+			else
+			{
+				UBYTE iLoop;
+				T_MFW_BT_REM_DEVICE_INFO *device;
+				MFW_BT_TRACE_P6("mmi_bt_search_cntrl(), Auth BD_ADDR 0x%02x%02x%02x%02x%02x%02x",
+								     auth_cmpl_param->bd_addr[0], auth_cmpl_param->bd_addr[1],
+								     auth_cmpl_param->bd_addr[2], auth_cmpl_param->bd_addr[3],
+								     auth_cmpl_param->bd_addr[4], auth_cmpl_param->bd_addr[5]);
+				if (data->srch_bt_please_wait_dialog != (void *)0)
+				{
+					SEND_EVENT(data->srch_bt_please_wait_dialog, DIALOG_DESTROY, 0, 0);
+					data->srch_bt_please_wait_dialog = (void *)0;
+				}
+				if (data->srch_bt_req_resp == BT_PAIRED_NOT_RESP)
+				{
+					if (auth_cmpl_param->is_success == FALSE)
+					{
+						/*
+						** Create a timed dialog to display the Message "Pairing Failed"
+						*/
+						mmi_bluetooth_show_info(data->win, TxtBtPairing, TxtFailed);
+					}
+					else
+					{
+						/*
+						** Create a timed dialog to display the Message "Paired"
+						*/
+						mmi_bluetooth_show_info(data->win, TxtBtPaired, TxtNull);
+						/*
+						** This will have been as part of a "Device List" either known or local
+						** The device will have been added to the known devices list, and will
+						** have a link_key present. Update our local data to reflect this.
+						*/
+						iLoop = 0;
+						while (iLoop < data->srch_bt_num_devices)
+						{
+							device = &data->srch_bt_dev_list[iLoop];
+							MFW_BT_TRACE_P7("mmi_bt_search_cntrl(), dev_list[%d] BD_ADDR 0x%02x%02x%02x%02x%02x%02x",
+											     iLoop, device->bd_addr[0], device->bd_addr[1], device->bd_addr[2], device->bd_addr[3],
+											     device->bd_addr[4], device->bd_addr[5]);
+							if (memcmp(&device->bd_addr[0], &auth_cmpl_param->bd_addr[0], BD_ADDR_LEN) == 0 )
+							{
+								MFW_BT_TRACE("mmi_bt_search_cntrl() : Auth_Complete Event, device found");
+								device->link_key_present = TRUE;
+								device->is_new = FALSE;
+								iLoop = 0xFF;
+							}
+							else
+								iLoop++;
+						}
+					}
+				}
+				data->srch_bt_req_resp = BT_NOT_EXPECTED;
+			}
+			break;
+		case BT_LIST_KNOWN_DEVICES:
+			{
+				BD_ADDR null_bd_addr;
+				memset(&null_bd_addr, 0x00, sizeof(BD_ADDR));
+			/*
+			** Get the known devices from the MFW
+			*/
+			data->srch_bt_mode = BT_MODE_KNOWN_DEVICES;
+				mfw_bt_dm_get_known_devices(null_bd_addr, BTA_ALL_SERVICE_MASK);
+			}
+			break;
+		case BT_DEVICE_SEARCH:
+			/*
+			** Trigger Bluetooth to search locally for any devices
+			*/
+			data->srch_bt_mode = BT_MODE_LOCAL_SEARCH;
+			/* Search for all devices, not service specified */
+			mfw_bt_dm_search(0);
+			data->srch_bt_please_wait_dialog = mmi_bluetooth_show_please_wait(data->win);
+			break;
+		case BT_INQUIRY_COMPLETE:
+			MFW_BT_TRACE("mmi_bt_search_cntrl > Recieved the INQUIRY COMPLETE Event");
+			inq_cmpl_param = (T_MFW_BT_DM_INQ_CMPL *)parameter;
+			if ((data->srch_bt_mode == BT_MODE_KNOWN_DEVICES) ||
+			     (data->srch_bt_mode == BT_MODE_LOCAL_SEARCH))
+			{
+				(void)timStop(data->srch_bt_search_timer);
+				if (data->srch_bt_please_wait_dialog != (void *)0)
+				{
+					SEND_EVENT(data->srch_bt_please_wait_dialog, DIALOG_DESTROY, 0, 0);
+					data->srch_bt_please_wait_dialog = (void *)0;
+				}
+			if (inq_cmpl_param->num_resps == 0)
+			{
+				/*
+				** Display an Dialog Screen to display "No Devices Found"
+				*/
+				mmi_bluetooth_show_info_callback(data->win, TxtBtNoDevices, TxtBtFound, mmi_bt_srch_no_device_found_dlg_cb);
+					data->srch_bt_mode = BT_MODE_NO_SEARCH;
+			}
+			else
+			{
+					MFW_BT_TRACE("mmi_bt_search_cntrl > Initialising the List");
+				/*
+				** Create the list menu to display the results
+				*/
+				/* initialization of the dialog data */
+				data->srch_bt_list_devices_menu_data.ListPosition   = 1;/* True cursor position in list menu. */
+				data->srch_bt_list_devices_menu_data.Font           = 0;
+				data->srch_bt_list_devices_menu_data.LeftSoftKey    = TxtNull;
+				data->srch_bt_list_devices_menu_data.RightSoftKey   = TxtCancel;
+				data->srch_bt_list_devices_menu_data.KeyEvents      = KEY_RIGHT;
+				data->srch_bt_list_devices_menu_data.Reason         = 0;
+				data->srch_bt_list_devices_menu_data.Strings        = TRUE;
+				data->srch_bt_list_devices_menu_data.autoDestroy    = FALSE;
+				data->srch_bt_list_devices_menu_data.Attr           = (MfwMnuAttr *)&menuBtSearchListAttr;
+				data->srch_bt_list_devices_menu_data.Attr->hdrId = TxtSearching;
+					/*
+					** CQ21834 : Special processing for Known Device List.
+					*/
+					if (data->srch_bt_mode == BT_MODE_KNOWN_DEVICES)
+					{
+						/*
+						** "Known devices" requires an extra entry, for further details see the comment below
+						*/
+						data->srch_bt_list_devices_menu_data.Attr->nItems = inq_cmpl_param->num_resps + 1;
+						data->srch_bt_list_devices_menu_data.ListLength = inq_cmpl_param->num_resps + 1; /* actual number of entries in list menu.    */
+					}
+					else
+					{
+				data->srch_bt_list_devices_menu_data.Attr->nItems = inq_cmpl_param->num_resps;
+						data->srch_bt_list_devices_menu_data.ListLength = inq_cmpl_param->num_resps; /* actual number of entries in list menu.    */
+					}
+				data->srch_bt_list_devices_menu_data.List = (MfwMnuItem *)mfwAlloc(data->srch_bt_list_devices_menu_data.ListLength * sizeof (MfwMnuItem));
+				if (data->srch_bt_list_devices_menu_data.List != (MfwMnuItem *)0)
+				{
+					MfwMnuItem *listItem;
+					MFW_BT_TRACE("mmi_bt_search_cntrl > List Memory Allocated successfully");
+					/*
+					** Initialise the memory to 0x00
+					*/
+					memset(data->srch_bt_list_devices_menu_data.List, 0x00, data->srch_bt_list_devices_menu_data.ListLength * sizeof (MfwMnuItem));
+					for (iLoop = 0; iLoop <data->srch_bt_list_devices_menu_data.ListLength; iLoop++)
+					{
+						listItem = &data->srch_bt_list_devices_menu_data.List[iLoop];
+						listItem->str = MmiRsrcGetText(TxtPleaseWait);
+						listItem->menu =     (MfwMnuAttr *)&menuBtDeviceOptions;
+						listItem->func =       (MenuFunc)mmi_bluetooth_device_mnu_cb;
+						listItem->flagFunc = (FlagFunc)item_flag_hide;
+					}
+						/*
+						** CQ21834 : If we are displaying a list of known devices, then if ALL the devices
+						** are removed from the list, there must be another entry to display otherwise
+						** the D-Sample will reset because it will enter an infinite loop. This is overcome
+						** by added an extra (an normally hidden) entry which will display "No Devices".
+						*/
+						if (data->srch_bt_mode == BT_MODE_KNOWN_DEVICES)
+						{
+							listItem = &data->srch_bt_list_devices_menu_data.List[inq_cmpl_param->num_resps];
+							listItem->str = MmiRsrcGetText(TxtBtNoDevices);
+							listItem->menu =     (MfwMnuAttr *)0;
+							listItem->func =       (MenuFunc)0;
+							listItem->flagFunc = (FlagFunc)isDeviceListEmpty;
+						}
+				}
+				data->srch_bt_dev_list_cb = (ListCbFunc)bt_srch_dev_list_searching_cb;
+				data->srch_bt_dev_list_win = (void *)0;
+				/*
+				** Create a dynamic memory pool to store the necessary data for the following menus
+				*/
+				data->srch_bt_num_devices = inq_cmpl_param->num_resps;
+				data->srch_bt_dev_list = (T_MFW_BT_REM_DEVICE_INFO *)mfwAlloc(sizeof(T_MFW_BT_REM_DEVICE_INFO) * data->srch_bt_num_devices);
+				data->srch_bt_device_count = 0;
+				}
+			}
+			break;
+		case BT_DISCOVER_RESULT:
+			disc_res_param = (T_MFW_BT_DM_DISC_RES *)parameter;
+			if (!mfw_bt_dm_is_discover())
+			{
+				/* We get here at the end of inquiry process */
+			/*
+			** If the mode is 'LIST COMPLETE' at this point it is because the user cancel the search but there
+			** were device events queued ... ignore them.
+			*/
+			if ((data->srch_bt_dev_list) &&
+			     (data->srch_bt_list_devices_menu_data.List) &&
+			     ((data->srch_bt_mode == BT_MODE_KNOWN_DEVICES) ||
+			      (data->srch_bt_mode == BT_MODE_LOCAL_SEARCH)))
+			{
+				if (data->srch_bt_dev_list_win != (void *)0)
+				{
+					/*
+					** The menu is recreated on each device received because the user may decide to halt
+					** the search at any point. For Known devices the menu is created at the end because
+					** The reponse for ALL devices is immediate.
+					** Delete the Menu window, as it will be recreated at the end of this operation
+					*/
+					listsDestroy(data->srch_bt_dev_list_win);
+				}
+				listItem = &data->srch_bt_list_devices_menu_data.List[data->srch_bt_device_count];
+				device = &data->srch_bt_dev_list[data->srch_bt_device_count];
+				memcpy(device, disc_res_param, sizeof(T_MFW_BT_REM_DEVICE_INFO));
+				listItem->str = device->name;
+					/*
+					** CQ21834 : For Known Devices, the device should be hidden in the list if the "Remove Device" menu
+					** 			option is selected.
+					*/
+					if (data->srch_bt_mode == BT_MODE_KNOWN_DEVICES)
+						listItem->flagFunc = (FlagFunc)isListDeviceUnknown;
+					else
+				listItem->flagFunc = (FlagFunc)item_flag_none;
+				MFW_BT_TRACE_P3("mmi_bt_search_cntrl > Idx %d : Device Name : %s, Item Str %s",
+								    data->srch_bt_device_count,
+								    device->name,
+								    listItem->str);
+				data->srch_bt_device_count++;
+				if (data->srch_bt_device_count == data->srch_bt_num_devices)
+				{
+					data->srch_bt_list_devices_menu_data.Attr->hdrId = TxtBtDevices;
+					data->srch_bt_list_devices_menu_data.LeftSoftKey = TxtSoftOptions;
+					data->srch_bt_list_devices_menu_data.RightSoftKey = TxtSoftBack;
+					data->srch_bt_list_devices_menu_data.KeyEvents      = KEY_CLEAR | KEY_RIGHT | KEY_LEFT | KEY_MNUUP | KEY_MNUDOWN |KEY_HUP;
+					data->srch_bt_list_devices_menu_data.autoDestroy = TRUE;
+					data->srch_bt_mode = BT_MODE_LIST_COMPLETE;
+					data->srch_bt_dev_list_cb = (ListCbFunc)bt_srch_dev_list_listmnu_cb;
+				}
+				if ((data->srch_bt_mode == BT_MODE_LOCAL_SEARCH) ||
+				     (data->srch_bt_mode == BT_MODE_LIST_COMPLETE))
+				{
+					/*
+					** Recreate the menu with the new details;
+					*/
+					if (listDisplayListMenu(data->win, &data->srch_bt_list_devices_menu_data, data->srch_bt_dev_list_cb, FALSE) != LISTS_FAIL)
+						data->srch_bt_dev_list_win = data->srch_bt_list_devices_menu_data.win;
+				}
+			}
+			}
+			else
+			{
+				/* We get here at the end of services discovery process */
+				if (data->srch_bt_please_wait_dialog != (void *)0)
+				{
+					SEND_EVENT(data->srch_bt_please_wait_dialog, DIALOG_DESTROY, 0, 0);
+					data->srch_bt_please_wait_dialog = (void *)0;
+				}
+				device = &data->srch_bt_dev_list[data->srch_bt_cur_dev_idx];
+				device->services = disc_res_param->services;
+				MFW_BT_TRACE("mmi_bt_search_cntrl > Memset srch_bt_cur_dev_serv_list to 0x00 ... ");
+			memset(data->srch_bt_cur_dev_serv_list, 0x00, (sizeof(ULONG)*(BTA_MAX_SERVICE_ID-1)));
+				num_of_services = bt_count_dev_services(device->services,
+												     data->srch_bt_cur_dev_serv_list);
+				MFW_BT_TRACE("mmi_bt_search_cntrl > Initialising the List Data");
+				/*
+				** Create the list menu to display the results
+				*/
+				/* initialization of the dialog data */
+				data->srch_bt_show_services_menu_data.ListPosition   = 1;/* True cursor position in list menu. */
+				data->srch_bt_show_services_menu_data.Font           = 0;
+				data->srch_bt_show_services_menu_data.LeftSoftKey    = TxtNull;
+				data->srch_bt_show_services_menu_data.RightSoftKey   = TxtSoftBack;
+				data->srch_bt_show_services_menu_data.KeyEvents      = KEY_CLEAR | KEY_RIGHT | KEY_MNUUP | KEY_MNUDOWN |KEY_HUP;
+				data->srch_bt_show_services_menu_data.Reason         = 0;
+				data->srch_bt_show_services_menu_data.Strings        = FALSE;
+				data->srch_bt_show_services_menu_data.autoDestroy    = TRUE;
+				data->srch_bt_show_services_menu_data.Attr           = (MfwMnuAttr *)&menuBtShowServicesListAttr;
+				data->srch_bt_show_services_menu_data.Attr->hdrId = TxtBtServices;
+				data->srch_bt_show_services_menu_data.Attr->nItems = num_of_services;
+				data->srch_bt_show_services_menu_data.ListLength = num_of_services; /* actual number of entries in list menu.    */
+				data->srch_bt_show_services_menu_data.List = (MfwMnuItem *)mfwAlloc(data->srch_bt_show_services_menu_data.ListLength * sizeof (MfwMnuItem));
+				if (data->srch_bt_show_services_menu_data.List != (MfwMnuItem *)0)
+				{
+					/*
+					** Initialise the memory to 0x00
+					*/
+					memset(data->srch_bt_show_services_menu_data.List, 0x00, data->srch_bt_show_services_menu_data.ListLength * sizeof (MfwMnuItem));
+					for (iLoop = 0; iLoop < data->srch_bt_show_services_menu_data.ListLength; iLoop++)
+					{
+						listItem = &data->srch_bt_show_services_menu_data.List[iLoop];
+						listItem->str =(char *)bt_get_TxtId_for_service(data->srch_bt_cur_dev_serv_list[iLoop]);
+						listItem->flagFunc = (FlagFunc)item_flag_none;
+					}
+					MFW_BT_TRACE("mmi_bt_search_cntrl > Displaying the List Menu!");
+					if (listDisplayListMenu(data->win, &data->srch_bt_show_services_menu_data, (ListCbFunc)bt_srch_service_list_listmnu_cb, FALSE) != LISTS_FAIL)
+							data->srch_bt_show_services_win = data->srch_bt_show_services_menu_data.win;
+				}
+				else
+				{
+					mmi_bluetooth_show_info(data->win, TxtFailed, TxtNull);
+				}
+			}
+			break;
+		case BT_DISCOVER_COMPLETE:
+			/*
+			** CQ 21838 : This event signifies the end of the discover process, this event shoulkd not be ignored.
+			**
+			** If the results for all the expected devices have been received then there will be nothing else to do,
+			** otherwise this signal will have to trigger the end of the search. If no device results had been
+			** reported, then the "No Devices Found".
+			*/
+			if (!mfw_bt_dm_is_discover())
+			{
+				if (data->srch_bt_device_count != data->srch_bt_num_devices)
+				{
+					if (data->srch_bt_device_count == 0)
+					{
+						/*
+						** If No devices have been reported display a dialog
+						*/
+						mmi_bluetooth_show_info_callback(data->win, TxtBtNoDevices, TxtBtFound, mmi_bt_srch_no_device_found_dlg_cb);
+						/*
+						** Destroy the memory allocated when the inquiry complete was received
+						*/
+						mfwFree((U8 *)data->srch_bt_list_devices_menu_data.List,
+									   (data->srch_bt_list_devices_menu_data.ListLength * sizeof (MfwMnuItem)));
+						mfwFree((U8 *)data->srch_bt_dev_list,
+										(sizeof(T_MFW_BT_REM_DEVICE_INFO) * data->srch_bt_num_devices));
+						data->srch_bt_num_devices = 0;
+						data->srch_bt_mode = BT_MODE_NO_SEARCH;
+					}
+					else
+					{
+						/*
+						** There are devices which have been reported.
+						** Change the mode of the list
+						*/
+						data->srch_bt_mode = BT_MODE_LIST_COMPLETE;
+						/*
+						** Destroy the window and recreate it
+						*/
+						listsDestroy(data->srch_bt_dev_list_win);
+						/*
+						** Allocate memory to copy the devices already listed, copy the active data,
+						** and free the memory set aside for ALL the devices to be listed.
+						**
+						** This should NOT be possible for the known device list, so there is no need to take account of the
+						** "No Devices" list entry
+						*/
+						ptr_tempListItem = (MfwMnuItem *)mfwAlloc(data->srch_bt_device_count * sizeof(MfwMnuItem));
+						if (ptr_tempListItem != (MfwMnuItem *)0)
+						{
+							/*
+							** Copy the list of items
+							*/
+							memcpy(ptr_tempListItem, data->srch_bt_list_devices_menu_data.List, (data->srch_bt_device_count * sizeof(MfwMnuItem)));
+							/*
+							** Free the first (and larger) list
+							*/
+							mfwFree((U8 *)data->srch_bt_list_devices_menu_data.List, (U16)(data->srch_bt_list_devices_menu_data.ListLength * sizeof(MfwMnuItem)));
+							data->srch_bt_list_devices_menu_data.List = ptr_tempListItem;
+						}
+						/*
+						** Repeat for the 'Device List'
+						*/
+						ptr_tempDevDb = (T_MFW_BT_REM_DEVICE_INFO *)mfwAlloc(data->srch_bt_device_count * sizeof(T_MFW_BT_REM_DEVICE_INFO));
+						if (ptr_tempDevDb!= (T_MFW_BT_REM_DEVICE_INFO *)0)
+						{
+							/*
+							** Copy the list of devices
+							*/
+							memcpy(ptr_tempDevDb, data->srch_bt_dev_list, (data->srch_bt_device_count * sizeof(T_MFW_BT_REM_DEVICE_INFO)));
+							/*
+							** Free the first (and larger) list
+							*/
+							mfwFree((U8 *)data->srch_bt_dev_list, (U16)(data->srch_bt_num_devices * sizeof(T_MFW_BT_REM_DEVICE_INFO)));
+							data->srch_bt_dev_list = ptr_tempDevDb;
+			}
+						/*
+						** Configure some other List parameters
+						*/
+						data->srch_bt_num_devices = data->srch_bt_device_count;
+						data->srch_bt_list_devices_menu_data.ListLength = data->srch_bt_device_count;
+						data->srch_bt_list_devices_menu_data.Attr->nItems = data->srch_bt_device_count;
+						data->srch_bt_list_devices_menu_data.Attr->hdrId = TxtBtDevices;
+						data->srch_bt_list_devices_menu_data.LeftSoftKey = TxtSoftOptions;
+						data->srch_bt_list_devices_menu_data.RightSoftKey = TxtSoftBack;
+						/*
+						** CQ21842 : Modify the List Key Events so that it handles all teh keys it requires.
+						*/
+						data->srch_bt_list_devices_menu_data.KeyEvents      = KEY_CLEAR | KEY_RIGHT | KEY_LEFT | KEY_MNUUP | KEY_MNUDOWN |KEY_HUP;
+						data->srch_bt_list_devices_menu_data.autoDestroy = TRUE;
+						data->srch_bt_dev_list_cb = (ListCbFunc)bt_srch_dev_list_listmnu_cb;
+						/*
+						** CQ21841 : For each device in the list, reset the string pointer because it will be pointing to the old device
+						** list which has just been freed
+						*/
+						for (iLoop = 0; iLoop < data->srch_bt_num_devices; iLoop++)
+							data->srch_bt_list_devices_menu_data.List[iLoop].str = data->srch_bt_dev_list[iLoop].name;
+						/*
+						** Recreate the menu with the new details;
+						*/
+						if (listDisplayListMenu(data->win, &data->srch_bt_list_devices_menu_data, data->srch_bt_dev_list_cb, FALSE) != LISTS_FAIL)
+							data->srch_bt_dev_list_win = data->srch_bt_list_devices_menu_data.win;
+					}
+				}
+			}
+			break;
+		case BT_PAIR_DEVICE:
+#ifdef NEW_EDITOR
+			/*
+			** Initialise the editor
+			*/
+			AUI_edit_SetDefault(&editor_data);
+			AUI_edit_SetMode(&editor_data, ED_MODE_HIDDEN, ED_CURSOR_BAR);
+			AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, data->bt_pairing_pin_buf, MFW_BT_MAX_PIN_CODE_LEN);
+			AUI_edit_SetTextStr(&editor_data, TxtSoftSelect, TxtSoftBack, TxtBtEnterPassKey, TxtNull);
+			AUI_edit_SetAltTextStr(&editor_data, 1, TxtNull, TRUE, TxtCancel);
+			AUI_edit_SetEvents(&editor_data, BT_PAIRING_EDITOR, TRUE, FOREVER, (T_AUI_EDIT_CB)mmi_bluetooth_editor_cb);
+			data->srch_bt_pairing_pin_editor= AUI_edit_Start(data->win, &editor_data);
+#endif
+			break;
+		case BT_SHOW_DEV_SERVICES:
+			cur_device = &data->srch_bt_dev_list[data->srch_bt_cur_dev_idx];
+			data->srch_bt_please_wait_dialog = mmi_bluetooth_show_please_wait(data->win);
+			mfw_bt_dm_discover_device(cur_device->bd_addr);
+			break;
+		case BT_DISABLE_SEARCH:
+			mmi_bt_search_destroy();
+			break;
+		default:
+			MFW_BT_TRACE("mmi_bluetooth() : Unexpected Event!");
+	}
+	return;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_win_cb
+$Description:		This function is the windows callback function for the Bluetooth Root window.
+				It has no display
+$Returns:		MFW_EVENT_REJECTED : This window does not display anything. The event is rejected
+				so it is passed down the win chain.
+$Arguments:		Not used.
+*******************************************************************************/
+int mmi_bluetooth_win_cb (MfwEvt evt, MfwHnd win)
+{
+	MFW_BT_TRACE("mmi_bluetooth_win_cb()");
+	return MFW_EVENT_REJECTED;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_device_mnu_cb
+$Description:		This function is called when the user has a list of devices (either known or local)
+				and they select 1.
+$Returns:		BOOL - True is successful, otherwise FALSE
+$Arguments:		None
+*******************************************************************************/
+static int  mmi_bluetooth_device_mnu_cb(MfwMnu * mnu, MfwMnuItem * item)
+{
+	MFW_BT_TRACE("mmi_bluetooth_device_mnu_cb()");
+	bt_srch_data.srch_bt_cur_dev_idx = mnu->lCursor[mnu->level];
+	/*
+	** CQ22023 : Modify the Menu Header to display the name of the Current Device
+	*/
+	menuBtDeviceOptions.hdrId = (int)bt_srch_data.srch_bt_dev_list[bt_srch_data.srch_bt_cur_dev_idx].name;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_editor_cb
+$Description:		This function provides the callback functionality to an editor for Bluetooth
+$Returns:		None
+$Arguments:
+*******************************************************************************/
+static void mmi_bluetooth_editor_cb(T_MFW_HND win, USHORT identifier, SHORT reason)
+{
+	T_MFW_WIN		* win_data = ((T_MFW_HDR *) win)->data;
+	T_MMI_BT_PIN_Req_Data * pin_req_data = (T_MMI_BT_PIN_Req_Data *)win_data->user;
+	T_MMI_BT_Dev_Name_Data* dev_name_data = (T_MMI_BT_Dev_Name_Data *)win_data->user;
+	T_MMI_BtSearchData *srch_data = (T_MMI_BtSearchData *)win_data->user;
+	UBYTE			* editor_buffer = NULL;
+	SHORT			max_edit_size = 0;
+	T_MFW_HND		editor_win;
+	T_MFW_HND		parent;
+	MFW_BT_TRACE("mmi_bluetooth_editor_cb()");
+	if ((identifier == BT_DEV_NAME_EDITOR) ||
+	     (identifier == BT_REM_DEV_NAME_EDITOR))	/* CQ21843 */
+	{
+		editor_buffer = dev_name_data->bt_device_name;
+		max_edit_size = MFW_BT_NAME_LENGTH;
+		editor_win = dev_name_data->bt_dev_name_editor;
+		parent = dev_name_data->win;
+	}
+	else if (identifier == BT_PIN_REQ_EDITOR)
+	{
+		editor_buffer = pin_req_data->bt_pin_req_buf;
+		max_edit_size = MFW_BT_MAX_PIN_CODE_LEN;
+		editor_win = pin_req_data->bt_pin_req_editor;
+		parent = pin_req_data->win;
+	}
+	else if (identifier == BT_PAIRING_EDITOR)
+	{
+		editor_buffer = srch_data->bt_pairing_pin_buf;
+		max_edit_size = MFW_BT_MAX_PIN_CODE_LEN;
+		editor_win = srch_data->srch_bt_pairing_pin_editor;
+		parent = srch_data->win;
+	}
+	else
+	{
+		MFW_BT_TRACE_P1("mmi_bluetooth_editor_cb() : Unknown Identifier %d", identifier);
+		/*
+		** if this isn't one of the "recognised" editors leave now!
+		*/
+		return;
+	}
+	switch (reason)
+	{
+		case INFO_KCD_LEFT:
+		{
+			/*
+			** Construct the required string
+			*/
+			/*
+			** The Editor Attributes for all Bluetooth Editors require ASCII text. Text should not be Unicode
+			**
+			if (editor_buffer[0] == 0x80 )		// If Unicode (there is no way it should be though!!)
+			{	//If empty string, remove 0x80 at beginning
+				if (editor_buffer[2]==0x00 &&  editor_buffer[3] == 0x00)
+					memset(editor_buffer, 0, max_edit_size);
+			}
+			*/
+			/*
+			** If there is no string entered, treat this as if it was a "Cancel"
+			*/
+			if (editor_buffer[0] == 0x00)
+			{
+				/*
+				** Send a "Cancel" to the Bluetooth window
+				*/
+				SEND_EVENT(parent, BT_EDITOR_CANCEL, identifier, NULL);
+			}
+			else
+			{
+				/*
+				** Send a "Select" to the Bluetooth window
+				*/
+				SEND_EVENT(parent, BT_EDITOR_SELECT, identifier, NULL);
+			}
+		}
+		break;
+		case INFO_KCD_RIGHT:
+			if (strlen((char *)editor_buffer) == 0)
+			{
+				/*
+				** Send a "Cancel" to the Bluetooth window
+				*/
+				SEND_EVENT(parent, BT_EDITOR_CANCEL, identifier, NULL);
+			}
+			break;
+		case INFO_KCD_HUP:
+			/*
+			** Set the buffer to NULLS
+			*/
+			memset(editor_buffer, 0x00, max_edit_size);
+			/*
+			** Send a "Cancel" to the Bluetooth window
+			*/
+			SEND_EVENT(parent, BT_EDITOR_CANCEL, identifier, NULL);
+			break;
+		default:
+			/* otherwise no action to be performed
+			*/
+			break;
+	}
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_search_cb
+$Description:		This function
+$Returns:		None
+$Arguments:
+*******************************************************************************/
+static int mmi_bluetooth_search_cb(T_MFW_EVENT evnt, void *para)
+{
+	MFW_BT_TRACE_P1("mmi_bluetooth_search_cb() : event received %d", evnt);
+	switch (evnt)
+	{
+		case E_BT_DM_AUTH_CMPL:
+			if (bt_srch_data.srch_bt_req_resp == BT_PAIRED_NOT_RESP)
+				SEND_EVENT(bt_srch_data.win, BT_AUTH_COMPLETE, 0, (void *)para);
+			else
+				return MFW_EVENT_REJECTED;
+			break;
+		case E_BT_DM_INQ_CMPL:
+			SEND_EVENT(bt_srch_data.win, BT_INQUIRY_COMPLETE, 0, (void *)para);
+			break;
+		case E_BT_DM_DISC_RES:
+			SEND_EVENT(bt_srch_data.win, BT_DISCOVER_RESULT, 0, (void *)para);
+			break;
+		case E_BT_DM_DISC_CMPL:
+			SEND_EVENT(bt_srch_data.win, BT_DISCOVER_COMPLETE, 0, (void *)para);
+			break;
+		default:
+			return MFW_EVENT_REJECTED;
+	}
+	return MFW_EVENT_CONSUMED;
+}
+/*******************************************************************************
+$Function:		mmi_bluetooth_root_cb
+$Description:		This function
+$Returns:		None
+$Arguments:
+*******************************************************************************/
+static int mmi_bluetooth_root_cb(T_MFW_EVENT evnt, void* para)
+{
+	T_MFW_BT_STATUS btRetVal;
+	T_MMI_BtData *data = &bt_data;
+	T_MFW_HND win = mfw_parent(mfw_header());
+	MFW_BT_TRACE_P1("mmi_bluetooth_root_cb() : event received %d", evnt);
+	switch (evnt)
+	{
+		case E_BT_ENABLE_CMPL:
+			if (((T_MFW_BT_ENABLE_CMPL *)para)->Success == FALSE)
+			{
+				/*
+				** Ensure Flag is Disabled
+				*/
+				data->bt_isActive = FALSE;
+				/*
+				** Turn the Bluetooth Icon Off ... Not Done because there is no documentation re icons!!!!!
+				**                                             and there is not the time to figure them out from Raw Code!!
+				*/
+				/*
+				** Create a timed dialog to display the Message "Bluetooth Failed"
+				*/
+				mmi_bluetooth_show_info(0, TxtBluetooth, TxtFailed);
+			}
+			else
+			{
+				/*
+				** Set Flag to Enabled
+				*/
+				data->bt_isActive = TRUE;
+				/*
+				** Turn the Bluetooth Icon On ... Not Done because there is no documentation re icons!!!!!
+				**                                             and there is not the time to figure them out from Raw Code!!
+				*/
+				/*
+				** Create a timed dialog to display the Message "Bluetooth Activated"
+				*/
+				mmi_bluetooth_show_info(0, TxtBluetooth, TxtActivated);
+			}
+			break;
+		case E_BT_DISABLE_CMPL:
+			/*
+			** Set Flag to Enabled
+			*/
+			data->bt_isActive = FALSE;
+			/*
+			** Turn the Bluetooth Icon Off ... Not Done because there is no documentation re icons!!!!!
+			**                                             and there is not the time to figure them out from Raw Code!!
+			*/
+			/*
+			** Create a timed dialog to display the Message "Bluetooth DeActivated"
+			*/
+			mmi_bluetooth_show_info(0, TxtBluetooth, TxtDeActivated);
+			break;
+		case E_BT_DM_DEV_NAME_REQ:
+			if (data->bt_dev_name_win == (void *)0)
+			{
+				data->bt_DevNameForStartup = TRUE;
+				data->bt_dev_name_win = mmi_bt_dev_name_create(win);
+				if (data->bt_dev_name_win != (void *)0)
+				{
+					SEND_EVENT(data->bt_dev_name_win, BT_DEV_NAME_REQ, 0, (void *)para);
+				}
+				else
+				{
+					MFW_BT_TRACE("mmi_bluetooth_root_cb() : Unable to create Device Name Win!");
+					btRetVal = mfw_bt_dm_set_local_name((void *)0);
+					if (btRetVal != MFW_BT_SUCCESS)
+					{
+						MFW_BT_TRACE("mmi_bluetooth_root_cb() : Unable to return Device Name to Mfw!");
+					}
+				}
+			}
+			else
+			{
+				MFW_BT_TRACE("mmi_bluetooth_root_cb() : Device Name Win already active");
+			}
+			break;
+		case E_BT_DM_LINK_UP:
+			if (data->bt_num_active_connections < MFW_BT_MAX_CONSEC_CONNECTIONS)
+				data->bt_num_active_connections++;
+			else
+			{
+				MFW_BT_TRACE("mmi_bluetooth_root_cb() : LINK_UP indicated after Max Consecutive connections reached");
+			}
+			break;
+		case E_BT_DM_LINK_DOWN:
+			if (data->bt_num_active_connections >= 1)
+				data->bt_num_active_connections--;
+			else
+			{
+				MFW_BT_TRACE("mmi_bluetooth_root_cb() : LINK_DOWN indicated when no active connections!");
+			}
+			break;
+		case E_BT_DM_PIN_REQ:
+			if (data->bt_pin_req_win  == (void *)0)
+			{
+				data->bt_pin_req_win = mmi_bt_pin_request_create(win);
+				if (data->bt_pin_req_win != (void *)0)
+				{
+					SEND_EVENT(data->bt_pin_req_win, BT_PIN_REQ, 0, (void *)para);
+				}
+				else
+				{
+					MFW_BT_TRACE("mmi_bluetooth_root_cb() : Unable to create PIN Req Win!");
+					btRetVal = mfw_bt_dm_pin_code((UINT8 *)0, (UINT8)0);
+					if (btRetVal != MFW_BT_SUCCESS)
+					{
+						MFW_BT_TRACE("mmi_bluetooth_root_cb() : Unable to return PIN to Mfw!");
+					}
+				}
+			}
+			else
+			{
+				MFW_BT_TRACE("mmi_bluetooth_root_cb() : PIN Req Win already active");
+				btRetVal = mfw_bt_dm_pin_code((UINT8 *)0, (UINT8)0);
+				if (btRetVal != MFW_BT_SUCCESS)
+				{
+					MFW_BT_TRACE("mmi_bluetooth_root_cb() : Unable to return PIN to Mfw!");
+				}
+			}
+			break;
+		case E_BT_DM_AUTH_CMPL:
+			if (data->bt_pin_req_win != (void *)0)
+			{
+				SEND_EVENT(data->bt_pin_req_win, BT_AUTH_COMPLETE, 0, (void *)para);
+			}
+			else
+			{
+				MFW_BT_TRACE("mmi_bluetooth_root_cb() : PIN Req Win inactive!");
+			}
+			break;
+		case E_BT_DM_AUTHORIZE_REQ:
+			if (data->bt_authorize_win == (void *)0)
+			{
+				data->bt_authorize_win = mmi_bt_authorize_create(win);
+				if (data->bt_authorize_win != (void *)0)
+				{
+					SEND_EVENT(data->bt_authorize_win, BT_AUTHORIZE_REQ, 0, (void *)para);
+				}
+				else
+				{
+					MFW_BT_TRACE("mmi_bluetooth_root_cb() : Unable to create Authorization Req Win!");
+					btRetVal = mfw_bt_dm_authorize_resp(MFW_BT_AUTH_FAIL);
+					if (btRetVal != MFW_BT_SUCCESS)
+					{
+						MFW_BT_TRACE("mmi_bluetooth_root_cb() : Unable to return Authorization to Mfw!");
+					}
+				}
+			}
+			else
+			{
+				MFW_BT_TRACE("mmi_bluetooth_root_cb() : Authorization IReq Win already active");
+				btRetVal = mfw_bt_dm_authorize_resp(MFW_BT_AUTH_FAIL);
+				if (btRetVal != MFW_BT_SUCCESS)
+				{
+					MFW_BT_TRACE("mmi_bluetooth_root_cb() : Unable to return Authorization to Mfw!");
+				}
+			}
+			break;
+		case E_BT_DM_SIG_STRENGTH_IND:
+			break;
+		case E_BT_DM_INQ_RES:
+		case E_BT_DM_INQ_CMPL:
+		case E_BT_DM_DISC_RES:
+		case E_BT_DM_DISC_CMPL:
+		default:
+			MFW_BT_TRACE("mmi_bluetooth_root_cb() : Unexpected Event!!");
+	}
+	return MFW_EVENT_CONSUMED;
+}
+static int mmi_bluetooth_search_timer_cb(MfwEvt e, MfwTim *t)
+{
+	T_MMI_BtSearchData *data = &bt_srch_data;
+	MFW_BT_TRACE("mmi_bluetooth_search_timer_cb()");
+	if (data->srch_bt_please_wait_dialog != (void *)0)
+	{
+		SEND_EVENT(data->srch_bt_please_wait_dialog, DIALOG_DESTROY, 0, 0);
+		data->srch_bt_please_wait_dialog = (void *)0;
+	}
+	/*
+	** Display "No Devices Found" and exit the Search Window
+	*/
+	mmi_bluetooth_show_info_callback(data->win, TxtBtNoDevices, TxtBtFound, mmi_bt_srch_no_device_found_dlg_cb);
+	data->srch_bt_mode = BT_MODE_NO_SEARCH;
+}
+static int mmi_bluetooth_discovery_timer_cb(MfwEvt e, MfwTim *t)
+{
+	T_MMI_BtData *data = &bt_data;
+	T_MFW_BT_STATUS btRetVal;
+	MFW_BT_TRACE("mmi_bluetooth_discovery_timer_cb()");
+	/*
+	** Make the Device Not Discoverable, (Device Hiddenm but from Temporary Request)
+	*/
+	btRetVal = mfw_bt_dm_set_visibility(FALSE, TRUE);
+	if (btRetVal != MFW_BT_SUCCESS)
+	{
+		MFW_BT_TRACE_P1("mmi_bluetooth_discovery_timer_cb() : Set Visibility (FALSE) failed with status : %d", btRetVal);
+	}
+	else
+	{
+		/*
+		** Create a timed dialog to display the Message "Device Hidden"
+		*/
+		mmi_bluetooth_show_info(0, TxtBtDevice, TxtBtHidden);
+	}
+	if (data->bt_stopBtOnDiscoverableTimeout != FALSE)
+	{
+	/*
+	** If there are currently active connections, start the connection timer, otherwise turn bluetooth off
+	*/
+	if (data->bt_num_active_connections >= 1)
+	{
+		timStart(data->bt_connection_timer);
+	}
+	else if (data->bt_isActive != FALSE)
+	{
+		/*
+		** Disable the Bluetooth module
+		*/
+		mfw_bt_disable();
+		}
+	}
+}
+static int mmi_bluetooth_connection_timer_cb(MfwEvt e, MfwTim *t)
+{
+	T_MMI_BtData *data = &bt_data;
+	MFW_BT_TRACE("mmi_bluetooth_connection_timer_cb()");
+	/*
+	** If there are currently active connections, start the connection timer, otherwise turn bluetooth off
+	*/
+	if (data->bt_num_active_connections >= 1)
+	{
+		timStart(data->bt_connection_timer);
+	}
+	else if (data->bt_isActive != FALSE)
+	{
+		/*
+		** Disable the Bluetooth module
+		*/
+		mfw_bt_disable();
+	}
+}
+static void mmi_bluetooth_dlg_cb(void)
+{
+	MFW_BT_TRACE("mmi_bluetooth_dlg_cb()");
+	return;
+}
+static void mmi_bt_srch_no_device_found_dlg_cb(void)
+{
+	MFW_BT_TRACE("mmi_bt_srch_no_device_found_dlg_cb()");
+	mmi_bt_search_destroy();
+	return;
+}
+static MfwHnd mmi_bluetooth_show_please_wait(T_MFW_HND parent)
+{
+	T_DISPLAY_DATA display_info;
+	MFW_BT_TRACE("mmi_bluetooth_show_please_wait()");
+	/*
+	** Create a timed dialog to display the Message "Failed"
+	*/
+	dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, TxtPleaseWait, TxtNull, COLOUR_STATUS);
+	dlg_initDisplayData_events( &display_info, mmi_bluetooth_dlg_cb, FOREVER, 0);
+	return info_dialog(parent, &display_info);
+}
+static MfwHnd mmi_bluetooth_show_info_callback(T_MFW_HND parent, int str1, int str2, T_VOID_FUNC callback)
+{
+	T_DISPLAY_DATA display_info;
+	MFW_BT_TRACE("mmi_bluetooth_show_info()");
+	/*
+	** Create a timed dialog to display the Message "Failed"
+	*/
+	dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, str1, str2, COLOUR_STATUS);
+	dlg_initDisplayData_events( &display_info, callback, BT_INFO_SCRN_TIMEOUT, KEY_LEFT | KEY_CLEAR | KEY_HUP);
+	return info_dialog(parent, &display_info);
+}
+static MfwHnd mmi_bluetooth_show_info(T_MFW_HND parent, int str1, int str2)
+{
+	return mmi_bluetooth_show_info_callback(parent, str1, str2, mmi_bluetooth_dlg_cb);
+}
+T_MFW_HND bt_menu_start(MfwHnd parent, MfwMnuAttr* menuAttr, T_VOID_FUNC cancel_cb)
+{
+	T_MFW_HND win;
+		T_MFW_WIN     *win_data;
+		T_bt_menu *data;
+	MFW_BT_TRACE("bt_menu_start()");
+	win = bt_menu_create (parent);
+	if (win NEQ NULL)
+	{
+		win_data = ((T_MFW_HDR *)win)->data;
+		data = (T_bt_menu *)win_data->user;
+		data->cancel_cb = cancel_cb;
+		SEND_EVENT (win, BT_MNU_INIT, 0, (MfwMnuAttr*) menuAttr);
+	}
+	return win;
+}
+static T_MFW_HND bt_menu_create(MfwHnd parent)
+{
+	T_MFW_WIN     * win_data;
+	T_bt_menu *  data = (T_bt_menu *)mfwAlloc(sizeof (T_bt_menu));
+	MFW_BT_TRACE ("bt_menu_create()");
+	data->win = win_create (parent, 0, E_WIN_VISIBLE, (T_MFW_CB)bt_menu_win_cb);
+	if (data->win EQ 0)
+	return 0;
+	/*
+	* Create window handler
+	*/
+	data->mmi_control.dialog   = (T_DIALOG_FUNC)bt_menu;
+	data->mmi_control.data     = data;
+	win_data                   = ((T_MFW_HDR *)data->win)->data;
+	win_data->user             = (void *)data;
+	/*
+	** Create the keyboard Handler
+	*/
+	data->kbd = kbdCreate(data->win,KEY_ALL,(MfwCb)bt_menu_kbd_cb);
+	data->kbd_long = kbdCreate(data->win,KEY_ALL|KEY_LONG,(MfwCb)bt_menu_kbd_long_cb);
+	/*
+	* return window handle
+	*/
+	return data->win;
+}
+static void bt_menu_destroy(MfwHnd window)
+{
+	T_MFW_WIN     * win_data  = ((T_MFW_HDR *)window)->data;
+	T_bt_menu * data = (T_bt_menu *)win_data->user;
+	MfwHnd auth_win = bt_data.bt_authorize_win;
+	T_MFW_WIN		* auth_win_data = ((T_MFW_HDR *) auth_win)->data;
+	T_MMI_BT_Authorise_Data * auth_data = (T_MMI_BT_Authorise_Data *)auth_win_data->user;
+	MFW_BT_TRACE ("bt_menu_destroy()");
+	if (window == NULL)
+	{
+		MFW_BT_TRACE ("Error : Called with NULL Pointer");
+		return;
+	}
+	if (data)
+	{
+		auth_data->bt_auth_menu = 0;
+		winDelete (data->win);
+		/*
+		** Free Memory
+		*/
+		mfwFree((void *)data, sizeof (T_bt_menu));
+	}
+}
+static void bt_menu (T_MFW_HND win, USHORT event, SHORT value, void * parameter)
+{
+	T_MFW_WIN      * win_data = ((T_MFW_HDR *) win)->data;
+	T_bt_menu      * data = (T_bt_menu *)win_data->user;
+	MFW_BT_TRACE ("bt_menu()");
+	switch (event)
+	{
+		case BT_MNU_INIT:
+			data->menu = mnuCreate(data->win, (MfwMnuAttr*)parameter, E_MNU_ESCAPE, (MfwCb)bt_menu_mnu_cb);
+			mnuLang(data->menu, mainMmiLng);
+			mnuUnhide(data->menu);
+			winShow(data->win);
+			break;
+		default:
+			return;
+	}
+}
+static int bt_menu_mnu_cb (MfwEvt e, MfwMnu *m)
+{
+	T_MFW_HND	win  = mfwParent(mfw_header());
+	MfwHnd auth_win = bt_data.bt_authorize_win;
+	T_MFW_WIN		* win_data = ((T_MFW_HDR *) auth_win)->data;
+	T_MMI_BT_Authorise_Data * data = (T_MMI_BT_Authorise_Data *)win_data->user;
+	MFW_BT_TRACE ("bt_menu_mnu_cb()");
+	switch (e)
+	{
+		case E_MNU_ESCAPE:
+			bt_menu_destroy(win);
+			data->bt_auth_menu = 0;
+			break;
+		default:
+			return 0;
+	}
+	return 1;
+}
+static int bt_menu_win_cb (MfwEvt e, MfwWin *w)
+{
+	T_bt_menu * data = (T_bt_menu *)w->user;
+	MfwMnu * mnu;
+	MFW_BT_TRACE ("bt_menu_win_cb()");
+	switch (e)
+	{
+		case MfwWinVisible:
+			mnu = (MfwMnu *)mfwControl(data->menu);
+			softKeys_displayId(TxtSoftSelect, TxtSoftBack, 0, mnu->curAttr->mnuColour );
+			break;
+		default:
+			return 0;
+	}
+	return 1;
+}
+static int bt_menu_kbd_cb (MfwEvt e, MfwKbd *k)
+{
+	T_MFW_HND	win  = mfwParent(mfw_header());
+	T_MFW_WIN	*win_data = ((T_MFW_HDR *)win)->data;
+	T_bt_menu	*data = (T_bt_menu *)win_data->user;
+	T_VOID_FUNC cancel_cb;
+	MFW_BT_TRACE ("bt_menu_kbd_cb()");
+	switch (k->code)
+	{
+		case KCD_MNUUP:
+			mnuUp(data->menu);
+			winShow(win);
+			break;
+		case KCD_MNUDOWN:
+			mnuDown(data->menu);
+			winShow(win);
+			break;
+		case KCD_LEFT:
+			mnuSelect(data->menu);
+			{
+				MfwMnu *mnu;
+				mnu = (MfwMnu *) mfwControl( data->menu );
+				if (mnu != NULL)
+				{
+					if (mnu->curAttr != NULL)
+						softKeys_displayId( TxtSoftSelect, TxtSoftBack, 0, mnu->curAttr->mnuColour);
+				}
+			}
+			break;
+		case KCD_RIGHT:
+		case KCD_HUP:
+			cancel_cb = data->cancel_cb;
+			mnuEscape(data->menu);
+			cancel_cb();
+			break;
+		default:
+			return MFW_EVENT_CONSUMED;
+	}
+	return MFW_EVENT_CONSUMED;
+}
+static int bt_menu_kbd_long_cb (MfwEvt e, MfwKbd *k)
+{
+	T_MFW_HND       win  = mfwParent(mfw_header());
+	T_MFW_WIN     * win_data = ((T_MFW_HDR *)win)->data;
+	T_bt_menu * data = (T_bt_menu *)win_data->user;
+	MFW_BT_TRACE ("bt_menu_kbd_long_cb()");
+	if ((e & KEY_CLEAR) && (e & KEY_LONG))
+	{
+		mnuEscape(data->menu);
+		return MFW_EVENT_CONSUMED;
+	}
+	return  MFW_EVENT_CONSUMED;
+}
+static void mmi_bt_authorize_editor_cb(T_MFW_HND win, USHORT identifier, SHORT reason)
+{
+	MfwHnd auth_win = bt_data.bt_authorize_win;
+	T_MFW_WIN		* win_data = ((T_MFW_HDR *) auth_win)->data;
+	T_MMI_BT_Authorise_Data * data = (T_MMI_BT_Authorise_Data *)win_data->user;
+	MFW_BT_TRACE("bt_auth_editor_cb()");
+	switch (reason)
+	{
+		case INFO_KCD_RIGHT:
+		case INFO_KCD_HUP:
+			/*
+			** CQ22021 : The Editor is destroyed automatically, reset the win value to NULL
+			*/
+			 data->bt_auth_info_editor = (void *)0;
+			/*
+			** Free the dynamically allocated memory
+			*/
+			mfwFree(data->bt_auth_info_text, data->bt_auth_info_text_size);
+			break;
+		default:
+			/* otherwise no action to be performed
+			*/
+			break;
+	}
+	return;
+}
+static int mmi_bt_authorize_display_info(MfwMnu* m, MfwMnuItem* i)
+{
+	T_MFW_HND	auth_win = bt_data.bt_authorize_win;
+	T_MFW_WIN   * win_data = ((T_MFW_HDR *) auth_win)->data;
+	T_MMI_BT_Authorise_Data * data = (T_MMI_BT_Authorise_Data *)win_data->user;
+	USHORT			reqBufSize = 0;
+	USHORT			serviceTxtId = TxtNotSupported;
+#ifdef NEW_EDITOR
+	T_AUI_EDITOR_DATA	editor_data;
+#endif
+	MFW_BT_TRACE("mmi_bt_authorize_display_info()");
+	/*
+	** Get the Text Id to be used to represent the service
+	*/
+	switch(data->bt_auth_req_param->service)
+	{
+		case BTA_SPP_SERVICE_ID:
+			serviceTxtId = TxtBtSerialPort;
+			break;
+		case BTA_DUN_SERVICE_ID:
+			serviceTxtId = TxtBtDialUpNetworking;
+			break;
+		case BTA_FAX_SERVICE_ID:
+			serviceTxtId = TxtFax;
+			break;
+		case BTA_HSP_SERVICE_ID:
+			serviceTxtId = TxtBtHeadSet;
+			break;
+		case BTA_HFP_SERVICE_ID:
+			serviceTxtId = TxtBtHandsFree;
+			break;
+		case BTA_OP_SERVICE_ID:
+			serviceTxtId = TxtBtObjectPush;
+			break;
+		case BTA_FT_SERVICE_ID:
+			serviceTxtId = TxtBtFileTransfer;
+			break;
+	}
+	/*
+	** Calculate the size of Buffer required this will give a little extra ... not not much.
+	*/
+	reqBufSize = BT_MAX_DISPLAY_DEV_NAME_LENGTH; // The max length of the dev name was ensured when the event was received
+	reqBufSize += strlen(MmiRsrcGetText(TxtBtRequiresAuthorizationForService));
+	reqBufSize += strlen(MmiRsrcGetText(serviceTxtId));
+	reqBufSize += 6; // Added for CR/Lf to ensure enough space
+	/*
+	** Allocate enough memory for the display text
+	*/
+	data->bt_auth_info_text = mfwAlloc(reqBufSize);
+	if (data->bt_auth_info_text == 0)
+	{
+		/*
+		** Display an error dialog and return
+		*/
+		mmi_bluetooth_show_info(data->win, TxtFailed, TxtErrorOutOfMem);
+		return MFW_EVENT_CONSUMED;
+	}
+	data->bt_auth_info_text_size = reqBufSize;
+	sprintf((char *)data->bt_auth_info_text, MmiRsrcGetText(TxtBtRequiresAuthorizationForService),
+		     (char *)data->bt_auth_req_param->bd_name,
+		     (char *)MmiRsrcGetText(serviceTxtId));
+#ifdef NEW_EDITOR
+	/*
+	** Initialise the editor
+	*/
+	AUI_edit_SetDefault(&editor_data);
+	AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, data->bt_auth_info_text, data->bt_auth_info_text_size);
+	AUI_edit_SetTextStr(&editor_data, TxtNull, TxtSoftBack, TxtBtInfo, TxtNull);
+	AUI_edit_SetMode(&editor_data, ED_MODE_READONLY, ED_CURSOR_NONE);
+	AUI_edit_SetEvents(&editor_data, 0, TRUE, FOREVER, mmi_bt_authorize_editor_cb);
+	data->bt_auth_info_editor = AUI_edit_Start(data->win, &editor_data);
+#endif
+	return MFW_EVENT_CONSUMED;
+}
+static int mmi_bt_authorize_once(MfwMnu* m, MfwMnuItem* i)
+{
+	MfwHnd auth_win = bt_data.bt_authorize_win;
+	T_MFW_WIN		* win_data = ((T_MFW_HDR *) auth_win)->data;
+	T_MMI_BT_Authorise_Data * data = (T_MMI_BT_Authorise_Data *)win_data->user;
+	T_MFW_BT_STATUS	btRetVal;
+	MFW_BT_TRACE("mmi_bt_authorize_once()");
+	/*
+	** Send the appropriate response to Bluetooth
+	*/
+	btRetVal = mfw_bt_dm_authorize_resp(MFW_BT_AUTH_ONCE);
+	/*
+	** Destroy the Menu
+	*/
+	if (data->bt_auth_menu != 0)
+		bt_menu_destroy(data->bt_auth_menu);
+	/*
+	** Free the Allocated Memory
+	*/
+	mfwFree((U8 *)data->bt_auth_req_param, (U16)sizeof(T_MFW_BT_DM_AUTHORIZE_REQ));
+	data->bt_auth_req_param = (void *)0;
+	/*
+	** Destroy the Authorization Window
+	*/
+	mmi_bt_authorize_destroy(data->win);
+	return MFW_EVENT_CONSUMED;
+}
+static int mmi_bt_authorize_always(MfwMnu* m, MfwMnuItem* i)
+{
+	MfwHnd auth_win = bt_data.bt_authorize_win;
+	T_MFW_WIN		* win_data = ((T_MFW_HDR *) auth_win)->data;
+	T_MMI_BT_Authorise_Data * data = (T_MMI_BT_Authorise_Data *)win_data->user;
+	T_MFW_BT_STATUS	btRetVal;
+	MFW_BT_TRACE("bt_authorize_always()");
+	/*
+	** Send the appropriate response to Bluetooth
+	*/
+	btRetVal = mfw_bt_dm_authorize_resp(MFW_BT_AUTH_ALWAYS);
+	/*
+	** Destroy the Menu
+	*/
+	if (data->bt_auth_menu != 0)
+		bt_menu_destroy(data->bt_auth_menu);
+	/*
+	** Free the Allocated Memory
+	*/
+	mfwFree((U8 *)data->bt_auth_req_param, (U16)sizeof(T_MFW_BT_DM_AUTHORIZE_REQ));
+	data->bt_auth_req_param = (void *)0;
+	/*
+	** Destroy the Authorization Window
+	*/
+	mmi_bt_authorize_destroy(data->win);
+	return MFW_EVENT_CONSUMED;
+}
+static int mmi_bt_dont_authorize(MfwMnu* m, MfwMnuItem* i)
+{
+	MfwHnd auth_win = bt_data.bt_authorize_win;
+	T_MFW_WIN		* win_data = ((T_MFW_HDR *) auth_win)->data;
+	T_MMI_BT_Authorise_Data * data = (T_MMI_BT_Authorise_Data *)win_data->user;
+	T_MFW_BT_STATUS	btRetVal;
+	MFW_BT_TRACE("mmi_bt_dont_authorize()");
+	/*
+	** Send the appropriate response to Bluetooth
+	*/
+	btRetVal = mfw_bt_dm_authorize_resp(MFW_BT_AUTH_FAIL);
+	/*
+	** Destroy the Menu
+	*/
+	if (data->bt_auth_menu != 0)
+		bt_menu_destroy(data->bt_auth_menu);
+	/*
+	** Free the Allocated Memory
+	*/
+	mfwFree((U8*)data->bt_auth_req_param, (U16)sizeof(T_MFW_BT_DM_AUTHORIZE_REQ));
+	data->bt_auth_req_param = (void *)0;
+	/*
+	** Destroy the Authorization Window
+	*/
+	mmi_bt_authorize_destroy(data->win);
+	return MFW_EVENT_CONSUMED;
+}
+static void mmi_bt_authorize_rsk(void)
+{
+	MfwHnd auth_win = bt_data.bt_authorize_win;
+	T_MFW_WIN		* win_data = ((T_MFW_HDR *) auth_win)->data;
+	T_MMI_BT_Authorise_Data * data = (T_MMI_BT_Authorise_Data *)win_data->user;
+	T_MFW_BT_STATUS	btRetVal;
+	MFW_BT_TRACE("bt_authorize_rsk()");
+	/*
+	** Send the appropriate response to Bluetooth
+	*/
+	btRetVal = mfw_bt_dm_authorize_resp(MFW_BT_AUTH_FAIL);
+	/*
+	** Destroy the Menu
+	*/
+	if (data->bt_auth_menu != 0)
+		bt_menu_destroy(data->bt_auth_menu);
+	/*
+	** Menu will be destroyed automatically by Right Softkey Press
+	** Free the Allocated Memory
+	*/
+	mfwFree((U8 *)data->bt_auth_req_param, (U16)sizeof(T_MFW_BT_DM_AUTHORIZE_REQ));
+	data->bt_auth_req_param = (void *)0;
+	/*
+	** Destroy the Authorization Window
+	*/
+	mmi_bt_authorize_destroy(data->win);
+	return;
+}
+static int bt_srch_dev_pair (MfwMnu * mnu, MfwMnuItem * item)
+{
+	MFW_BT_TRACE("bt_srch_dev_pair()");
+	SEND_EVENT(bt_srch_data.win, BT_PAIR_DEVICE, 0, 0);
+	return MFW_EVENT_CONSUMED;
+}
+static int bt_srch_dev_show_services (MfwMnu * mnu, MfwMnuItem * item)
+{
+	MFW_BT_TRACE("bt_srch_dev_show_services()");
+	SEND_EVENT(bt_srch_data.win, BT_SHOW_DEV_SERVICES, 0, 0);
+	return MFW_EVENT_CONSUMED;
+}
+/*
+**	CQ21843 : Menu Action function
+*/
+static int bt_srch_dev_set_name (MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_BT_STATUS btRetVal;
+	T_MMI_BtData *data = &bt_data;
+	T_MFW_BT_REM_DEVICE_INFO *cur_device;
+	MfwHnd win = mfw_parent(mfw_header());
+	MFW_BT_TRACE("bt_srch_dev_set_name()");
+	cur_device = &bt_srch_data.srch_bt_dev_list[bt_srch_data.srch_bt_cur_dev_idx];
+	if (data->bt_dev_name_win == (void *)0)
+	{
+		data->bt_DevNameForStartup = FALSE;
+		data->bt_dev_name_win = mmi_bt_dev_name_create(win);
+		if (data->bt_dev_name_win != (void *)0)
+		{
+			SEND_EVENT(data->bt_dev_name_win, BT_SET_REM_DEV_NAME, 0, (void *)cur_device);
+		}
+		else
+		{
+			MFW_BT_TRACE("bt_srch_dev_set_name() : Unable to create Device Name Win!");
+		}
+	}
+	else
+	{
+		MFW_BT_TRACE("bt_srch_dev_set_name() : Device Name Win already active");
+	}
+	return MFW_EVENT_CONSUMED;
+}
+static int bt_srch_dev_add_known (MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_BT_STATUS btRetVal;
+	T_MFW_BT_REM_DEVICE_INFO *cur_device;
+	cur_device = &bt_srch_data.srch_bt_dev_list[bt_srch_data.srch_bt_cur_dev_idx];
+	MFW_BT_TRACE_P7("bt_srch_dev_add_known(), Idx %d, BD_ADDR 0x%02x%02x%02x%02x%02x%02x",
+					     bt_srch_data.srch_bt_cur_dev_idx,
+					     cur_device->bd_addr[0],
+					     cur_device->bd_addr[1],
+					     cur_device->bd_addr[2],
+					     cur_device->bd_addr[3],
+					     cur_device->bd_addr[4],
+					     cur_device->bd_addr[5]);
+	/*
+	** CQ21834 : Ensure that the is_new value is set before writing the data to Flash, so that it will be
+	**			set correctly when  the handset is restarted.
+	*/
+	cur_device->is_new = FALSE;
+	btRetVal = mfw_bt_dm_add_device(cur_device->bd_addr);
+	if (btRetVal != MFW_BT_SUCCESS)
+	{
+		/*
+		** CQ21834 : Failed to write the data to Flash, continue to treat the device as unknown.
+		*/
+		cur_device->is_new = TRUE;
+		MFW_BT_TRACE_P1("mfw_bt_dm_add_device returned error : %d", btRetVal);
+		mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+	}
+	else
+	{
+		winShow(mfw_parent(mfw_header()));
+	}
+	return MFW_EVENT_CONSUMED;
+}
+static int bt_srch_dev_rem_known (MfwMnu * mnu, MfwMnuItem * item)
+{
+	T_MFW_BT_STATUS btRetVal;
+	T_MFW_BT_REM_DEVICE_INFO *cur_device;
+	MFW_BT_TRACE("bt_srch_dev_rem_known()");
+	cur_device = &bt_srch_data.srch_bt_dev_list[bt_srch_data.srch_bt_cur_dev_idx];
+	btRetVal = mfw_bt_dm_delete_device(cur_device->bd_addr);
+	if (btRetVal != MFW_BT_SUCCESS)
+	{
+		MFW_BT_TRACE_P1("mfw_bt_dm_delete_device returned error : %d", btRetVal);
+		mmi_bluetooth_show_info(0, TxtFailed, TxtNull);
+	}
+	else
+	{
+		cur_device->is_new = TRUE;
+		cur_device->link_key_present = FALSE;
+		winShow(mfw_parent(mfw_header()));
+	}
+	return MFW_EVENT_CONSUMED;
+}
+static void bt_srch_dev_list_searching_cb(T_MFW_HND Parent, ListMenuData * ListData)
+{
+	T_MFW_WIN			*win_data	= ((T_MFW_HDR *)Parent)->data;
+	T_MMI_BtSearchData	*data		= (T_MMI_BtSearchData *)win_data->user;
+	MfwMnuItem			*ptr_tempListItem;
+	T_MFW_BT_REM_DEVICE_INFO	*ptr_tempDevDb;
+	int iLoop;						/* CQ21841 : Loop identifier used while resetting the List labels */
+	MFW_BT_TRACE("bt_srch_dev_list_searching_cb()");
+	if ((ListData->Reason EQ LISTS_REASON_BACK) ||
+	     (ListData->Reason EQ LISTS_REASON_CLEAR) ||
+	     (ListData->Reason EQ LISTS_REASON_HANGUP))
+	{
+		/*
+		** Change the mode of the list
+		*/
+		data->srch_bt_mode = BT_MODE_LIST_COMPLETE;
+		/*
+		** Stop the Search Now ... even if there are more entries waiting in the buffer, they will be ignored.
+		*/
+		mfw_bt_dm_cancel_search();
+		/*
+		** Destroy the window and recreate it
+		*/
+		listsDestroy(ListData->win);
+		/*
+		** Allocate memory to copy the devices already listed, copy the active data,
+		** and free the memory set aside for ALL the devices to be listed.
+		*/
+		ptr_tempListItem = (MfwMnuItem *)mfwAlloc(data->srch_bt_device_count * sizeof(MfwMnuItem));
+		if (ptr_tempListItem != (MfwMnuItem *)0)
+		{
+			/*
+			** Copy the list of items
+			*/
+			memcpy(ptr_tempListItem, data->srch_bt_list_devices_menu_data.List, (data->srch_bt_device_count * sizeof(MfwMnuItem)));
+			/*
+			** Free the first (and larger) list
+			*/
+			mfwFree((U8 *)data->srch_bt_list_devices_menu_data.List, (U16)(data->srch_bt_num_devices * sizeof(MfwMnuItem)));
+			data->srch_bt_list_devices_menu_data.List = ptr_tempListItem;
+		}
+		/*
+		** Repeat for the 'Device List'
+		*/
+		ptr_tempDevDb = (T_MFW_BT_REM_DEVICE_INFO *)mfwAlloc(data->srch_bt_device_count * sizeof(T_MFW_BT_REM_DEVICE_INFO));
+		if (ptr_tempDevDb!= (T_MFW_BT_REM_DEVICE_INFO *)0)
+		{
+			/*
+			** Copy the list of devices
+			*/
+			memcpy(ptr_tempDevDb, data->srch_bt_dev_list, (data->srch_bt_device_count * sizeof(T_MFW_BT_REM_DEVICE_INFO)));
+			/*
+			** Free the first (and larger) list
+			*/
+			mfwFree((U8 *)data->srch_bt_dev_list, (U16)(data->srch_bt_num_devices * sizeof(T_MFW_BT_REM_DEVICE_INFO)));
+			data->srch_bt_dev_list = ptr_tempDevDb;
+		}
+		/*
+		** Configure some other List parameters
+		*/
+		data->srch_bt_num_devices = data->srch_bt_device_count;
+		data->srch_bt_list_devices_menu_data.ListLength = data->srch_bt_device_count;
+		data->srch_bt_list_devices_menu_data.Attr->nItems = data->srch_bt_device_count;
+		data->srch_bt_list_devices_menu_data.Attr->hdrId = TxtBtDevices;
+		data->srch_bt_list_devices_menu_data.LeftSoftKey = TxtSoftOptions;
+		data->srch_bt_list_devices_menu_data.RightSoftKey = TxtSoftBack;
+		/*
+		** CQ21842 : Modify the List Key Events so that it handles all teh keys it requires.
+		*/
+		data->srch_bt_list_devices_menu_data.KeyEvents      = KEY_CLEAR | KEY_RIGHT | KEY_LEFT | KEY_MNUUP | KEY_MNUDOWN |KEY_HUP;
+		data->srch_bt_list_devices_menu_data.autoDestroy = TRUE;
+		data->srch_bt_dev_list_cb = (ListCbFunc)bt_srch_dev_list_listmnu_cb;
+		/*
+		** CQ21841 : For each device in the list, reset the string pointer because it will be pointing to the old device
+		** list which has just been freed
+		*/
+		for (iLoop = 0; iLoop < data->srch_bt_num_devices; iLoop++)
+			data->srch_bt_list_devices_menu_data.List[iLoop].str = data->srch_bt_dev_list[iLoop].name;
+		/*
+		** Recreate the menu with the new details;
+		*/
+		if (listDisplayListMenu(data->win, &data->srch_bt_list_devices_menu_data, data->srch_bt_dev_list_cb, FALSE) != LISTS_FAIL)
+			data->srch_bt_dev_list_win = data->srch_bt_list_devices_menu_data.win;
+	}
+	return;
+}
+static void bt_srch_dev_list_listmnu_cb(T_MFW_HND Parent, ListMenuData * ListData)
+{
+	T_MFW_WIN			*win_data	= ((T_MFW_HDR *)Parent)->data;
+	//T_MMI_BtSearchData	*data		= (T_MMI_BtSearchData *)win_data->user;
+	T_MMI_BtSearchData	*data		= &bt_srch_data;
+	MfwMnuItem			*ptr_tempListItem;
+	T_MFW_BT_REM_DEVICE_INFO	*ptr_tempDevDb;
+	MFW_BT_TRACE_P1("bt_srch_dev_list_listmnu_cb(), with reason %d", ListData->Reason);
+	if ((ListData->Reason EQ LISTS_REASON_BACK) ||
+	     (ListData->Reason EQ LISTS_REASON_CLEAR) ||
+	     (ListData->Reason EQ LISTS_REASON_HANGUP))
+	{
+		/*
+		** Destroy the window --- Not sure if this is required! ... leave it out for now
+		*/
+		 listsDestroy(ListData->win);
+		/*
+		** Free the memory set aside for ALL the devices to be listed.
+		** CQ21834 : Use the "ListLength" value as this will also include the "No Devices" Entry for Known Devices.
+		*/
+		mfwFree((U8 *)data->srch_bt_list_devices_menu_data.List, (U16)(data->srch_bt_list_devices_menu_data.ListLength * sizeof(MfwMnuItem)));
+		data->srch_bt_list_devices_menu_data.List = (void *)0;
+		/*
+		** Repeat for the 'Device List'
+		*/
+		mfwFree((U8 *)data->srch_bt_dev_list, (U16)(data->srch_bt_num_devices * sizeof(T_MFW_BT_REM_DEVICE_INFO)));
+		data->srch_bt_dev_list = (void *)0;
+		/*
+		** Configure some other List parameters
+		*/
+		data->srch_bt_num_devices = 0;
+		data->srch_bt_device_count = 0;
+		data->srch_bt_list_devices_menu_data.ListLength = 0;
+		data->srch_bt_list_devices_menu_data.Attr->nItems = 0;
+		data->srch_bt_list_devices_menu_data.Attr->hdrId = 0;
+		data->srch_bt_list_devices_menu_data.LeftSoftKey = 0;
+		data->srch_bt_list_devices_menu_data.RightSoftKey = 0;
+		data->srch_bt_list_devices_menu_data.autoDestroy = TRUE;
+		data->srch_bt_dev_list_cb = (ListCbFunc)0;
+		data->srch_bt_dev_list_win = 0;
+		data->srch_bt_mode = BT_MODE_NO_SEARCH;
+		/*
+		** Destroy the "Bt Search Window" and return to the underlying Menu
+		*/
+		SEND_EVENT(data->win, BT_DISABLE_SEARCH, 0, 0);
+	}
+	return;
+}
+static void bt_srch_service_list_listmnu_cb(T_MFW_HND Parent, ListMenuData * ListData)
+{
+	T_MFW_WIN			*win_data	= ((T_MFW_HDR *)Parent)->data;
+	T_MMI_BtSearchData	*data		= (T_MMI_BtSearchData *)win_data->user;
+	MfwMnuItem			*ptr_tempListItem;
+	T_MFW_BT_REM_DEVICE_INFO	*ptr_tempDevDb;
+	MFW_BT_TRACE("bt_srch_service_list_listmnu_cb()");
+	if ((ListData->Reason EQ LISTS_REASON_BACK) ||
+	     (ListData->Reason EQ LISTS_REASON_CLEAR) ||
+	     (ListData->Reason EQ LISTS_REASON_HANGUP))
+	{
+		/*
+		** Destroy the window --- Not sure if this is required! ... leave it out for now
+		*/
+		listsDestroy(ListData->win);
+		/*
+		** Free the memory set aside for ALL the devices to be listed.
+		*/
+		mfwFree((U8 *)data->srch_bt_show_services_menu_data.List, (U16)(data->srch_bt_show_services_menu_data.ListLength * sizeof(MfwMnuItem)));
+		data->srch_bt_show_services_menu_data.List = (void *)0;
+		/*
+		** Configure some other List parameters
+		*/
+		data->srch_bt_show_services_menu_data.ListLength = 0;
+		data->srch_bt_show_services_menu_data.Attr->nItems = 0;
+		data->srch_bt_show_services_menu_data.Attr->hdrId = 0;
+		data->srch_bt_show_services_menu_data.LeftSoftKey = 0;
+		data->srch_bt_show_services_menu_data.RightSoftKey = 0;
+		data->srch_bt_show_services_menu_data.autoDestroy = TRUE;
+		data->srch_bt_show_services_win = 0;
+	}
+	return;
+}
+static int bt_count_dev_services(T_MFW_BT_SERVICE_MASK services, T_MFW_BT_SERVICE_MASK *srv_mask_arry)
+{
+	ULONG	chk_serv = 2;
+	int		iLoop;
+	int		iCount = 0;
+	MFW_BT_TRACE_P1("bt_count_dev_services() : services 0x%08lx", services);
+	for (iLoop = BTA_RES_SERVICE_ID + 1; iLoop < BTA_MAX_SERVICE_ID ; iLoop++)
+	{
+		MFW_BT_TRACE_P4("bt_count_dev_services > Idx %d, Count %d, Services 0x%08lx, chk_srv 0x%08lx",
+							iLoop, iCount, services, chk_serv);
+			if ((services & chk_serv) != 0)
+			{
+				MFW_BT_TRACE_P2("bt_count_dev_services > Idx %d, Service 0x%08lx", iCount, chk_serv);
+				srv_mask_arry[iCount] = chk_serv;
+				iCount++;
+			}
+			chk_serv *= 2;
+	}
+	MFW_BT_TRACE_P1("bt_count_dev_services > Number of Services Found : %d" , iCount);
+	return iCount;
+}
+static int bt_get_TxtId_for_service(T_MFW_BT_SERVICE_MASK service)
+{
+	int TxtId;
+	MFW_BT_TRACE("bt_get_TxtId_for_service()");
+	switch (service)
+	{
+		case BTA_SPP_SERVICE_MASK:
+			TxtId = TxtBtSerialPort;
+			break;
+		case BTA_DUN_SERVICE_MASK:
+			TxtId = TxtBtDialUpNetworking;
+			break;
+		case BTA_FAX_SERVICE_MASK:
+			TxtId = TxtFax;
+			break;
+		case BTA_LAP_SERVICE_MASK:
+			TxtId = TxtBtLanAccess;
+			break;
+		case BTA_HSP_SERVICE_MASK:
+			TxtId = TxtBtHeadSet;
+			break;
+		case BTA_HFP_SERVICE_MASK:
+			TxtId = TxtBtHandsFree;
+			break;
+		case BTA_OP_SERVICE_MASK:
+			TxtId = TxtBtObjectPush;
+			break;
+		case BTA_FT_SERVICE_MASK:
+			TxtId = TxtBtFileTransfer;
+			break;
+		case BTA_CT_SERVICE_MASK:
+			TxtId = TxtBtCordlessTelephony;
+			break;
+		case BTA_IC_SERVICE_MASK:
+			TxtId = TxtBtIntercom;
+			break;
+		default:
+			TxtId = TxtBtUnknownService;
+	}
+	return TxtId;
+}

FreeCalypso > hg > fc-magnetite

comparison src/aci2/bmi/mmiBluetooth.c @ 3:93999a60b835