mfw_bta.c

是一个手机功能的模拟程序

#endif
      MFREE(srv_sync_push_ind);
      return TRUE;
    case BTP_SRV_SYNC_PUSH_CNF:
      /* BTI indicates that the client requests to pull an object from the sync server */
      MALLOC(srv_sync_push_cnf, sizeof(T_MFW_BT_SRV_SYNC_PUSH_CNF));
      memset(srv_sync_push_cnf, 0, sizeof(T_MFW_BT_SRV_SYNC_PUSH_CNF));
      srv_sync_push_cnf->service = ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->device;
      srv_sync_push_cnf->subtype = ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->subtype;
      memcpy(srv_sync_push_cnf->mfw_client_bd_addr, ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
      srv_sync_push_cnf->mfw_object.mfw_object_type = ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_type;
      memset(&sync_object_name, 0, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);/* limited with 256 characters */
      memcpy(&sync_object_name, &((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_name, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);
      srv_sync_push_cnf->mfw_object.mfw_object_name = sync_object_name;/* from string in Primitive to static buffer in MFW (pointer is not possible in Primitive), pointer of buffer */
      memset(&receiv_sync_object_mime_type, 0, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);/* limited with 256 characters */
      memcpy(&receiv_sync_object_mime_type, &((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_m_t, MFW_BT_OPP_OBJECT_MIME_MAX_LEN);
      srv_sync_push_cnf->mfw_object.mfw_object_mime_type = receiv_sync_object_mime_type;/* same comment like for ...object_name */
      srv_sync_push_cnf->mfw_object.mfw_object_length = ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_length;
      srv_sync_push_cnf->mfw_object_id.mfw_object_size = ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_id_size;
      memset(&sync_object_location_id, 0, MFW_BT_SYNC_OBJECT_IDENTIFIER);/* limited with 256 characters */
      memcpy(&sync_object_location_id, &((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_id_loc, MFW_BT_SYNC_OBJECT_IDENTIFIER);
      srv_sync_push_cnf->mfw_object_id.mfw_location = sync_object_location_id;/* from string in Primitive to static buffer in MFW (pointer is not possible in Primitive), pointer of buffer */
      bt_signal(BT_SRV_SYNC_PUSH_CNF, srv_sync_push_cnf);
#ifdef _SIMULATION_
      TRACE_EVENT_P3("sync push cnf = %d, %d, %s", srv_sync_push_cnf->service, srv_sync_push_cnf->subtype, srv_sync_push_cnf->mfw_client_bd_addr);
#endif
      MFREE(srv_sync_push_cnf);
      return TRUE;

    case BTP_CONNECT_DEVICE_INF:
      /* BTI indicates that hsg manages a connection on RFCOMM level */
      MALLOC(connect_inf, sizeof(T_MFW_BT_CONNECT_INF));
      memset(connect_inf, 0, sizeof(T_MFW_BT_CONNECT_INF));
      connect_inf->service = ((T_BTP_CONNECT_DEVICE_INF *)data)->device;
      connect_inf->ind_id = ((T_BTP_CONNECT_DEVICE_INF *)data)->ind_id;

      if(connect_inf->ind_id EQ MFW_BT_INVALID_HEADSET_ID)
      {
        memcpy(connect_inf->bd_addr, ((T_BTP_CONNECT_DEVICE_INF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
      }
      bt_signal(BT_CONNECT_DEVICE_INF, connect_inf);
#ifdef _SIMULATION_
      TRACE_EVENT_P3("conn inf = %d %d %s", connect_inf->service, connect_inf->ind_id, connect_inf->bd_addr);
#endif
      MFREE(connect_inf);
      return TRUE;

  /* BT CTRL */
    case BTP_CHNG_LOCAL_NAME:
      MALLOC(c_loc_name, sizeof(T_MFW_BT_CHNG_LOCAL_NAME));
      c_loc_name->success = ((T_BTP_CHNG_LOCAL_NAME *)data)->success;
      bt_signal(BT_CHNG_LOCAL_NAME, c_loc_name);
      MFREE(c_loc_name);
      return TRUE;

    case BTP_READ_LOCAL_NAME:
      MALLOC(r_loc_name, sizeof(T_MFW_BT_READ_LOCAL_NAME));
      r_loc_name->success = ((T_BTP_READ_LOCAL_NAME *)data)->success;
      memcpy(r_loc_name->bd_name, ((T_BTP_READ_LOCAL_NAME *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
      bt_signal(BT_READ_LOCAL_NAME, r_loc_name);
      MFREE(r_loc_name);
      return TRUE;

    case BTP_REMOTE_DEV_INFO_RES:
      MALLOC(rem_dev_info, sizeof(T_MFW_BT_REMOTE_DEV_INFO_RES));
      rem_dev_info->success = ((T_BTP_REMOTE_DEV_INFO_RES *)data)->success;
      memcpy(rem_dev_info->bd_addr, ((T_BTP_REMOTE_DEV_INFO_RES *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
      memcpy(rem_dev_info->bd_name, ((T_BTP_REMOTE_DEV_INFO_RES *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
      memcpy(rem_dev_info->cod, ((T_BTP_REMOTE_DEV_INFO_RES *)data)->cod, MFW_BT_DEVICE_CLASS_LEN);

      bt_signal(BT_REMOTE_DEV_INFO_RES, rem_dev_info);
      MFREE(rem_dev_info);
      return TRUE;

    case BTP_CHNG_CONNECTABLE_MODE:
      MALLOC(chng_cmode, sizeof(T_MFW_BT_CHNG_CONNECTABLE_MODE));
      chng_cmode->success = ((T_BTP_CHNG_CONNECTABLE_MODE *)data)->success;
      chng_cmode->mode = (T_MFW_BT_CONNECTABLE_MODE)((T_BTP_CHNG_CONNECTABLE_MODE *)data)->mode;
      chng_cmode->scan_interval = ((T_BTP_CHNG_CONNECTABLE_MODE *)data)->scan_interval;
      chng_cmode->scan_window = ((T_BTP_CHNG_CONNECTABLE_MODE *)data)->scan_window;

      bt_signal(BT_CHNG_CONNECTABLE_MODE, chng_cmode);
      MFREE(chng_cmode);
      return TRUE;

    case BTP_CHNG_DISCOVERABLE_MODE:
      MALLOC(chng_dmode, sizeof(T_MFW_BT_CHNG_DISCOVERABLE_MODE));
      chng_dmode->success = ((T_BTP_CHNG_DISCOVERABLE_MODE *)data)->success;
      chng_dmode->mode = (T_MFW_BT_DISCOVERABLE_MODE)((T_BTP_CHNG_DISCOVERABLE_MODE *)data)->mode;
      chng_dmode->scan_interval = ((T_BTP_CHNG_DISCOVERABLE_MODE *)data)->scan_interval;
      chng_dmode->scan_window = ((T_BTP_CHNG_DISCOVERABLE_MODE *)data)->scan_window;

      bt_signal(BT_CHNG_DISCOVERABLE_MODE, chng_dmode);
      MFREE(chng_dmode);
      return TRUE;

    case BTP_READ_BD_ADDR:
      MALLOC(r_bd_addr, sizeof(T_MFW_BT_READ_BD_ADDR));
      r_bd_addr->success = ((T_BTP_READ_BD_ADDR *)data)->success;
      memcpy(r_bd_addr->bd_addr, ((T_BTP_READ_BD_ADDR *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
      bt_signal(BT_READ_BD_ADDR, r_bd_addr);
      MFREE(r_bd_addr);
      return TRUE;

/*#ifdef PCA_6350*/
    case BTP_PCA_EVENT:
      if (((T_BTP_PCA_EVENT*)data)->pca_event == BTI_PCA_GW_STATUS_CFM)
      {
        MALLOC(pca_gw_status, sizeof(T_MFW_BT_PCA_GW_STATUS_CFM));
        pca_gw_status->status = ((T_BTP_PCA_EVENT*)data)->pca_gw_status;
        bt_signal(BT_PCA_GW_STATUS_CFM, pca_gw_status);
        return TRUE;
      }

      if (((T_BTP_PCA_EVENT*)data)->pca_event == BTI_PCA_GW_LINK_MONITORING)
      {
        MALLOC(pca_link_mon, sizeof(T_MFW_BT_PCA_GW_LINK_MONITORING));
        pca_link_mon->link_status = ((T_BTP_PCA_EVENT*)data)->pca_link_status;
        memcpy(pca_link_mon->bd_addr, ((T_BTP_PCA_EVENT *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
        bt_signal(BT_PCA_GW_LINK_MONITORING, pca_link_mon);
        return TRUE;
      }

      if (((T_BTP_PCA_EVENT*)data)->pca_event == BTI_PCA_GW_CALL_MONITORING)
      {
        MALLOC(pca_call_mon, sizeof(T_MFW_BT_PCA_GW_CALL_MONITORING));
        pca_call_mon->call_status = ((T_BTP_PCA_EVENT*)data)->pca_call_status;
        bt_signal(BT_PCA_GW_CALL_MONITORING, pca_call_mon);
        return TRUE;
      }

      if (((T_BTP_PCA_EVENT*)data)->pca_event == BTI_PCA_GW_HANGUP_CFM)
      {
        MALLOC(pca_hangup, sizeof(T_MFW_BT_PCA_GW_HANGUP_CFM));
        pca_hangup->hangup = ((T_BTP_PCA_EVENT*)data)->pca_hangup;
        bt_signal(BT_PCA_GW_HANGUP_CFM, pca_hangup);
        return TRUE;
      }

    /* Cartman added begin */
    
    case BTP_HSG_HEADSET_CONNECTION_IND:
        MALLOC(hsg_headset_connection_ind, sizeof(T_MFW_BT_HSG_HEADSET_CONNECTION_IND));
        memset(hsg_headset_connection_ind, 0, sizeof(T_MFW_BT_HSG_HEADSET_CONNECTION_IND));
        
        hsg_headset_connection_ind->service = ((T_BTP_HSG_HEADSET_CONNECTION_IND *)data)->device;
        hsg_headset_connection_ind->ind_id = ((T_BTP_HSG_HEADSET_CONNECTION_IND *)data)->ind_id;
        memcpy(hsg_headset_connection_ind->bd_addr, ((T_BTP_HSG_HEADSET_CONNECTION_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);

        bt_signal(BT_HSG_HEADSET_CONNECTION_IND, hsg_headset_connection_ind);    	
    	return TRUE;

    case BTP_HSG_SPECIFIC_CMD_RDY:
		MALLOC(hsg_specific_cmd_cfm, sizeof(T_MFW_BT_HSG_SPECIFIC_CMD_CFM));

		memcpy(hsg_specific_cmd_cfm->cmd,((T_BTP_HSG_SPECIFIC_CMD_RDY *)data)->cmd,100);
        
        bt_signal(BT_HSG_SPECIFIC_CMD_CFM,hsg_specific_cmd_cfm);
    	return TRUE;

    case BTP_HSG_SAVE_LIST_CNF:
        MALLOC(hsg_save_list_cnf, sizeof(T_MFW_BT_HSG_SAVE_LIST_CNF));
        hsg_save_list_cnf->result=((T_BTP_HSG_SAVE_LIST_CNF *)data)->result;
        
        bt_signal(BT_HSG_SAVE_LIST_CNF,hsg_save_list_cnf);
    	return TRUE;    	

    /* Cartman added end */
      
/*#endif*/ /* PCA_6350 */
  }

#ifdef _SIMULATION_
/*
 * kk 12.01.01
 * these primitives are available only for testing. they describe
 * function calls (loopbacked to ACI/MFW) made from MFW
 */

    switch ((USHORT) opc)
    {
        case BTP_INIT_PROFILE_REQ:
        TRACE_EVENT("bta_response_cb:BTP_INIT_PROFILE_REQ");
        return TRUE;

        case BTP_DEINIT_PROFILE_REQ:
        TRACE_EVENT("bta_response_cb:BTP_DEINIT_PROFILE_REQ");
        return TRUE;

        case BTP_DEVICE_SEARCH_REQ:
        TRACE_EVENT("bta_response_cb:BTP_DEVICE_SEARCH_REQ");
        return TRUE;

        case BTP_CONNECT_DEVICE_REQ:
        TRACE_EVENT("bta_response_cb:BTP_CONNECT_DEVICE_REQ");
        return TRUE;

        case BTP_CONNECT_DEVICE_RES:
        TRACE_EVENT("bta_response_cb:BTP_CONNECT_DEVICE_RES");
        return TRUE;

        case BTP_DISCONNECT_DEVICE_REQ:
        TRACE_EVENT("bta_response_cb:BTP_DISCONNECT_DEVICE_REQ");
        return TRUE;

        case BTP_TRANSFER_AUDIO_IN_REQ:
        TRACE_EVENT("bta_response_cb:BTP_TRANSFER_AUDIO_IN_REQ");
        return TRUE;

        case BTP_TRANSFER_AUDIO_OUT_REQ:
        TRACE_EVENT("bta_response_cb:BTP_TRANSFER_AUDIO_OUT_REQ");
        return TRUE;

        case BTP_RECONFIG_PROFILE_REQ:
        TRACE_EVENT("bta_response_cb:BTP_RECONFIG_PROFILE_REQ");
        return TRUE;

        case BTI_SEND_DATA_TEST:
        TRACE_EVENT("BTI_SEND_DATA_TEST");
        {
            UBYTE buf[2048];
            memset(buf, 0, 2048);
            memcpy(buf, ((T_BTI_SEND_DATA_TEST *)data)->ind_data, ((T_BTI_SEND_DATA_TEST *)data)->len);

            bti_simulate_dti_data_ind(((T_BTI_SEND_DATA_TEST *)data)->port_nb, ((T_BTI_SEND_DATA_TEST *)data)->len, buf);
        }
        return TRUE;

        case BTI_GET_DATA_TEST:
        TRACE_EVENT("BTI_GET_DATA_TEST");
        {
            UBYTE buf[2048];
            memset(buf, 0, 2048);
            memcpy(buf, ((T_BTI_GET_DATA_TEST *)data)->ind_data, ((T_BTI_GET_DATA_TEST *)data)->len);

            bti_simulate_data_bt_to_gsm(((T_BTI_GET_DATA_TEST *)data)->port_nb, ((T_BTI_GET_DATA_TEST *)data)->len, buf);
        }
        return TRUE;
/* for test bluetooth without BMI/MMI ******************************************/
        case BTP_SRV_SYNC_TEST:/* test SYNC profile */
        TRACE_EVENT("bta_response_cb:BTP_SRV_SYNC_TEST");
        switch(((T_BTP_SRV_SYNC_TEST *)data)->func_id)
        {
          case 1:/* start bluetooth primitive SYN_SERVER_SYNC_COMPLETE */
            bti_syn_server_sync_compl();
            break;
          case 2: /* start bluetooth function syn_server_sync_termination() */
            service = MFW_BT_SYNC;
            subtyp = MFW_BT_SERVER;
            if(bt_syn_s_sync_terminate(service, subtyp) NEQ MFW_BT_OK)
            {
              TRACE_EVENT("mfw_bta:sync termination Failure");
            }
            else
              TRACE_E