开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
bt_con.cpp
资源名称：Maui_META_src_v5.0808.0.zip　[点击查看]
上传用户：gelin96
上传日期：2017-01-08
资源大小：20993k
文件大小：66k
源码类别：

MTK

开发平台：

C++ Builder

bt_con.cpp：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2001
  8. *
  9. *****************************************************************************/
  11. /*****************************************************************************
  12.  *
  13.  * Filename:
  14.  * ---------
  15.  *   bt_con.cpp
  16.  *
  17.  * Project:
  18.  * --------
  19.  *   Maui META APP
  20.  *
  21.  * Description:
  22.  * ------------
  23.  *   BT connection test source
  24.  *
  25.  * Author:
  26.  * -------
  27.  *  Andy Ueng (mtk00490)
  28.  *
  29.  *============================================================================
  30.  *             HISTORY
  31.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  32.  *------------------------------------------------------------------------------
  33.  * $Revision$
  34.  * $Modtime$
  35.  * $Log$
  36.  *
  37.  *------------------------------------------------------------------------------
  38.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  39.  *============================================================================
  40.  ****************************************************************************/
  41. //===========================================================================
  42. #include<iostream>
  44. #include <fstream>
  46. #pragma hdrstop
  48. // BT
  49. #ifndef  _BT_HCI_COMMON_H_
  50. #include "bt_hci_common.h"
  51. #endif
  53. #ifndef  _BT_CON_H_
  54. #include "bt_con.h"
  55. #endif
  57. // man
  58. #ifndef  _MAN_TIMER_H_
  59. #include "man_timer.h"
  60. #endif
  62. #ifndef  _MAN_ACTIVE_H_
  63. #include "man_active.h"
  64. #endif
  67. // misc
  68. #ifndef  _FT_UTILS_H_
  69. #include "ft_utils.h"
  70. #endif
  72. // message
  73. #ifndef _META_LAB_MSG_H_
  74. #include "meta_lab_msg.h"
  75. #endif
  78. //==============================================================================
  79. static CBTCT* gs_bt_ct_ptr;
  80. static bool g_bIsRunning = false;
  82. //==============================================================================
  83. static void REQ_Stop(void)
  84. {   gs_bt_ct_ptr->REQ_Stop();
  85. }
  87. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  88. static void  REQ_SendResetHCICommand( void )
  89. {   gs_bt_ct_ptr->REQ_SendResetHCICommand();
  90. }
  92. //---------------------------------------------------------------------------
  93. static void __stdcall CNF_ResetHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  94. {   gs_bt_ct_ptr->CNF_ResetHCIEvent( cnf, token, usrData );
  95. }
  97. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  98. static void  REQ_Send_Read_Local_BDAdrress_HCI_command( void )
  99. {   gs_bt_ct_ptr->REQ_Send_Read_Local_BDAdrress_HCI_command();
  100. }
  102. //-----------------------------------------------------------------------------
  103. static void __stdcall CNF_ReadLocalBDAddressHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  104. {   gs_bt_ct_ptr->CNF_ReadLocalBDAddressHCIEvent( cnf, token, usrData );
  105. }
  107. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  108. static void  REQ_Send_Write_Local_BDAdrress_HCI_command( void )
  109. {   gs_bt_ct_ptr->REQ_Send_Write_Local_BDAdrress_HCI_command();
  110. }
  112. //---------------------------------------------------------------------------
  113. static void __stdcall CNF_WriteLocalBDAddressHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  114. {   gs_bt_ct_ptr->CNF_WriteLocalBDAddressHCIEvent( cnf, token, usrData );
  115. }
  117. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  118. static void  REQ_Send_Scan_HCI_command( void )
  119. {   gs_bt_ct_ptr->REQ_Send_Scan_HCI_command();
  120. }
  122. //---------------------------------------------------------------------------
  123. static void __stdcall CNF_ScanHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  124. {   gs_bt_ct_ptr->CNF_ScanHCIEvent( cnf, token, usrData );
  125. }
  127. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  128. static void REQ_Send_Inquiry_Scan_Interval_HCI_command(void)
  129. {
  130.     gs_bt_ct_ptr->REQ_Send_Inquiry_Scan_Interval_HCI_command();
  131. }
  133. //---------------------------------------------------------------------------
  134. static void __stdcall CNF_InquiryScanIntervalHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  135. {
  136.     gs_bt_ct_ptr->CNF_InquiryScanIntervalHCIEvent(cnf, token, usrData);
  137. }
  139. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  140. static void REQ_Send_Page_Scan_Interval_HCI_command(void)
  141. {
  142.     gs_bt_ct_ptr->REQ_Send_Page_Scan_Interval_HCI_command();
  143. }
  145. //---------------------------------------------------------------------------
  146. static void __stdcall CNF_PageScanIntervalHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  147. {
  148.     gs_bt_ct_ptr->CNF_PageScanIntervalHCIEvent(cnf, token, usrData);
  149. }
  151. static void  REQ_Send_Auto_Accept_HCI_command( void )
  152. {   gs_bt_ct_ptr->REQ_Send_Auto_Accept_HCI_command();
  153. }
  155. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  156. static void  REQ_Send_Inquiry_HCI_command( void )
  157. {   gs_bt_ct_ptr->REQ_Send_Inquiry_HCI_command();
  158. }
  160. //---------------------------------------------------------------------------
  161. static void __stdcall CNF_InquiryHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  162. {   gs_bt_ct_ptr->CNF_InquiryHCIEvent( cnf, token, usrData );
  163. }
  165. //---------------------------------------------------------------------------
  166. static void  REQ_Send_Inquiry_Cancel_HCI_command( void )
  167. {   gs_bt_ct_ptr->REQ_Send_Inquiry_Cancel_HCI_command();
  168. }
  170. //---------------------------------------------------------------------------
  171. static void __stdcall CNF_InquiryCancelHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  172. {   gs_bt_ct_ptr->CNF_InquiryCancelHCIEvent( cnf, token, usrData );
  173. }
  174. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  175. static void  REQ_Send_ConnectACL_HCI_command( void )
  176. {   gs_bt_ct_ptr->REQ_Send_ConnectACL_HCI_command();
  177. }
  179. //---------------------------------------------------------------------------
  180. static void __stdcall CNF_ConnectACLHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  181. {   gs_bt_ct_ptr->CNF_ConnectACLHCIEvent( cnf, token, usrData );
  182. }
  184. //---------------------------------------------------------------------------
  185. static void __stdcall CNF_DisconnectACLAutoHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  186. {   gs_bt_ct_ptr->CNF_DisconnectACLAutoHCIEvent( cnf, token, usrData );
  187. }
  188. //---------------------------------------------------------------------------
  189. static void __stdcall CNF_LinkKeyNegReplyHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  190. {   gs_bt_ct_ptr->CNF_LinkKeyNegReplyHCIEvent( cnf, token, usrData );
  191. }
  193. //---------------------------------------------------------------------------
  194. static void  REQ_Send_DisconnectACL_HCI_command( void )
  195. {   gs_bt_ct_ptr->REQ_Send_DisconnectACL_HCI_command();
  196. }
  198. //---------------------------------------------------------------------------
  199. static void __stdcall CNF_DisconnectACLHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  200. {   gs_bt_ct_ptr->CNF_DisconnectACLHCIEvent( cnf, token, usrData );
  201. }
  203. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  204. static void  REQ_Send_Change_ACL_Packet_Type_HCI_command( void )
  205. {   gs_bt_ct_ptr->REQ_Send_Change_ACL_Packet_Type_HCI_command();
  206. }
  208. //---------------------------------------------------------------------------
  209. static void __stdcall CNF_ChangeACLPacketTypeHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  210. {   gs_bt_ct_ptr->CNF_ChangeACLPacketTypeHCIEvent( cnf, token, usrData );
  211. }
  213. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  214. static void  REQ_Send_EnterPIN_HCI_command( void )
  215. {   gs_bt_ct_ptr->REQ_Send_EnterPIN_HCI_command();
  216. }
  218. //---------------------------------------------------------------------------
  219. static void __stdcall CNF_EnterPINHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  220. {   gs_bt_ct_ptr->CNF_EnterPINHCIEvent( cnf, token, usrData );
  221. }
  223. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  224. static void  REQ_Send_ConnectSCO_HCI_command( void )
  225. {   gs_bt_ct_ptr->REQ_Send_ConnectSCO_HCI_command();
  226. }
  228. //---------------------------------------------------------------------------
  229. static void __stdcall CNF_ConnectSCOHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  230. {   gs_bt_ct_ptr->CNF_ConnectSCOHCIEvent( cnf, token, usrData );
  231. }
  233. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  234. static void  REQ_Send_DisconnectSCO_HCI_command( void )
  235. {   gs_bt_ct_ptr->REQ_Send_DisconnectSCO_HCI_command();
  236. }
  238. //---------------------------------------------------------------------------
  239. static void __stdcall CNF_DisconnectSCOHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  240. {   gs_bt_ct_ptr->CNF_DisconnectSCOHCIEvent( cnf, token, usrData );
  241. }
  242. //===========================================================================
  243. CBTCT::CBTCT( void )
  244. {
  245.     g_bIsRunning = false;
  246.     ConfirmCallback = 0;
  247.     AllocateVector();
  248. }
  250. //---------------------------------------------------------------------------
  251. CBTCT::~CBTCT( void )
  252. {
  253.     g_bIsRunning = false;
  254.     ConfirmCallback = 0;
  255.     DeAllocateVector();
  256. }
  258. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  259. void CBTCT::AllocateVector( void )
  260. {
  261.     if( NULL == m_pvCTRes )
  262.         m_pvCTRes     = new vector<S_BT_CT_RES>;
  264. }
  266. //---------------------------------------------------------------------------
  267. void CBTCT::DeAllocateVector( void )
  268. {
  269.     if( NULL != m_pvCTRes )
  270.     {
  271.         if( ! m_pvCTRes->empty() )
  272.         {
  273.             m_pvCTRes->erase( m_pvCTRes->begin(), m_pvCTRes->end() );
  274.         }
  275.         delete m_pvCTRes;
  276.         m_pvCTRes = NULL;
  277.     }
  278. }
  280. //---------------------------------------------------------------------------
  281. void  CBTCT::EraseVector( void )
  282. {
  283.     if( ! m_pvCTRes->empty() )
  284.     {   m_pvCTRes->erase( m_pvCTRes->begin(), m_pvCTRes->end() );
  285.     }
  286. }
  288. //---------------------------------------------------------------------------
  289. //---------------------------------------------------------------------------
  290. void  CBTCT::REQ_Stop( void )
  291. {
  292.     if (!g_bIsRunning)
  293.     {
  294.         return;
  295.     }
  296.     
  297.     Confirm( METAAPP_STOP );
  298. }
  300. //---------------------------------------------------------------------------
  301. void  CBTCT::Confirm(E_METAAPP_RESULT_T confirm_state)
  302. {
  303.     if (!g_bIsRunning)
  304.     {
  305.         return;
  306.     }
  307.     g_bIsRunning = false;
  309.     if (NULL == ConfirmCallback)
  310.     {
  311.         return;
  312.     }    
  313.     m_eConfirmState = confirm_state;
  314.     ActiveMan->SetActiveFunction( ConfirmCallback );
  315. }
  319. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  320. void  CBTCT::Reset_HCI_Command( BT_HCI_COMMAND &hci_cmd )
  321. {
  322.     for( int i=0; i<(sizeof(hci_cmd.m_cmd)/sizeof(hci_cmd.m_cmd[0])); i++ )
  323.     {
  324.         hci_cmd.m_cmd[i] = 0;
  325.     }
  326. }
  331. //==========================================================================
  332. void  CBTCT::REQ_Stop_Start( void )
  333. {
  334.     gs_bt_ct_ptr  = this;
  335.     g_bIsRunning  = true;
  337.     META_CancelAllBlockingCall_r( m_META_HANDLE_Obj.Get_MainHandle() );
  338.     ActiveMan->SetActiveFunction( ::REQ_Stop );
  339.    
  340. }
  342. //==========================================================================
  343. void  CBTCT::REQ_Reset_Start( S_BT_CT bt_ct )
  344. {
  345.     gs_bt_ct_ptr  = this;
  346.     g_bIsRunning  = true;
  348.     m_sBTCT = bt_ct;
  349.     EraseVector();
  350.     ActiveMan->SetActiveFunction( ::REQ_SendResetHCICommand );
  352. }
  354. //---------------------------------------------------------------
  355. void CBTCT::REQ_SendResetHCICommand( void )
  356. {
  357.     if(!g_bIsRunning)  return;
  359.     BT_HCI_COMMAND hci_cmd;
  360.     Compose_Reset_HCI_Command( hci_cmd );
  362.     AddTxLogToStringList( hci_cmd );
  363.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_ResetHCIEvent, NULL, HCE_COMMAND_COMPLETE);
  365.     if (!m_bEventOk)
  366.     {
  367.         Confirm( METAAPP_FAIL );
  368.         return;
  369.     }
  371.     if (META_SUCCESS != MetaResult)
  372.     {
  373.         if( META_TIMEOUT == MetaResult )
  374.         {
  375.             Confirm( METAAPP_TIMEOUT );
  376.             return;
  377.         }
  378.         else if( META_CANCEL == MetaResult )
  379.         {
  380.             Confirm( METAAPP_CANCEL );
  381.             return;
  382.         }
  383.         else
  384.         {
  385.             Confirm( METAAPP_FAIL );
  386.             return;
  387.         }
  388.     }
  390.     Confirm(METAAPP_SUCCESS);
  391. }
  393. //---------------------------------------------------------------------------
  394. void __stdcall CBTCT::CNF_ResetHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  395. {
  396.     // 0E,04,01,03,0C,00
  397.     if (!g_bIsRunning)
  398.     {
  399.         return;
  400.     }
  401.     
  402.     AddRxLogToStringList(*cnf);
  404.     if ((cnf->m_len      != 0x04) ||
  405.         (cnf->m_parms[0] != 0x01) ||
  406.         (cnf->m_parms[1] != 0x03) ||
  407.         (cnf->m_parms[2] != 0x0C) ||
  408.         (cnf->m_parms[3] != 0x00)
  409.       )
  410.     {
  411.         m_bEventOk = false;
  412.     }
  413.     else
  414.     {
  415.         m_bEventOk = true;
  416.     }
  417. }
  419. //---------------------------------------------------------------------------
  420. void CBTCT::Compose_Reset_HCI_Command( BT_HCI_COMMAND &hci_cmd )
  421. {
  422.     hci_cmd.m_opcode = 0x0C03;
  423.     hci_cmd.m_len    = 0x00;
  425. }
  427. //===========================================================================
  428. //////////////////////////// Read local BD address //////////////////////////
  429. //===========================================================================
  430. void  CBTCT::REQ_ReadLocalBDAddress_Start( S_BT_CT bt_ct )
  431. {
  432.     gs_bt_ct_ptr  = this;
  433.     g_bIsRunning  = true;
  435.     m_sBTCT = bt_ct;
  436.     ActiveMan->SetActiveFunction( ::REQ_Send_Read_Local_BDAdrress_HCI_command );
  437. }
  439. //---------------------------------------------------------------------------
  440. void  CBTCT::REQ_Send_Read_Local_BDAdrress_HCI_command( void )
  441. {
  442.     if(!g_bIsRunning)  return;
  444.     m_bEventOk = false;
  445.     BT_HCI_COMMAND hci_cmd;
  447.     Compose_Read_Local_BD_Addr_HCI_Command( hci_cmd );
  448.     AddTxLogToStringList( hci_cmd );
  449.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_ReadLocalBDAddressHCIEvent, NULL, HCE_COMMAND_COMPLETE );
  451.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  452.     {
  454.         if( META_TIMEOUT == MetaResult )
  455.         {
  456.             Confirm( METAAPP_TIMEOUT );
  457.             return;
  458.         }
  459.         else if( META_CANCEL == MetaResult )
  460.         {
  461.             Confirm( METAAPP_CANCEL );
  462.             return;
  463.         }
  464.         else
  465.         {
  466.             Confirm( METAAPP_FAIL );
  467.             return;
  468.         }
  469.     }
  471.     Confirm(METAAPP_SUCCESS);
  472. }
  474. //---------------------------------------------------------------------------
  475. void __stdcall CBTCT::CNF_ReadLocalBDAddressHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  476. {
  477.     if(!g_bIsRunning)  return;
  478.     if( 0xFF == cnf->m_event )  return; // LMP
  480.     AddRxLogToStringList( *cnf );
  481.     m_bEventOk = DeCompose_Read_Local_BD_Addr_HCI_Event( *cnf, m_sLocalBdAddr );
  483. }
  485. //--------------------------------------------------------------------------
  486. void  CBTCT::Compose_Read_Local_BD_Addr_HCI_Command( BT_HCI_COMMAND &hci_cmd )
  487. {
  488.     hci_cmd.m_opcode = 0x1009;
  489.     hci_cmd.m_len    = 0;
  490.     Reset_HCI_Command( hci_cmd );
  492. }
  494. //--------------------------------------------------------------------------
  495. bool  CBTCT::DeCompose_Read_Local_BD_Addr_HCI_Event( BT_HCI_EVENT hci_event, S_BD_ADDRS &s_bd_addrs )
  496. {
  498.     if(
  499.         0x09 != hci_event.m_parms[1] ||
  500.         0x10 != hci_event.m_parms[2] ||
  501.         0x00 != hci_event.m_parms[3]
  502.        )
  503.      {  return false;
  504.      }
  506.      S_BD_ADDR bd_addr;
  507.      for( int i=0; i<BD_ADDRESS_LEN; i++ )
  508.         bd_addr.uc_BD_Addr[i] = hci_event.m_parms[4+i];
  510.     s_bd_addrs.us_NAP = (bd_addr.uc_BD_Addr[5] << 8) | bd_addr.uc_BD_Addr[4];
  511.     s_bd_addrs.uc_UAP = bd_addr.uc_BD_Addr[3];
  512.     s_bd_addrs.ui_LAP = (bd_addr.uc_BD_Addr[2] << 16) | (bd_addr.uc_BD_Addr[1] << 8) | bd_addr.uc_BD_Addr[0];
  513.     return true;
  514. }
  516. //===========================================================================
  517. ///////////////////////////  write local BD address  ////////////////////////
  518. //===========================================================================
  519. void  CBTCT::REQ_WriteLocalBDAddress_Start( S_BT_CT bt_ct )
  520. {
  521.     gs_bt_ct_ptr  = this;
  522.     g_bIsRunning  = true;
  524.     m_sBTCT = bt_ct;
  525.     ActiveMan->SetActiveFunction( ::REQ_Send_Write_Local_BDAdrress_HCI_command );
  526. }
  528. //---------------------------------------------------------------------------
  529. void  CBTCT::REQ_Send_Write_Local_BDAdrress_HCI_command( void )
  530. {
  531.     if(!g_bIsRunning)  return;
  533.     m_bEventOk = false;
  534.     BT_HCI_COMMAND hci_cmd;
  536.     Compose_Write_Local_BD_Addr_HCI_Command( hci_cmd, m_sLocalBdAddr );
  537.     AddTxLogToStringList( hci_cmd );
  538.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_WriteLocalBDAddressHCIEvent, NULL, HCE_COMMAND_COMPLETE );
  540.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  541.     {
  542.         if( META_TIMEOUT == MetaResult )
  543.         {
  544.             Confirm( METAAPP_TIMEOUT );
  545.             return;
  546.         }
  547.         else if( META_CANCEL == MetaResult )
  548.         {
  549.             Confirm( METAAPP_CANCEL );
  550.             return;
  551.         }
  552.         else
  553.         {
  554.             Confirm( METAAPP_FAIL );
  555.             return;
  556.         }
  557.     }
  559.     Confirm(METAAPP_SUCCESS);
  560. }
  562. //---------------------------------------------------------------------------
  563. void __stdcall CBTCT::CNF_WriteLocalBDAddressHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  564. {
  565.     if(!g_bIsRunning)  return;
  566.     if( 0xFF == cnf->m_event )  return; // LMP
  568.     AddRxLogToStringList( *cnf );
  569.     m_bEventOk = DeCompose_Write_Local_BD_Addr_HCI_Event( *cnf );
  571. }
  573. //--------------------------------------------------------------------------
  574. void  CBTCT::Compose_Write_Local_BD_Addr_HCI_Command( BT_HCI_COMMAND &hci_cmd, S_BD_ADDRS s_bd_addrs )
  575. {
  576.     hci_cmd.m_opcode = 0xFC1A;
  577.     hci_cmd.m_len    = 6;
  578.     Reset_HCI_Command( hci_cmd );
  579.     hci_cmd.m_cmd[0] = m_sLocalBdAddr.ui_LAP & 0x000000FF;
  580.     hci_cmd.m_cmd[1] = (m_sLocalBdAddr.ui_LAP & 0x0000FF00) >>  8;
  581.     hci_cmd.m_cmd[2] = (m_sLocalBdAddr.ui_LAP & 0x00FF0000) >> 16;
  582.     hci_cmd.m_cmd[3] =  m_sLocalBdAddr.uc_UAP;
  583.     hci_cmd.m_cmd[4] =  m_sLocalBdAddr.us_NAP & 0x00FF;
  584.     hci_cmd.m_cmd[5] = (m_sLocalBdAddr.us_NAP & 0xFF00) >> 8;
  585. }
  587. //--------------------------------------------------------------------------
  588. bool  CBTCT::DeCompose_Write_Local_BD_Addr_HCI_Event( BT_HCI_EVENT hci_event )
  589. {
  590.     if(
  591.         0x1A != hci_event.m_parms[1] ||
  592.         0xFC != hci_event.m_parms[2] ||
  593.         0x00 != hci_event.m_parms[3]
  594.        )
  595.      {  return false;
  596.      }
  598.     return true;
  599. }
  601. //===========================================================================
  602. ////////////////////////////       Scan            //////////////////////////
  603. //===========================================================================
  604. void  CBTCT::REQ_Scan_Start( S_BT_CT bt_ct )
  605. {
  606.     gs_bt_ct_ptr  = this;
  607.     g_bIsRunning  = true;
  609.     m_sBTCT = bt_ct;
  610.     ActiveMan->SetActiveFunction( ::REQ_Send_Scan_HCI_command );
  611. }
  613. //---------------------------------------------------------------------------
  614. void  CBTCT::REQ_Send_Scan_HCI_command( void )
  615. {
  616.     if(!g_bIsRunning)  return;
  618.     m_bEventOk = false;
  619.     BT_HCI_COMMAND hci_cmd;
  621.     // interlaced inquiry scan
  622.     Compose_Inquiry_Scan_Type_HCI_Command( hci_cmd, m_sScan );
  623.     AddTxLogToStringList( hci_cmd );
  624.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_ScanHCIEvent, NULL, HCE_COMMAND_COMPLETE );
  626.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  627.     {
  629.         if( META_TIMEOUT == MetaResult )
  630.         {
  631.             Confirm( METAAPP_TIMEOUT );
  632.             return;
  633.         }
  634.         else if( META_CANCEL == MetaResult )
  635.         {
  636.             Confirm( METAAPP_CANCEL );
  637.             return;
  638.         }
  639.         else
  640.         {
  641.             Confirm( METAAPP_FAIL );
  642.             return;
  643.         }
  644.     }
  646.     // interlaced page scan
  647.     Compose_Page_Scan_Type_HCI_Command( hci_cmd, m_sScan );
  648.     AddTxLogToStringList( hci_cmd );
  649.     MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_ScanHCIEvent, NULL, HCE_COMMAND_COMPLETE );
  651.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  652.     {
  654.         if( META_TIMEOUT == MetaResult )
  655.         {
  656.             Confirm( METAAPP_TIMEOUT );
  657.             return;
  658.         }
  659.         else if( META_CANCEL == MetaResult )
  660.         {
  661.             Confirm( METAAPP_CANCEL );
  662.             return;
  663.         }
  664.         else
  665.         {
  666.             Confirm( METAAPP_FAIL );
  667.             return;
  668.         }
  669.     }
  671.     //  scan type
  672.     Compose_Scan_Enable_HCI_Command( hci_cmd, m_sScan );
  673.     AddTxLogToStringList( hci_cmd );
  674.     MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_ScanHCIEvent, NULL, HCE_COMMAND_COMPLETE );
  676.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  677.     {
  679.         if( META_TIMEOUT == MetaResult )
  680.         {
  681.             Confirm( METAAPP_TIMEOUT );
  682.             return;
  683.         }
  684.         else if( META_CANCEL == MetaResult )
  685.         {
  686.             Confirm( METAAPP_CANCEL );
  687.             return;
  688.         }
  689.         else
  690.         {
  691.             Confirm( METAAPP_FAIL );
  692.             return;
  693.         }
  694.     }
  695.     Confirm(METAAPP_SUCCESS);
  696. }
  698. //---------------------------------------------------------------------------
  699. void __stdcall CBTCT::CNF_ScanHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  700. {
  701.     if(!g_bIsRunning)  return;
  702.     if( 0xFF == cnf->m_event )  return; // LMP
  704.     AddRxLogToStringList( *cnf );
  705.     m_bEventOk = DeCompose_Scan_HCI_Event( *cnf );
  707. }
  709. //--------------------------------------------------------------------------
  710. void  CBTCT::Compose_Inquiry_Scan_Type_HCI_Command( BT_HCI_COMMAND &hci_cmd, S_BT_SCAN scan )
  711. {
  712.     hci_cmd.m_opcode = 0x0C43;
  713.     hci_cmd.m_len    = 1;
  714.     Reset_HCI_Command( hci_cmd );
  715.     if( scan.b_interlaced_inquiry_scan )
  716.         hci_cmd.m_cmd[0] = 1;
  717.     else
  718.         hci_cmd.m_cmd[0] = 0;
  719. }
  721. //--------------------------------------------------------------------------
  722. void  CBTCT::Compose_Page_Scan_Type_HCI_Command( BT_HCI_COMMAND &hci_cmd, S_BT_SCAN scan )
  723. {
  724.     hci_cmd.m_opcode = 0x0C47;
  725.     hci_cmd.m_len    = 1;
  726.     Reset_HCI_Command( hci_cmd );
  727.     if( scan.b_interlaced_page_scan )
  728.         hci_cmd.m_cmd[0] = 1;
  729.     else
  730.         hci_cmd.m_cmd[0] = 0;
  731. }
  733. //--------------------------------------------------------------------------
  734. void  CBTCT::Compose_Scan_Enable_HCI_Command( BT_HCI_COMMAND &hci_cmd, S_BT_SCAN scan )
  735. {
  736.     hci_cmd.m_opcode = 0x0C1A;
  737.     hci_cmd.m_len    = 1;
  738.     Reset_HCI_Command( hci_cmd );
  739.     hci_cmd.m_cmd[0] = (unsigned char) scan.e_scan_type;
  740. }
  742. //--------------------------------------------------------------------------
  743. bool  CBTCT::DeCompose_Scan_HCI_Event( BT_HCI_EVENT hci_event )
  744. {
  746.     if(
  747.         0x00 != hci_event.m_parms[3]
  748.        )
  749.      {  return false;
  750.      }
  753.     return true;
  754. }
  756. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  757. void CBTCT::REQ_Set_Inquiry_Scan_Interval_Start(S_BT_CT bt_ct)
  758. {
  759.     gs_bt_ct_ptr  = this;
  760.     g_bIsRunning  = true;
  761.     m_sBTCT = bt_ct;
  763.     ActiveMan->SetActiveFunction(::REQ_Send_Inquiry_Scan_Interval_HCI_command);
  764. }
  766. //---------------------------------------------------------------------------
  767. void CBTCT::REQ_Send_Inquiry_Scan_Interval_HCI_command(void)
  768. {
  769.     if (!g_bIsRunning)
  770.     {
  771.         return;
  772.     }
  774.     m_bEventOk = false;
  775.     BT_HCI_COMMAND hci_cmd;
  777.     // interlaced inquiry scan
  778.     Compose_Inquiry_Scan_Interval_HCI_Command(hci_cmd);
  779.     AddTxLogToStringList(hci_cmd);
  780.     META_RESULT MetaResult = META_BT_SendHCICommand_r(m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_InquiryScanIntervalHCIEvent, NULL, HCE_COMMAND_COMPLETE);
  782.     if ((META_SUCCESS != MetaResult) || (!m_bEventOk))
  783.     {
  784.         if (META_TIMEOUT == MetaResult)
  785.         {
  786.             Confirm(METAAPP_TIMEOUT);
  787.             return;
  788.         }
  789.         else if (META_CANCEL == MetaResult)
  790.         {
  791.             Confirm(METAAPP_CANCEL);
  792.             return;
  793.         }
  794.         else
  795.         {
  796.             Confirm(METAAPP_FAIL);
  797.             return;
  798.         }
  799.     }
  800.     Confirm(METAAPP_SUCCESS);
  801. }
  803. //---------------------------------------------------------------------------
  804. void __stdcall CBTCT::CNF_InquiryScanIntervalHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  805. {
  806.     if (!g_bIsRunning)
  807.     {
  808.         return;
  809.     }
  811.     if (0xFF == cnf->m_event)
  812.     {
  813.         return; // LMP
  814.     }
  816.     AddRxLogToStringList(*cnf);
  817.     m_bEventOk = DeCompose_Inquiry_Scan_Interval_HCI_Event(*cnf);
  819. }
  821. //--------------------------------------------------------------------------
  822. void CBTCT::Compose_Inquiry_Scan_Interval_HCI_Command(BT_HCI_COMMAND &hci_cmd)
  823. {
  824.     hci_cmd.m_opcode = 0x0C1E;
  825.     hci_cmd.m_len    = 4;
  826.     Reset_HCI_Command(hci_cmd);
  827.     hci_cmd.m_cmd[0] = 0x64;
  828.     hci_cmd.m_cmd[1] = 0x00;
  829.     hci_cmd.m_cmd[2] = 0x11;
  830.     hci_cmd.m_cmd[3] = 0x00;
  831. }
  833. //--------------------------------------------------------------------------
  834. bool CBTCT::DeCompose_Inquiry_Scan_Interval_HCI_Event(BT_HCI_EVENT hci_event)
  835. {
  837.     if(
  838.         0x00 != hci_event.m_parms[3]
  839.        )
  840.      {  return false;
  841.      }
  844.     return true;
  845. }
  847. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  848. void CBTCT::REQ_Set_Page_Scan_Interval_Start(S_BT_CT bt_ct)
  849. {
  850.     gs_bt_ct_ptr  = this;
  851.     g_bIsRunning  = true;
  852.     m_sBTCT = bt_ct;
  853.     
  854.     ActiveMan->SetActiveFunction(::REQ_Send_Page_Scan_Interval_HCI_command);
  855. }
  857. //---------------------------------------------------------------------------
  858. void CBTCT::REQ_Send_Page_Scan_Interval_HCI_command(void)
  859. {
  860.     if (!g_bIsRunning)
  861.     {
  862.         return;
  863.     }
  865.     m_bEventOk = false;
  866.     BT_HCI_COMMAND hci_cmd;
  868.     // interlaced inquiry scan
  869.     Compose_Page_Scan_Interval_HCI_Command(hci_cmd);
  870.     AddTxLogToStringList(hci_cmd);
  871.     META_RESULT MetaResult = META_BT_SendHCICommand_r(m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_PageScanIntervalHCIEvent, NULL, HCE_COMMAND_COMPLETE);
  873.     if ((META_SUCCESS != MetaResult) || (!m_bEventOk))
  874.     {
  875.         if (META_TIMEOUT == MetaResult)
  876.         {
  877.             Confirm(METAAPP_TIMEOUT);
  878.             return;
  879.         }
  880.         else if (META_CANCEL == MetaResult)
  881.         {
  882.             Confirm(METAAPP_CANCEL);
  883.             return;
  884.         }
  885.         else
  886.         {
  887.             Confirm(METAAPP_FAIL);
  888.             return;
  889.         }
  890.     }
  891.     Confirm(METAAPP_SUCCESS);
  892. }
  894. //---------------------------------------------------------------------------
  895. void __stdcall CBTCT::CNF_PageScanIntervalHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  896. {
  897.     if (!g_bIsRunning)
  898.     {
  899.         return;
  900.     }
  902.     if (0xFF == cnf->m_event)
  903.     {
  904.         return; // LMP
  905.     }
  907.     AddRxLogToStringList(*cnf);
  908.     m_bEventOk = DeCompose_Page_Scan_Interval_HCI_Event(*cnf);
  910. }
  912. //--------------------------------------------------------------------------
  913. void CBTCT::Compose_Page_Scan_Interval_HCI_Command(BT_HCI_COMMAND &hci_cmd)
  914. {
  915.     hci_cmd.m_opcode = 0x0C1C;
  916.     hci_cmd.m_len    = 4;
  917.     Reset_HCI_Command(hci_cmd);
  918.     hci_cmd.m_cmd[0] = 0x64;
  919.     hci_cmd.m_cmd[1] = 0x00;
  920.     hci_cmd.m_cmd[2] = 0x11;
  921.     hci_cmd.m_cmd[3] = 0x00;
  922. }
  924. //--------------------------------------------------------------------------
  925. bool CBTCT::DeCompose_Page_Scan_Interval_HCI_Event(BT_HCI_EVENT hci_event)
  926. {
  928.     if(
  929.         0x00 != hci_event.m_parms[3]
  930.        )
  931.      {  return false;
  932.      }
  935.     return true;
  936. }
  938. //===========================================================================
  939. ////////////////////////////       auto accept     //////////////////////////
  940. //===========================================================================
  941. void  CBTCT::REQ_Auto_Accept_Start( S_BT_CT bt_ct )
  942. {
  943.     gs_bt_ct_ptr  = this;
  944.     g_bIsRunning  = true;
  946.     m_sBTCT = bt_ct;
  947.     ActiveMan->SetActiveFunction( ::REQ_Send_Auto_Accept_HCI_command );
  948. }
  950. //---------------------------------------------------------------------------
  951. void  CBTCT::REQ_Send_Auto_Accept_HCI_command( void )
  952. {
  953.     if(!g_bIsRunning)  return;
  955.     m_bEventOk = false;
  956.     BT_HCI_COMMAND hci_cmd;
  958.     // interlaced inquiry scan
  959.     Compose_Auto_Accept_HCI_Command( hci_cmd );
  960.     AddTxLogToStringList( hci_cmd );
  961.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_ScanHCIEvent, NULL, HCE_COMMAND_COMPLETE );
  963.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  964.     {
  966.         if( META_TIMEOUT == MetaResult )
  967.         {
  968.             Confirm( METAAPP_TIMEOUT );
  969.             return;
  970.         }
  971.         else if( META_CANCEL == MetaResult )
  972.         {
  973.             Confirm( METAAPP_CANCEL );
  974.             return;
  975.         }
  976.         else
  977.         {
  978.             Confirm( METAAPP_FAIL );
  979.             return;
  980.         }
  981.     }
  983.     Confirm(METAAPP_SUCCESS);
  984. }
  986. //---------------------------------------------------------------------------
  987. void __stdcall CBTCT::CNF_AutoAcceptHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  988. {
  989.     if(!g_bIsRunning)  return;
  990.     if( 0xFF == cnf->m_event )  return; // LMP
  992.     AddRxLogToStringList( *cnf );
  993.     m_bEventOk = DeCompose_Scan_HCI_Event( *cnf );
  995. }
  997. //--------------------------------------------------------------------------
  998. void  CBTCT::Compose_Auto_Accept_HCI_Command( BT_HCI_COMMAND &hci_cmd )
  999. {
  1000.     hci_cmd.m_opcode = 0x0C05;
  1001.     hci_cmd.m_len    = 3;
  1002.     Reset_HCI_Command( hci_cmd );
  1003.     hci_cmd.m_cmd[0] = 0x02;
  1004.     hci_cmd.m_cmd[1] = 0x00;
  1005.     hci_cmd.m_cmd[2] = 0x02;
  1006. }
  1009. //--------------------------------------------------------------------------
  1010. bool  CBTCT::DeCompose_Auto_Accept_HCI_Event( BT_HCI_EVENT hci_event )
  1011. {
  1013.     if(
  1014.         0x00 != hci_event.m_parms[3]
  1015.        )
  1016.      {  return false;
  1017.      }
  1020.     return true;
  1021. }
  1023. //===========================================================================
  1024. ///////////////////////////        Inquiry           ////////////////////////
  1025. //===========================================================================
  1026. void  CBTCT::REQ_Inquiry_Start( S_BT_CT bt_ct )
  1027. {
  1028.     gs_bt_ct_ptr  = this;
  1029.     g_bIsRunning  = true;
  1031.     m_sBTCT = bt_ct;
  1033.   //  EraseVector();
  1034.     ActiveMan->SetActiveFunction( ::REQ_Send_Inquiry_HCI_command );
  1035. }
  1037. //---------------------------------------------------------------------------
  1038. void  CBTCT::REQ_Send_Inquiry_HCI_command( void )
  1039. {
  1040.     if(!g_bIsRunning)  return;
  1042.     m_bEventOk = false;
  1043.     BT_HCI_COMMAND hci_cmd;
  1044.     m_uiEventCount = 0;
  1045.     Compose_Inquiry_HCI_Command( hci_cmd );
  1046.     AddTxLogToStringList( hci_cmd );
  1047.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), m_uiInquiryTimeout, &hci_cmd, ::CNF_InquiryHCIEvent, NULL, 0x01 );
  1049.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  1050.     {
  1051.         if( META_TIMEOUT == MetaResult )
  1052.         {
  1053.             Confirm( METAAPP_TIMEOUT );
  1054.             return;
  1055.         }
  1056.         else if( META_CANCEL == MetaResult )
  1057.         {
  1058.             Confirm( METAAPP_CANCEL );
  1059.             return;
  1060.         }
  1061.         else
  1062.         {
  1063.             Confirm( METAAPP_FAIL );
  1064.             return;
  1065.         }
  1066.     }
  1068.     Confirm(METAAPP_SUCCESS);
  1069. }
  1071. //---------------------------------------------------------------------------
  1072. void __stdcall CBTCT::CNF_InquiryHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  1073. {
  1074.     if(!g_bIsRunning)  return;
  1075.     if( 0xFF == cnf->m_event )  return; // LMP
  1076.     m_uiEventCount++;
  1078.     AddRxLogToStringList( *cnf );
  1080.     m_bEventOk = DeCompose_Inquiry_HCI_Event( *cnf );
  1082. }
  1084. //--------------------------------------------------------------------------
  1085. void  CBTCT::Compose_Inquiry_HCI_Command( BT_HCI_COMMAND &hci_cmd )
  1086. {
  1087.     // 33 8B 9E 30 0A
  1089.     hci_cmd.m_opcode = 0x0401;
  1090.     hci_cmd.m_len    = 5;
  1091.     Reset_HCI_Command( hci_cmd );
  1092.     hci_cmd.m_cmd[0] = 0x33;
  1093.     hci_cmd.m_cmd[1] = 0x8B;
  1094.     hci_cmd.m_cmd[2] = 0x9E;
  1095.     hci_cmd.m_cmd[3] = 0x30;
  1096.     hci_cmd.m_cmd[4] = 0x0A;
  1097.     
  1098. }
  1100. //--------------------------------------------------------------------------
  1101. bool  CBTCT::DeCompose_Inquiry_HCI_Event( BT_HCI_EVENT hci_event )
  1102. {
  1103.     if( 0x02 == hci_event.m_event )
  1104.     {
  1105.         int num_of_response = hci_event.m_parms[0];
  1106.         for( int i=0; i<num_of_response; i++ )
  1107.         {
  1108.             S_BT_CT_RES res;
  1109.             res.e_acl_status = BT_ACL_STATUS_NONE;
  1110.             for( int j=0; j<BD_ADDRESS_LEN; j++ )
  1111.             {
  1112.                 res.s_bd_addr.uc_BD_Addr[j] = hci_event.m_parms[i*14+j+1];
  1113.             }
  1115.             vector<S_BT_CT_RES>:: iterator iter;
  1116.             bool match = false;
  1117.             for( iter = m_pvCTRes->begin(); iter != m_pvCTRes->end(); iter++ )
  1118.             {
  1119.                 match = true;
  1120.                 for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1121.                 {
  1122.                     if( iter->s_bd_addr.uc_BD_Addr[i] != res.s_bd_addr.uc_BD_Addr[i] )
  1123.                     {
  1124.                         match = false;
  1125.                         break;
  1126.                     }
  1127.                 }
  1129.                 if( match )
  1130.                    break;
  1131.             }
  1133.             if( ! match )
  1134.             {
  1135.                 res.e_acl_status = BT_ACL_STATUS_NONE;
  1136.                 res.e_sco_status = BT_CT_SCO_STATUS_NONE;
  1137.                 res.uc_h1_acl    = 0xFF;
  1138.                 res.uc_h2_acl    = 0xFF;
  1139.                 res.uc_h1_sco    = 0xFF;
  1140.                 res.uc_h2_sco    = 0xFF;
  1141.                 m_pvCTRes->push_back( res );
  1143.                 char str[3];
  1144.                 AnsiString as_bd_addr;
  1145.                 for( int j=BD_ADDRESS_LEN-1; j>=0; j-- )
  1146.                 {
  1147.                     if( res.s_bd_addr.uc_BD_Addr[j] <= 0x0F )
  1148.                         sprintf( str, "0%X", res.s_bd_addr.uc_BD_Addr[j] );
  1149.                     else
  1150.                         sprintf( str, "%X", res.s_bd_addr.uc_BD_Addr[j] );
  1152.                     AnsiString as_str(str);
  1153.                     if( j!=0 ) as_str+= ":";
  1154.                         as_bd_addr+= as_str;
  1155.                 }
  1156.                 AddBDAddressToDiscovedList( as_bd_addr );
  1157.             }
  1158.         }
  1159.     }
  1161.     return true;
  1162. }
  1164. //---------------------------------------------------------------------------
  1165. void  CBTCT::AddBDAddressToDiscovedList( AnsiString as_bd_addr )
  1166. {
  1167.     m_sBTCT.list->Add( as_bd_addr );
  1168. }
  1170. //===========================================================================
  1171. ///////////////////////////        Inquiry Cancel          //////////////////
  1172. //===========================================================================
  1173. void  CBTCT::REQ_Inquiry_Cancel_Start( S_BT_CT bt_ct )
  1174. {
  1175.     gs_bt_ct_ptr  = this;
  1176.     g_bIsRunning  = true;
  1178.     m_sBTCT = bt_ct;
  1181.     //ActiveMan->SetActiveFunction2( ::REQ_Send_Inquiry_Cancel_HCI_command );
  1182.     ActiveMan->SetActiveFunction(::REQ_Send_Inquiry_Cancel_HCI_command);
  1183. }
  1185. //---------------------------------------------------------------------------
  1186. void  CBTCT::REQ_Send_Inquiry_Cancel_HCI_command( void )
  1187. {
  1188.     if(!g_bIsRunning)  return;
  1190.     m_bEventOk = false;
  1191.     BT_HCI_COMMAND hci_cmd;
  1193.     Compose_Inquiry_Cancel_HCI_Command( hci_cmd );
  1194.     AddTxLogToStringList( hci_cmd );
  1195.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 10000, &hci_cmd, ::CNF_InquiryCancelHCIEvent, NULL, HCE_COMMAND_COMPLETE );
  1197.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  1198.     {
  1199.         if( META_TIMEOUT == MetaResult )
  1200.         {
  1201.             Confirm( METAAPP_TIMEOUT );
  1202.             return;
  1203.         }
  1204.         else if( META_CANCEL == MetaResult )
  1205.         {
  1206.             Confirm( METAAPP_CANCEL );
  1207.             return;
  1208.         }
  1209.         else
  1210.         {
  1211.             Confirm( METAAPP_FAIL );
  1212.             return;
  1213.         }
  1214.     }
  1216.     //ActiveMan->SetActiveFunction2( ::REQ_Finish );
  1217.     Confirm(METAAPP_SUCCESS);
  1218. }
  1220. //---------------------------------------------------------------------------
  1221. void __stdcall CBTCT::CNF_InquiryCancelHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  1222. {
  1223.     if(!g_bIsRunning)  return;
  1224.     if( 0xFF == cnf->m_event )  return; // LMP
  1225.     m_uiEventCount++;
  1227.     AddRxLogToStringList( *cnf );
  1229.     m_bEventOk = DeCompose_Inquiry_Cancel_HCI_Event( *cnf );
  1231. }
  1233. //--------------------------------------------------------------------------
  1234. void  CBTCT::Compose_Inquiry_Cancel_HCI_Command( BT_HCI_COMMAND &hci_cmd )
  1235. {
  1236.     // 33 8B 9E 30 0A
  1238.     hci_cmd.m_opcode = 0x0402;
  1239.     hci_cmd.m_len    = 0;
  1240.     Reset_HCI_Command( hci_cmd );
  1242.     
  1243. }
  1245. //--------------------------------------------------------------------------
  1246. bool  CBTCT::DeCompose_Inquiry_Cancel_HCI_Event( BT_HCI_EVENT hci_event )
  1247. {
  1248.     if(
  1249.         0x00 != hci_event.m_parms[3]
  1250.        )
  1251.      {  return false;
  1252.      }
  1255.     return true;
  1256. }
  1258. //===========================================================================
  1259. ///////////////////////////        Connect           ////////////////////////
  1260. //===========================================================================
  1261. void  CBTCT::REQ_ConnectACL_Start( S_BT_CT bt_ct )
  1262. {
  1263.     gs_bt_ct_ptr  = this;
  1264.     g_bIsRunning  = true;
  1266.     m_sBTCT = bt_ct;
  1269.     ActiveMan->SetActiveFunction( ::REQ_Send_ConnectACL_HCI_command );
  1270. }
  1272. //---------------------------------------------------------------------------
  1273. void  CBTCT::REQ_Send_ConnectACL_HCI_command( void )
  1274. {
  1275.     if(!g_bIsRunning)  return;
  1277.     m_bEventOk = false;
  1278.     BT_HCI_COMMAND hci_cmd;
  1279.     //m_uiEventCount = 0;
  1280.     Compose_ConnectACL_HCI_Command( hci_cmd, m_sConnectACL );
  1281.     AddTxLogToStringList( hci_cmd );
  1282.     META_RESULT MetaResult = META_BT_RegisterAutoCallback_r( m_META_HANDLE_Obj.Get_MainHandle(), ::CNF_DisconnectACLAutoHCIEvent );
  1283.     MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 40000, &hci_cmd, ::CNF_ConnectACLHCIEvent, NULL, 0x1D );
  1285.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  1286.     {
  1287.         if( META_TIMEOUT == MetaResult )
  1288.         {
  1289.             Confirm( METAAPP_TIMEOUT );
  1290.             return;
  1291.         }
  1292.         else if( META_CANCEL == MetaResult )
  1293.         {
  1294.             Confirm( METAAPP_CANCEL );
  1295.             return;
  1296.         }
  1297.         else
  1298.         {
  1299.             Confirm( METAAPP_FAIL );
  1300.             return;
  1301.         }
  1302.     }
  1304.     Confirm(METAAPP_SUCCESS);
  1305. }
  1307. //---------------------------------------------------------------------------
  1308. void __stdcall CBTCT::CNF_ConnectACLHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  1309. {
  1310.     if(!g_bIsRunning)  return;
  1311.     if( 0xFF == cnf->m_event )  return; // LMP
  1312.    // m_uiEventCount++;
  1314.     AddRxLogToStringList( *cnf );
  1316.     m_bEventOk = DeCompose_ConnectACL_HCI_Event( *cnf );
  1318. }
  1320. //--------------------------------------------------------------------------
  1321. void __stdcall CBTCT::CNF_DisconnectACLAutoHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  1322. {
  1323.     AddRxLogToStringList( *cnf );
  1325.     if( (0x05 == cnf->m_event) && (0x00 == cnf->m_parms[0]) )
  1326.     {
  1327.         vector<S_BT_CT_RES>:: iterator iter;
  1328.         bool match;
  1329.         for( iter = m_pvCTRes->begin(); iter != m_pvCTRes->end(); iter++ )
  1330.         {
  1331.             match = true;
  1332.             if( iter->uc_h1_acl != cnf->m_parms[1] ||
  1333.                 iter->uc_h2_acl != cnf->m_parms[2]
  1334.               )
  1335.             {
  1336.                     match = false;
  1337.                     break;
  1338.             }
  1340.             if( match )
  1341.             {
  1342.                 iter->e_acl_status = BT_ACL_STATUS_NONE;
  1343.                 break;
  1344.             }
  1345.         }
  1346.     }
  1348.     if (NULL != m_sBTCT.log)
  1349.     {
  1350.         PostMessage(m_sBTCT.hPostMsgDestHandle,
  1351.                     WM_ML_BT_DISCONNECT_MSG,
  1352.                     PAGEIDX_BT_CT,
  1353.                     0
  1354.                     );
  1355.     }
  1356. }
  1358. //--------------------------------------------------------------------------
  1359. void  CBTCT::Compose_ConnectACL_HCI_Command( BT_HCI_COMMAND &hci_cmd, S_BT_CONNECT_ACL connect )
  1360. {
  1361.     // 33 8B 9E 30 0A
  1363.     hci_cmd.m_opcode = 0x0405;
  1364.     hci_cmd.m_len    = 13;
  1365.     Reset_HCI_Command( hci_cmd );
  1366.     for(int i=0; i<BD_ADDRESS_LEN; i++ )
  1367.         hci_cmd.m_cmd[i] = connect.s_bd_addr.uc_BD_Addr[i];
  1368.     hci_cmd.m_cmd[6] = connect.us_acl_pkt_type & 0x00FF;
  1369.     hci_cmd.m_cmd[7] = (connect.us_acl_pkt_type & 0xFF00) >> 8;
  1370.     hci_cmd.m_cmd[8] = 0x01;
  1371.     hci_cmd.m_cmd[9] = 0x00;
  1372.     hci_cmd.m_cmd[10]= 0x00;
  1373.     hci_cmd.m_cmd[11]= 0x00;
  1374.     hci_cmd.m_cmd[12]= 0x01;
  1375. }
  1377. //--------------------------------------------------------------------------
  1378. bool  CBTCT::DeCompose_ConnectACL_HCI_Event( BT_HCI_EVENT hci_event )
  1379. {
  1381.     if( 0x03 == hci_event.m_event )
  1382.     {
  1383.         S_BT_CT_RES ct_res;
  1384.         // status
  1385.         ct_res.e_acl_status = (E_BT_ACL_STATUS) hci_event.m_parms[0];
  1386.         if( (ct_res.e_acl_status != BT_ACL_STATUS_SUCCESS) &&
  1387.             (ct_res.e_acl_status != BT_ACL_STATUS_PAGE_TIMEOUT)
  1388.           )
  1389.         {   ct_res.e_acl_status = BT_ACL_STATUS_FAIL;
  1390.         }
  1392.         // connection handle
  1393.         ct_res.uc_h1_acl = hci_event.m_parms[1];
  1394.         ct_res.uc_h2_acl = hci_event.m_parms[2];
  1396.         // bd address
  1397.         for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1398.         {
  1399.             ct_res.s_bd_addr.uc_BD_Addr[i] = hci_event.m_parms[3+i];
  1400.         }
  1402.         vector<S_BT_CT_RES>:: iterator iter;
  1404.         for( iter = m_pvCTRes->begin(); iter != m_pvCTRes->end(); iter++ )
  1405.         {
  1406.             bool match = true;
  1407.             for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1408.             {
  1409.                 if( iter->s_bd_addr.uc_BD_Addr[i] != ct_res.s_bd_addr.uc_BD_Addr[i] )
  1410.                 {
  1411.                     match = false;
  1412.                     break;
  1413.                 }
  1414.             }
  1416.             if( match )
  1417.             {
  1418.                 *iter = ct_res;
  1419.                 break;
  1420.             }
  1421.         }
  1422.     }
  1423.     else if( 0x17 == hci_event.m_event )
  1424.     {
  1425. #if 0
  1426.         BT_HCI_COMMAND hci_cmd;
  1427.         Compose_Link_Key_Negative_Reply_HCI_Command( hci_cmd, m_sConnectACL );
  1428.         AddTxLogToStringList( hci_cmd );
  1429.         m_bEvent2Ok = false;
  1430.         META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_LinkKeyNegReplyHCIEvent, NULL, HCE_COMMAND_COMPLETE );
  1432.         if( (META_SUCCESS != MetaResult) || (!m_bEvent2Ok) )
  1433.         {
  1434.             if( META_TIMEOUT == MetaResult )
  1435.             {
  1436.                 Confirm( METAAPP_TIMEOUT );
  1437.                 return false;
  1438.             }
  1439.             else if( META_CANCEL == MetaResult )
  1440.             {
  1441.                 Confirm( METAAPP_CANCEL );
  1442.                 return false;
  1443.             }
  1444.             else
  1445.             {
  1446.                 Confirm( METAAPP_FAIL );
  1447.                 return false;
  1448.             }
  1449.         }
  1450. #endif
  1452.     }
  1453.     else if( 0x16 == hci_event.m_event )
  1454.     {
  1455.         if (NULL != m_sBTCT.log)
  1456.         {
  1457.             PostMessage(m_sBTCT.hPostMsgDestHandle,
  1458.                         WM_ML_BT_PIN_MSG,
  1459.                         PAGEIDX_BT_CT,
  1460.                         0
  1461.                        );
  1462.         }               
  1463.     }
  1465.     return true;
  1466. }
  1468. //---------------------------------------------------------------------------
  1469. void __stdcall CBTCT::CNF_LinkKeyNegReplyHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  1470. {
  1471.     if(!g_bIsRunning)  return;
  1472.     if( 0xFF == cnf->m_event )  return; // LMP
  1473.    // m_uiEventCount++;
  1475.     AddRxLogToStringList( *cnf );
  1477.     m_bEvent2Ok = DeCompose_Link_Key_Negative_Reply_HCI_Event( *cnf, m_sConnectACL );
  1478. }
  1480. //--------------------------------------------------------------------------
  1481. void  CBTCT::Compose_Link_Key_Negative_Reply_HCI_Command( BT_HCI_COMMAND &hci_cmd, S_BT_CONNECT_ACL connect )
  1482. {
  1483.     // 33 8B 9E 30 0A
  1485.     hci_cmd.m_opcode = 0x040C;
  1486.     hci_cmd.m_len    = 6;
  1487.     Reset_HCI_Command( hci_cmd );
  1488.     for(int i=0; i<BD_ADDRESS_LEN; i++ )
  1489.         hci_cmd.m_cmd[i] = connect.s_bd_addr.uc_BD_Addr[i];
  1490.     
  1491. }
  1493. //---------------------------------------------------------------------------
  1494. bool CBTCT::DeCompose_Link_Key_Negative_Reply_HCI_Event( BT_HCI_EVENT hci_event, S_BT_CONNECT_ACL connect )
  1495. {
  1496.     if( 0x00 != hci_event.m_parms[3] )
  1497.      {  return false;
  1498.      }
  1500.     for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1501.     {
  1502.         if( connect.s_bd_addr.uc_BD_Addr[i] != hci_event.m_parms[4+i] )
  1503.             return false;
  1504.     }        
  1506.     return true;
  1507. }
  1509. //===========================================================================
  1510. ///////////////////////////  Change ACL packet type  ////////////////////////
  1511. //===========================================================================
  1512. void  CBTCT::REQ_Change_ACL_Packet_Type_Start( S_BT_CT bt_ct )
  1513. {
  1514.     gs_bt_ct_ptr  = this;
  1515.     g_bIsRunning  = true;
  1517.     m_sBTCT = bt_ct;
  1520.     ActiveMan->SetActiveFunction( ::REQ_Send_Change_ACL_Packet_Type_HCI_command );
  1521. }
  1523. //---------------------------------------------------------------------------
  1524. void  CBTCT::REQ_Send_Change_ACL_Packet_Type_HCI_command( void )
  1525. {
  1526.     if(!g_bIsRunning)  return;
  1528.     m_bEventOk = false;
  1529.     BT_HCI_COMMAND hci_cmd;
  1530.     //m_uiEventCount = 0;
  1531.     Compose_Change_ACL_Packet_Type_HCI_Command( hci_cmd, m_sConnectACL );
  1532.     AddTxLogToStringList( hci_cmd );
  1533.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 10000, &hci_cmd, ::CNF_ChangeACLPacketTypeHCIEvent, NULL, 0x1D );
  1535.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  1536.     {
  1537.         if( META_TIMEOUT == MetaResult )
  1538.         {
  1539.             Confirm( METAAPP_TIMEOUT );
  1540.             return;
  1541.         }
  1542.         else if( META_CANCEL == MetaResult )
  1543.         {
  1544.             Confirm( METAAPP_CANCEL );
  1545.             return;
  1546.         }
  1547.         else
  1548.         {
  1549.             Confirm( METAAPP_FAIL );
  1550.             return;
  1551.         }
  1552.     }
  1554.     Confirm(METAAPP_SUCCESS);
  1555. }
  1557. //---------------------------------------------------------------------------
  1558. void __stdcall CBTCT::CNF_ChangeACLPacketTypeHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  1559. {
  1560.     if(!g_bIsRunning)  return;
  1561.     if( 0xFF == cnf->m_event )  return; // LMP
  1562.    // m_uiEventCount++;
  1564.     AddRxLogToStringList( *cnf );
  1566.     m_bEventOk = DeCompose_Change_ACL_Packet_Type_HCI_Event( *cnf );
  1568. }
  1570. //--------------------------------------------------------------------------
  1571. void  CBTCT::Compose_Change_ACL_Packet_Type_HCI_Command( BT_HCI_COMMAND &hci_cmd, S_BT_CONNECT_ACL connect )
  1572. {
  1573.     hci_cmd.m_opcode = 0x040F;
  1574.     hci_cmd.m_len    = 4;
  1575.     Reset_HCI_Command( hci_cmd );
  1577.     vector<S_BT_CT_RES>:: iterator iter;
  1578.     for( iter = m_pvCTRes->begin(); iter != m_pvCTRes->end(); iter++ )
  1579.     {
  1580.         bool match = true;
  1581.         for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1582.         {
  1583.             if( iter->s_bd_addr.uc_BD_Addr[i] != connect.s_bd_addr.uc_BD_Addr[i] )
  1584.             {
  1585.                 match = false;
  1586.                 break;
  1587.             }
  1588.         }
  1590.         if( match )
  1591.         {
  1592.             break;
  1593.         }
  1594.     }
  1595.     hci_cmd.m_cmd[0] = iter->uc_h1_acl;
  1596.     hci_cmd.m_cmd[1] = iter->uc_h2_acl;
  1597.     hci_cmd.m_cmd[2] = connect.us_acl_pkt_type & 0x00FF;
  1598.     hci_cmd.m_cmd[3] = (connect.us_acl_pkt_type & 0xFF00) >> 8;
  1599. }
  1601. //--------------------------------------------------------------------------
  1602. bool  CBTCT::DeCompose_Change_ACL_Packet_Type_HCI_Event( BT_HCI_EVENT hci_event )
  1603. {
  1608.     return true;
  1609. }
  1611. //===========================================================================
  1612. ///////////////////////////  Enter PIN  ////////////////////////
  1613. //===========================================================================
  1614. bool  CBTCT::REQ_EnterPIN_Start( S_BT_CT bt_ct )
  1615. {
  1616.     gs_bt_ct_ptr  = this;
  1617.     g_bIsRunning  = true;
  1619.     m_sBTCT = bt_ct;
  1622.     if( REQ_Send_EnterPIN_HCI_command() ) return false;
  1624.     return true;
  1625. }
  1627. //---------------------------------------------------------------------------
  1628. bool  CBTCT::REQ_Send_EnterPIN_HCI_command( void )
  1629. {
  1630.     if(!g_bIsRunning)  return false;
  1632.     m_bEventOk = false;
  1633.     BT_HCI_COMMAND hci_cmd;
  1634.     //m_uiEventCount = 0;
  1635.     Compose_EnterPIN_HCI_Command( hci_cmd, m_sEnterPIN );
  1636.     AddTxLogToStringList( hci_cmd );
  1637.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_EnterPINHCIEvent, NULL, HCE_COMMAND_COMPLETE );
  1638.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  1639.     {
  1640.         return false;
  1641.     }
  1643.     return true;
  1644. }
  1646. //---------------------------------------------------------------------------
  1647. void __stdcall CBTCT::CNF_EnterPINHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  1648. {
  1649.     if(!g_bIsRunning)  return;
  1650.     if( 0xFF == cnf->m_event )  return; // LMP
  1651.    // m_uiEventCount++;
  1653.     AddRxLogToStringList( *cnf );
  1655.     m_bEventOk = DeCompose_EnterPIN_HCI_Event( *cnf );
  1657. }
  1659. //--------------------------------------------------------------------------
  1660. void  CBTCT::Compose_EnterPIN_HCI_Command( BT_HCI_COMMAND &hci_cmd, S_BT_ENTER_PIN enter_pin )
  1661. {
  1662.     hci_cmd.m_opcode = 0x040D;
  1663.     hci_cmd.m_len    = 23;
  1664.     Reset_HCI_Command( hci_cmd );
  1666.     for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1667.     {
  1668.         hci_cmd.m_cmd[i] = enter_pin.s_bd_addr.uc_BD_Addr[i];
  1669.     }
  1671.     hci_cmd.m_cmd[6] = enter_pin.s_bt_pin.uc_pin_len;
  1672.     for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1673.     {
  1674.         hci_cmd.m_cmd[7+i] = enter_pin.s_bt_pin.uc_PIN[i];
  1675.     }
  1676.     
  1677. }
  1679. //--------------------------------------------------------------------------
  1680. bool  CBTCT::DeCompose_EnterPIN_HCI_Event( BT_HCI_EVENT hci_event )
  1681. {
  1682.     if(
  1683.         0x00 != hci_event.m_parms[3]
  1684.        )
  1685.      {  return false;
  1686.      }
  1689.     return true;
  1690. }
  1692. //===========================================================================
  1693. ///////////////////////////      Disonnect  ACL      ////////////////////////
  1694. //===========================================================================
  1695. void  CBTCT::REQ_DisconnectACL_Start( S_BT_CT bt_ct )
  1696. {
  1697.     gs_bt_ct_ptr  = this;
  1698.     g_bIsRunning  = true;
  1700.     m_sBTCT = bt_ct;
  1703.     ActiveMan->SetActiveFunction( ::REQ_Send_DisconnectACL_HCI_command );
  1704. }
  1706. //---------------------------------------------------------------------------
  1707. void  CBTCT::REQ_Send_DisconnectACL_HCI_command( void )
  1708. {
  1709.     if(!g_bIsRunning)  return;
  1711.     m_bEventOk = false;
  1712.     BT_HCI_COMMAND hci_cmd;
  1713.     //m_uiEventCount = 0;
  1714.     Compose_DisconnectACL_HCI_Command( hci_cmd, m_sDisconnectACL );
  1715.     AddTxLogToStringList( hci_cmd );
  1716.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 10000, &hci_cmd, ::CNF_DisconnectACLHCIEvent, NULL, 0x05 );
  1718.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  1719.     {
  1720.         if( META_TIMEOUT == MetaResult )
  1721.         {
  1722.             Confirm( METAAPP_TIMEOUT );
  1723.             return;
  1724.         }
  1725.         else if( META_CANCEL == MetaResult )
  1726.         {
  1727.             Confirm( METAAPP_CANCEL );
  1728.             return;
  1729.         }
  1730.         else
  1731.         {
  1732.             Confirm( METAAPP_FAIL );
  1733.             return;
  1734.         }
  1735.     }
  1737.     Confirm(METAAPP_SUCCESS);
  1738. }
  1740. //---------------------------------------------------------------------------
  1741. void __stdcall CBTCT::CNF_DisconnectACLHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  1742. {
  1743.     if(!g_bIsRunning)  return;
  1744.     if( 0xFF == cnf->m_event )  return; // LMP
  1745.    // m_uiEventCount++;
  1747.     AddRxLogToStringList( *cnf );
  1749.     m_bEventOk = DeCompose_DisconnectACL_HCI_Event( *cnf, m_sDisconnectACL );
  1751. }
  1753. //--------------------------------------------------------------------------
  1754. void  CBTCT::Compose_DisconnectACL_HCI_Command( BT_HCI_COMMAND &hci_cmd, S_BT_DISCONNECT_ACL disconnect )
  1755. {
  1756.     // 33 8B 9E 30 0A
  1758.     hci_cmd.m_opcode = 0x0406;
  1759.     hci_cmd.m_len    = 3;
  1760.     Reset_HCI_Command( hci_cmd );
  1762.     vector<S_BT_CT_RES>:: iterator iter;
  1763.     for( iter = m_pvCTRes->begin(); iter != m_pvCTRes->end(); iter++ )
  1764.     {
  1765.         bool match = true;
  1766.         for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1767.         {
  1768.             if( iter->s_bd_addr.uc_BD_Addr[i] != disconnect.s_bd_addr.uc_BD_Addr[i] )
  1769.             {
  1770.                 match = false;
  1771.                 break;
  1772.             }
  1773.         }
  1775.         if( match )
  1776.         {
  1777.             break;
  1778.         }
  1779.     }
  1781.     hci_cmd.m_cmd[0] = iter->uc_h1_acl;
  1782.     hci_cmd.m_cmd[1] = iter->uc_h2_acl;
  1783.     hci_cmd.m_cmd[2] = 0x13;
  1785. }
  1787. //--------------------------------------------------------------------------
  1788. bool  CBTCT::DeCompose_DisconnectACL_HCI_Event( BT_HCI_EVENT hci_event, S_BT_DISCONNECT_ACL disconnect )
  1789. {
  1790.     if( (0x05 == hci_event.m_event) && (0x00 == hci_event.m_parms[0]) )
  1791.     {
  1792.         vector<S_BT_CT_RES>:: iterator iter;
  1793.         for( iter = m_pvCTRes->begin(); iter != m_pvCTRes->end(); iter++ )
  1794.         {
  1795.             bool match = true;
  1796.             for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1797.             {
  1798.                 if( iter->s_bd_addr.uc_BD_Addr[i] != disconnect.s_bd_addr.uc_BD_Addr[i] )
  1799.                 {
  1800.                     match = false;
  1801.                     break;
  1802.                 }
  1803.             }
  1805.             if( match )
  1806.             {
  1807.                 iter->e_acl_status = BT_ACL_STATUS_NONE;
  1808.                 break;
  1809.             }
  1810.         }
  1811.     }
  1813.     return true;
  1814. }
  1817. //===========================================================================
  1818. ///////////////////////////        Connect  SCO      ////////////////////////
  1819. //===========================================================================
  1820. void  CBTCT::REQ_ConnectSCO_Start( S_BT_CT bt_ct )
  1821. {
  1822.     gs_bt_ct_ptr  = this;
  1823.     g_bIsRunning  = true;
  1825.     m_sBTCT = bt_ct;
  1828.     ActiveMan->SetActiveFunction( ::REQ_Send_ConnectSCO_HCI_command );
  1829. }
  1831. //---------------------------------------------------------------------------
  1832. void  CBTCT::REQ_Send_ConnectSCO_HCI_command( void )
  1833. {
  1834.     if(!g_bIsRunning)  return;
  1836.     m_bEventOk = false;
  1837.     BT_HCI_COMMAND hci_cmd;
  1838.     //m_uiEventCount = 0;
  1839.     Compose_ConnectSCO_HCI_Command( hci_cmd, m_sConnectSCO );
  1840.     AddTxLogToStringList( hci_cmd );
  1841.     META_RESULT MetaResult = META_BT_SendHCICommand_r( m_META_HANDLE_Obj.Get_MainHandle(), 10000, &hci_cmd, ::CNF_ConnectSCOHCIEvent, NULL, 0x2C );
  1843.     if( (META_SUCCESS != MetaResult) || (!m_bEventOk) )
  1844.     {
  1845.         if( META_TIMEOUT == MetaResult )
  1846.         {
  1847.             Confirm( METAAPP_TIMEOUT );
  1848.             return;
  1849.         }
  1850.         else if( META_CANCEL == MetaResult )
  1851.         {
  1852.             Confirm( METAAPP_CANCEL );
  1853.             return;
  1854.         }
  1855.         else
  1856.         {
  1857.             Confirm( METAAPP_FAIL );
  1858.             return;
  1859.         }
  1860.     }
  1862.     Confirm(METAAPP_SUCCESS);
  1863. }
  1865. //---------------------------------------------------------------------------
  1866. void __stdcall CBTCT::CNF_ConnectSCOHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  1867. {
  1868.     if(!g_bIsRunning)  return;
  1869.     if( 0xFF == cnf->m_event )  return; // LMP
  1870.    // m_uiEventCount++;
  1872.     AddRxLogToStringList( *cnf );
  1874.     m_bEventOk = DeCompose_ConnectSCO_HCI_Event( *cnf, m_sConnectSCO );
  1876. }
  1878. //--------------------------------------------------------------------------
  1879. void  CBTCT::Compose_ConnectSCO_HCI_Command(BT_HCI_COMMAND &hci_cmd, S_BT_CT_CONNECT_SCO connect)
  1880. {
  1881.     hci_cmd.m_opcode = 0x0428;
  1882.     hci_cmd.m_len    = 17;
  1883.     Reset_HCI_Command( hci_cmd );
  1885.     vector<S_BT_CT_RES>:: iterator iter;
  1886.     for( iter = m_pvCTRes->begin(); iter != m_pvCTRes->end(); iter++ )
  1887.     {
  1888.         bool match = true;
  1889.         for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1890.         {
  1891.             if( iter->s_bd_addr.uc_BD_Addr[i] != connect.s_bd_addr.uc_BD_Addr[i] )
  1892.             {
  1893.                 match = false;
  1894.                 break;
  1895.             }
  1896.         }
  1898.         if( match )
  1899.         {
  1900.             break;
  1901.         }
  1902.     }
  1903.     hci_cmd.m_cmd[0] = iter->uc_h1_acl;
  1904.     hci_cmd.m_cmd[1] = iter->uc_h2_acl;
  1905.     hci_cmd.m_cmd[2] = 0x40; // @4 Transmit_Bandwidth
  1906.     hci_cmd.m_cmd[3] = 0x1F;
  1907.     hci_cmd.m_cmd[4] = 0x00;
  1908.     hci_cmd.m_cmd[5] = 0x00;
  1909.     hci_cmd.m_cmd[6] = 0x40; // @4 Receive_Bandwidth
  1910.     hci_cmd.m_cmd[7] = 0x1F;
  1911.     hci_cmd.m_cmd[8] = 0x00;
  1912.     hci_cmd.m_cmd[9] = 0x00;
  1913.     hci_cmd.m_cmd[10]= 0x05; // @2 Max_Latency
  1914.     hci_cmd.m_cmd[11]= 0x00;
  1915.     hci_cmd.m_cmd[12]= 0xAC; // @2 Voice_Setting
  1916.     hci_cmd.m_cmd[13]= 0x00;
  1917.     hci_cmd.m_cmd[14]= 0x00; // @1 Retransmission_Effort
  1918.     hci_cmd.m_cmd[15]=  connect.e_pkt_type & 0x00FF; // @2 Packet_Type
  1919.     hci_cmd.m_cmd[16]= (connect.e_pkt_type & 0xFF00) >> 8;
  1920. }
  1922. //--------------------------------------------------------------------------
  1923. bool  CBTCT::DeCompose_ConnectSCO_HCI_Event(BT_HCI_EVENT hci_event, S_BT_CT_CONNECT_SCO connect)
  1924. {
  1925.     if( 0x2C == hci_event.m_event )
  1926.     {
  1927.         vector<S_BT_CT_RES>:: iterator iter;
  1928.         for( iter = m_pvCTRes->begin(); iter != m_pvCTRes->end(); iter++ )
  1929.         {
  1930.             bool match = true;
  1931.             for( int i=0; i<BD_ADDRESS_LEN; i++ )
  1932.             {
  1933.                 if( iter->s_bd_addr.uc_BD_Addr[i] != connect.s_bd_addr.uc_BD_Addr[i] )
  1934.                 {
  1935.                     match = false;
  1936.                     break;
  1937.                 }
  1938.             }
  1940.             if( match )
  1941.             {
  1942.                 break;
  1943.             }
  1944.         }
  1946.         if( hci_event.m_parms[0] != 0   )
  1947.         {
  1948.             iter->e_sco_status = BT_CT_SCO_STATUS_FAIL;
  1949.             return false;
  1950.         }
  1952.         iter->e_sco_status = BT_CT_SCO_STATUS_SUCCESS;
  1953.         iter->uc_h1_sco    = hci_event.m_parms[1];
  1954.         iter->uc_h2_sco    = hci_event.m_parms[2];
  1955.     }
  1956.     return true;
  1957. }
  1959. //===========================================================================
  1960. ///////////////////////////      Disonnect  SCO      ////////////////////////
  1961. //===========================================================================
  1962. void  CBTCT::REQ_DisconnectSCO_Start(S_BT_CT bt_ct)
  1963. {
  1964.     gs_bt_ct_ptr  = this;
  1965.     g_bIsRunning  = true;
  1967.     m_sBTCT = bt_ct;
  1970.     ActiveMan->SetActiveFunction(::REQ_Send_DisconnectSCO_HCI_command);
  1971. }
  1973. //---------------------------------------------------------------------------
  1974. void  CBTCT::REQ_Send_DisconnectSCO_HCI_command(void)
  1975. {
  1976.     if(!g_bIsRunning)  return;
  1978.     m_bEventOk = false;
  1979.     BT_HCI_COMMAND hci_cmd;
  1980.     //m_uiEventCount = 0;
  1981.     Compose_DisconnectSCO_HCI_Command(hci_cmd, m_sDisconnectSCO);
  1982.     AddTxLogToStringList(hci_cmd);
  1983.     META_RESULT MetaResult = META_BT_SendHCICommand_r(m_META_HANDLE_Obj.Get_MainHandle(), 5000, &hci_cmd, ::CNF_DisconnectSCOHCIEvent, NULL, 0x05 );
  1985.     if ((META_SUCCESS != MetaResult) || (!m_bEventOk))
  1986.     {
  1987.         if (META_TIMEOUT == MetaResult)
  1988.         {
  1989.             Confirm(METAAPP_TIMEOUT);
  1990.         }
  1991.         else if (META_CANCEL == MetaResult)
  1992.         {
  1993.             Confirm(METAAPP_CANCEL);
  1994.         }
  1995.         else
  1996.         {
  1997.             Confirm(METAAPP_FAIL);
  1998.         }
  1999.         return;
  2000.     }
  2002.     Confirm(METAAPP_SUCCESS);
  2003. }
  2005. //---------------------------------------------------------------------------
  2006. void __stdcall CBTCT::CNF_DisconnectSCOHCIEvent(const BT_HCI_EVENT *cnf, const short token, void *usrData)
  2007. {
  2008.     if (!g_bIsRunning)
  2009.     {
  2010.         return;
  2011.     }
  2013.     if (0xFF == cnf->m_event) // LMP
  2014.     {
  2015.         return;
  2016.     }
  2017.    // m_uiEventCount++;
  2019.     AddRxLogToStringList( *cnf );
  2021.     m_bEventOk = DeCompose_DisconnectSCO_HCI_Event( *cnf, m_sDisconnectSCO );
  2023. }
  2025. //--------------------------------------------------------------------------
  2026. void  CBTCT::Compose_DisconnectSCO_HCI_Command( BT_HCI_COMMAND &hci_cmd, S_BT_CT_DISCONNECT_SCO disconnect )
  2027. {
  2028.     // 33 8B 9E 30 0A
  2030.     hci_cmd.m_opcode = 0x0406;
  2031.     hci_cmd.m_len    = 3;
  2032.     Reset_HCI_Command( hci_cmd );
  2034.     vector<S_BT_CT_RES>:: iterator iter;
  2035.     for( iter = m_pvCTRes->begin(); iter != m_pvCTRes->end(); iter++ )
  2036.     {
  2037.         bool match = true;
  2038.         for( int i=0; i<BD_ADDRESS_LEN; i++ )
  2039.         {
  2040.             if( iter->s_bd_addr.uc_BD_Addr[i] != disconnect.s_bd_addr.uc_BD_Addr[i] )
  2041.             {
  2042.                 match = false;
  2043.                 break;
  2044.             }
  2045.         }
  2047.         if( match )
  2048.         {
  2049.             iter->e_sco_status = BT_CT_SCO_STATUS_NONE;
  2050.             break;
  2051.         }
  2052.     }
  2054.     hci_cmd.m_cmd[0] = iter->uc_h1_sco;
  2055.     hci_cmd.m_cmd[1] = iter->uc_h2_sco;
  2056.     hci_cmd.m_cmd[2] = 0x13;
  2058. }
  2060. //--------------------------------------------------------------------------
  2061. bool  CBTCT::DeCompose_DisconnectSCO_HCI_Event(BT_HCI_EVENT hci_event, S_BT_CT_DISCONNECT_SCO disconnect)
  2062. {
  2063.    // if( (0x05 == hci_event.m_event) && (0x00 == hci_event.m_parms[0]) )
  2064.     {
  2065.         vector<S_BT_CT_RES>:: iterator iter;
  2066.         for( iter = m_pvCTRes->begin(); iter != m_pvCTRes->end(); iter++ )
  2067.         {
  2068.             bool match = true;
  2069.             for( int i=0; i<BD_ADDRESS_LEN; i++ )
  2070.             {
  2071.                 if( iter->s_bd_addr.uc_BD_Addr[i] != disconnect.s_bd_addr.uc_BD_Addr[i] )
  2072.                 {
  2073.                     match = false;
  2074.                     break;
  2075.                 }
  2076.             }
  2078.             if (match)
  2079.             {
  2080.                 iter->e_sco_status = BT_CT_SCO_STATUS_NONE;
  2081.                 break;
  2082.             }
  2083.         }
  2084.     }
  2086.     return true;
  2087. }
  2089. //===========================================================================
  2090. ////////////////////////////   Log  information   ////////////////////////
  2091. //===========================================================================
  2092. void  CBTCT::AddTxLogToStringList(BT_HCI_COMMAND hci_cmd)
  2093. {
  2094.     if (NULL == m_sBTCT.log)
  2095.     {
  2096.         return;
  2097.     }
  2099.     char        str[1024];
  2100.     AnsiString as_log;
  2101.     sprintf( str, "%X,", hci_cmd.m_opcode & 0x00FF );
  2102.     AnsiString as_opcode_low(str);
  2103.     sprintf( str, "%X,", (hci_cmd.m_opcode & 0xFF00)>>8 );
  2104.     AnsiString as_opcode_high(str);
  2105.     Array_To_Hex_String_UnsignedChar( str, hci_cmd.m_cmd, hci_cmd.m_len, ',' );
  2106.     AnsiString as_cmd( (const char*)str );
  2107.     if( 0 == hci_cmd.m_len )
  2108.        as_cmd = "";
  2109.     sprintf( str, "%X,", hci_cmd.m_len );
  2110.     AnsiString as_length(str);
  2113.     as_log = "[" + TimeToStr(Time()) + "] TX: " + as_opcode_low + as_opcode_high + as_length  + as_cmd;
  2115.     m_sBTCT.log->Add( as_log );
  2117.     PostMessage(
  2118.                          m_sBTCT.hPostMsgDestHandle,
  2119.                          WM_ML_BT_PRINT_MSG,
  2120.                          PAGEIDX_BT_CT,
  2121.                          0
  2122.                         );
  2123. }
  2125. //--------------------------------------------------------------------------
  2126. void  CBTCT::AddRxLogToStringList(BT_HCI_EVENT hci_event)
  2127. {
  2128.     if (NULL == m_sBTCT.log)
  2129.     {
  2130.         return;
  2131.     }
  2133.     unsigned char        str[1024];
  2134.     AnsiString as_log;
  2135.     sprintf( str, "%X,", hci_event.m_event );
  2136.     AnsiString as_event( (const char*) str );
  2137.     sprintf( str, "%X,", hci_event.m_len );
  2138.     AnsiString as_length( (const char*) str );
  2139.     Array_To_Hex_String_UnsignedChar( str, hci_event.m_parms, hci_event.m_len, ',' );
  2140.     AnsiString as_param( (const char*) str );
  2141.     if(  0 == hci_event.m_len )
  2142.         as_param = "";
  2144.     as_log = "[" + TimeToStr(Time()) + "] RX: " + as_event + as_length + as_param;
  2145.     m_sBTCT.log->Add( as_log );
  2147.     PostMessage(
  2148.                          m_sBTCT.hPostMsgDestHandle,
  2149.                          WM_ML_BT_PRINT_MSG,
  2150.                          PAGEIDX_BT_CT,
  2151.                          0
  2152.                         );
  2153. }
  2155. //===========================================================================
  2156. ////////////////////////////   Global  information   ////////////////////////
  2157. //===========================================================================
  2158. E_METAAPP_RESULT_T CBTCT::Get_ConfirmState(void)
  2159. {
  2160.     return  m_eConfirmState;
  2161. }
  2163. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  2164. S_BD_ADDRS CBTCT::Get_LocalBdAddr( void )
  2165. {   return m_sLocalBdAddr;
  2166. }
  2168. //---------------------------------------------------------------------------
  2169. void CBTCT::Set_LocalBdAddr( S_BD_ADDRS bd_addr )
  2170. {   m_sLocalBdAddr = bd_addr;
  2171. }
  2173. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  2174. void CBTCT::Set_ScanParameter( S_BT_SCAN scan )
  2175. {   m_sScan = scan; 
  2176. }
  2178. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  2179. void CBTCT::Set_InquiryTimeout( unsigned int timeout )
  2180. {   m_uiInquiryTimeout = timeout;
  2181. }
  2183. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  2184. vector<S_BT_CT_RES>*  CBTCT::Get_CtResVector( void )
  2185. {
  2186.     return m_pvCTRes;
  2187. }
  2189. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  2190. void CBTCT::Set_EnterPINParameter( S_BT_ENTER_PIN enter_pin )
  2191. {   m_sEnterPIN = enter_pin;
  2192. }
  2194. //--------------------------------------------------------------------------
  2195. void CBTCT::Set_ConnectACLParameter( S_BT_CONNECT_ACL connect )
  2196. {   m_sConnectACL = connect;
  2197. }
  2199. //---------------------------------------------------------------------------
  2200. void CBTCT::Set_DisconnectACLParameter( S_BT_DISCONNECT_ACL disconnect )
  2201. {   m_sDisconnectACL = disconnect;
  2202. }
  2204. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  2205. void CBTCT::Set_ConnectSCOParameter( S_BT_CT_CONNECT_SCO connect )
  2206. {   m_sConnectSCO = connect;
  2207. }
  2209. //---------------------------------------------------------------------------
  2210. void CBTCT::Set_DisconnectSCOParameter( S_BT_CT_DISCONNECT_SCO disconnect )
  2211. {   m_sDisconnectSCO = disconnect;
  2212. }
  2214. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~