コード例 #1
0
ファイル: sink_mapc.c プロジェクト: jrryu/HW--FW
/****************************************************************************
NAME	
	handleMapcMnsStartCfm
    
DESCRIPTION
    confirmation of start of the message notification service
    
PARAMS
    pMessage    message
    
RETURNS
	void
*/
static void handleMapcMnsStartCfm(MAPC_MNS_START_CFM_T* pMsg)
{
    MAPC_DEBUG(("MAPC:MAPC_MNS_START_CFM- status:[%d] -- ", pMsg->status));
    
    /* if the notification service started succesfully, store its details which
       are not stored by the MAP library */
    if(pMsg->status == mapc_success)
    {
        MAPC_DEBUG(("MAPC:success. channel = %x, handle = %ld \n", pMsg->mnsChannel, pMsg->sdpHandle));

        /* store server channel and handle values */
        theSink.rundata->mapc_data.mnsChannel = pMsg->mnsChannel;
        theSink.rundata->mapc_data.sdpHandle  = pMsg->sdpHandle;

        /* set link encryption requirements */
        ConnectionSmSetSdpSecurityIn(TRUE);
        ConnectionSmRegisterIncomingService(protocol_rfcomm, pMsg->mnsChannel, sec4_in_level_2 ); 
    }
    else
    {
        MAPC_DEBUG(("MAPC:MAPC Mns start fails\n"));
    }
}
コード例 #2
0
ファイル: BtTask.c プロジェクト: flaksirus/SkiHeater
/* Task handler function */
void BtTaskHandler(Task task, MessageId id, Message message)
{
    sppDevState state = btApp.spp_state;
    
    switch(id)
    {
    case CL_INIT_CFM:
        DEBUG(("CL_INIT_CFM\n"));
        if(((CL_INIT_CFM_T*)message)->status == success)
        {
            /* Connection Library initialisation was a success */
            /*sppDevInit();   */
            spp_init_params init;

            init.client_recipe = 0;
            init.size_service_record = 0;
	        init.service_record = 0;
	        init.no_service_record = 0;
	
            /* Initialise the spp profile lib, stating that this is device B */ 
            SppInitLazy(&btApp.task, &btApp.task, &init);
        }
        /*else
            Some reset function*/
        break;
    case CL_DM_LINK_SUPERVISION_TIMEOUT_IND:
        DEBUG(("CL_DM_LINK_SUPERVISION_TIMEOUT_IND\n"));
        break;
    case CL_DM_SNIFF_SUB_RATING_IND:
        DEBUG(("CL_DM_SNIFF_SUB_RATING_IND\n"));
        break;
    case SPP_INIT_CFM:
        DEBUG(("SPP_INIT_CFM\n"));
        switch(state)
        {
        case sppDevInitialising:
            /* Check for spp_init_success. What do we do if it failed? */
            if (((SPP_INIT_CFM_T *) message)->status == spp_init_success)
            {
                setSppState(sppDevReady);
                /* Turn off security */
                ConnectionSmRegisterIncomingService(0x0000, 0x0001, 0x0000);
                /* Write class of device */
                ConnectionWriteClassOfDevice(0x1F00);
                /* Start Inquiry mode */
                setSppState(sppDevPairable);
                /* Set devB device to inquiry scan mode, waiting for discovery */
                ConnectionWriteInquiryscanActivity(0x400, 0x200);
                ConnectionSmSetSdpSecurityIn(TRUE);
                /* Make this device discoverable (inquiry scan), and connectable (page scan) */
                ConnectionWriteScanEnable(hci_scan_enable_inq_and_page);
            }
            break;
        case sppDevReady:
        case sppDevPairable:
        case sppDevConnecting:
        case sppDevConnected:
        default:
            DEBUG(("SPP_INIT_CFM unhandled: state = %d, id = %d\n", state, id));
            break;
        }
        break;
    case SPP_CONNECT_CFM:
        {        
            SPP_CONNECT_CFM_T *cfm = (SPP_CONNECT_CFM_T *) message;
            DEBUG(("SPP_CONNECT_CFM result = %d\n", cfm->status));
            switch(state)
            {   
            case sppDevConnecting:
                /* Connect cfm, but must check status as connection may have failed */
                if (cfm->status == rfcomm_connect_success)
                {
                    /* Connection Success */
                    DEBUG(("Device connected...\n"));
                    /* Connect Uart to Rfcomm */
                    /*(void) StreamConnect(StreamUartSource(), cfm->sink);
                    (void) StreamConnect(StreamSourceFromSink(cfm->sink), StreamUartSink());*/
					/* (void) StreamConnectDispose(StreamSourceFromSink(cfm->sink)); */
                    
                    btApp.spp = cfm->spp;                    
                    btApp.sink = cfm->sink;
                    setSppState(sppDevConnected);
                    ConnectionWriteScanEnable(hci_scan_enable_off);
                }
                else
                {
                    /* Connection failed */
                    setSppState(sppDevPairable);
                    DEBUG(("Connection failed\n"));
                }
                break;
            case sppDevPairable:
                /* Connect cfm, but must check status as connection may have failed */
                if (cfm->status == rfcomm_connect_success)
                {
                    /* Device has been reset to pairable mode. Disconnect from current device */
                    SppDisconnect(cfm->spp);
                }
                break;
            case sppDevInitialising:
            case sppDevReady:
            case sppDevConnected:
            default:
                DEBUG(("SPP_CONNECT_CFM unhandled: state = %d, id = %d\n", state, id));
                break;
            }
        }
        break;
    case SPP_CONNECT_IND:
        {
            DEBUG(("SPP_CONNECT_IND\n"));        
            /*CAST_TYPED_MSG(SPP_CONNECT_IND, ind, message);*/
            switch(state)
            {   
            case sppDevPairable:
                /* Received command that a device is trying to connect. Send response. */
                SppConnectResponseLazy(((SPP_CONNECT_IND_T*)message)->spp, TRUE, &((SPP_CONNECT_IND_T*)message)->addr, 1, FRAME_SIZE);
                /*sppDevAuthoriseConnectInd(btApp,(SPP_CONNECT_IND_T*)message);*/
                setSppState(sppDevConnecting);
                break;
            case sppDevInitialising:
            case sppDevConnecting:
            case sppDevReady:
            case sppDevConnected:
            default:
                DEBUG(("SPP_CONNECT_IND unhandled: state = %d, id = %d\n", state, id));
                break;
            }
        }
        break;
    case SPP_DISCONNECT_IND:
        DEBUG(("SPP_DISCONNECT_IND\n"));
        /* Disconnect message has arrived */
        switch(state)
        {
        case sppDevConnected:
            /* Turn off security */
            ConnectionSmRegisterIncomingService(0x0000, 0x0001, 0x0000);
            /* Write class of device */
            ConnectionWriteClassOfDevice(0x1F00);
            /* Start Inquiry mode */
            setSppState(sppDevPairable);
            /* Set devB device to inquiry scan mode, waiting for discovery */
            ConnectionWriteInquiryscanActivity(0x400, 0x200);
            ConnectionSmSetSdpSecurityIn(TRUE);
            /* Make this device discoverable (inquiry scan), and connectable (page scan) */
            ConnectionWriteScanEnable(hci_scan_enable_inq_and_page);
            break;
        case sppDevInitialising:
        case sppDevPairable:
        case sppDevConnecting:
        case sppDevReady:
        default:
            DEBUG(("SPP_DISCONNECT_IND unhandled: state = %d, id = %d\n", state, id));
            break;
        }
        break;      
    case CL_DM_ACL_OPENED_IND:
        DEBUG(("CL_DM_ACL_OPENED_IND\n"));
        break;
    case CL_DM_ACL_CLOSED_IND:
        DEBUG(("CL_DM_ACL_CLOSED_IND\n"));
        break;
    case CL_SM_PIN_CODE_IND:
        DEBUG(("CL_SM_PIN_CODE_IND\n"));
        ConnectionSmPinCodeResponse(&((CL_SM_PIN_CODE_IND_T*)message)->bd_addr, 4, (uint8*)"1234");
        /*sppDevHandlePinCodeRequest((CL_SM_PIN_CODE_IND_T *) message);*/
        break;
    case CL_SM_AUTHORISE_IND:  
        DEBUG(("CL_SM_PIN_CODE_IND\n"));
        /*sppDevAuthoriseResponse((CL_SM_AUTHORISE_IND_T*) message);*/
        ConnectionSmAuthoriseResponse(&((CL_SM_AUTHORISE_IND_T*)message)->bd_addr, 
                                          ((CL_SM_AUTHORISE_IND_T*)message)->protocol_id, 
                                          ((CL_SM_AUTHORISE_IND_T*)message)->channel, 
                                          ((CL_SM_AUTHORISE_IND_T*)message)->incoming, 
                                          TRUE);
        break;
    case CL_SM_AUTHENTICATE_CFM:
        DEBUG(("CL_SM_AUTHENTICATE_CFM\n"));
        /*sppDevSetTrustLevel((CL_SM_AUTHENTICATE_CFM_T*)message);   */
        /*CAST_TYPED_MSG(CL_SM_AUTHENTICATE_CFM, cfm, message);   */  
        if(((CL_SM_AUTHENTICATE_CFM_T*)message)->status == auth_status_success)
        {
            /* Pairing success, now set the trust level*/
            ConnectionSmSetTrustLevel(&((CL_SM_AUTHENTICATE_CFM_T*)message)->bd_addr, TRUE);
        }
        else if(((CL_SM_AUTHENTICATE_CFM_T*)message)->status == auth_status_fail)
        {
             DEBUG(("Pairing failed\n"));
        }
        break;
    case CL_SM_ENCRYPTION_KEY_REFRESH_IND:
        DEBUG(("CL_SM_ENCRYPTION_KEY_REFRESH_IND\n"));
        break;
    case CL_DM_LINK_POLICY_IND:
        DEBUG(("CL_DM_LINK_POLICY_IND\n"));
        break;
    case CL_SM_IO_CAPABILITY_REQ_IND:
        DEBUG(("CL_SM_IO_CAPABILITY_REQ_IND\n"));
        ConnectionSmIoCapabilityResponse( &btApp.bd_addr, 
                                          cl_sm_io_cap_no_input_no_output,
                                          FALSE,
                                          TRUE,
                                          FALSE,
                                          0,
                                          0 );
        break;
 
    case CL_SM_REMOTE_IO_CAPABILITY_IND:
        {
            CAST_TYPED_MSG(CL_SM_REMOTE_IO_CAPABILITY_IND, csricit, message);    

            DEBUG(("CL_SM_REMOTE_IO_CAPABILITY_REQ_IND\n"));
            
            DEBUG(("\t Remote Addr: nap %04x uap %02x lap %08lx\n",
                    csricit->bd_addr.nap,
                    csricit->bd_addr.uap,
                    csricit->bd_addr.lap ));
            btApp.bd_addr = csricit->bd_addr;
        }
        break;          
    case SPP_MESSAGE_MORE_DATA:
        DEBUG(("SPP_MESSAGE_MORE_DATA\n"));
        ParseSppData(task, ((SPP_MESSAGE_MORE_DATA_T*)message)->source);
        break;
    case SPP_MESSAGE_MORE_SPACE:
        DEBUG(("SPP_MESSAGE_MORE_SPACE\n"));
        break;
	/*case BUTTON_RESET_PRESS:
		DEBUG(("Button pressed\n"));
        switch(btApp.spp_state)
        {   
        case sppDevInitialising:
            return;
            break;
        case sppDevReady:
        case sppDevPairable:
        case sppDevConnecting:
            sppDevInquire(btApp);
            break;
        case sppDevConnected:
            SppDisconnect(btApp.spp);
            break;
        }
		break;*/
    case CL_RFCOMM_CONTROL_IND:
        DEBUG(("CL_RFCOMM_CONTROL_IND\n"));
        break;        
    default:
        /* An unexpected message has arrived - must handle it */
        DEBUG(("bt app - msg type  not yet handled 0x%x\n", id));
        break;
    }
}