示例#1
0
/****************************************************************************
NAME    
    audioIndicateCodec
    
DESCRIPTION
    Sends an event to indicate which A2DP codec is in use

RETURNS
    void
*/
void audioIndicateCodec(uint8 seid)
{
    switch(seid)
    {
        case SBC_SEID:
            MessageSend ( &theSink.task , EventSbcCodec , 0 ) ;
            break;
        case MP3_SEID:
            MessageSend ( &theSink.task , EventMp3Codec , 0 ) ;
            break;        
        case AAC_SEID:
            MessageSend ( &theSink.task , EventAacCodec , 0 ) ;
            break;  
        case APTX_SEID:
            MessageSend ( &theSink.task , EventAptxCodec , 0 ) ;
            break;  
#ifdef INCLUDE_FASTSTREAM            
        case FASTSTREAM_SEID:
            MessageSend ( &theSink.task , EventFaststreamCodec , 0 ) ;
            break;  
#endif
#ifdef INCLUDE_APTX_ACL_SPRINT            
        case APTX_SPRINT_SEID:
            MessageSend ( &theSink.task , EventAptxLLCodec , 0 ) ;
            break;              
#endif            
        default:
           AUD_DEBUG(("AUD: Unknown codec\n"));                 
    }
}
/****************************************************************************
NAME
    connectionSmInit

DESCRIPTION
    This Function is called to initialise SM. The config option is not 
    currently used but may be in future.

RETURNS
    Nothing.
*/
void connectionSmInit(cl_dm_bt_version version, connectionSmState *smState, uint8 flags)
{
    MAKE_CL_MESSAGE(CL_INTERNAL_SM_INIT_REQ);

    message->options            =  DM_SM_INIT_SECURITY_MODE | 
                                   DM_SM_INIT_MODE3_ENC;
    
    message->config             =  0;
    
    if(version >= bluetooth4_1 && (flags & CONNECTION_FLAG_SC_ENABLE))
    {
        message->options        |= DM_SM_INIT_SECURE_CONNECTIONS;

        if(flags & CONNECTION_FLAG_SCOM_ENABLE)
        {
            message->config         |=  DM_SM_SEC_MODE_CONFIG_SC_ONLY_MODE;
            message->options        |=  DM_SM_INIT_CONFIG;
        }
    }

    message->write_auth_enable  =  cl_sm_wae_acl_owner_none;

    if(version >= bluetooth2_1)
    {
        message->options            |=  DM_SM_INIT_WRITE_AUTH_ENABLE;

        message->security_mode      =   sec_mode4_ssp;
        message->mode3_enc          =   hci_enc_mode_pt_to_pt_and_bcast;

    }
    else if (version == bluetooth2_0)
    {
        /* As per the documentation for DM_SM_INIT_REQ_T in dm_prim.h
         * write auth enable applies to security mode 2.
         * mode3 encryption doesn't apply in this mode.
         * No clue why mode 3 encryption is enabled.
         */
        message->options            |=  DM_SM_INIT_WRITE_AUTH_ENABLE;
        message->security_mode      =   sec_mode2_service;
        message->mode3_enc          =   hci_enc_mode_pt_to_pt;
    }    
    else
    {
        message->security_mode      =   sec_mode2_service;
        message->mode3_enc          =   hci_enc_mode_pt_to_pt;
    }

    smState->security_mode = message->security_mode;
    smState->enc_mode = message->mode3_enc;
    
    MessageSend(connectionGetCmTask(), CL_INTERNAL_SM_INIT_REQ, message);
}
示例#3
0
/****************************************************************************
*NAME 
*   AvrcpBrowseGetFolderItemsResponse
*
*DESCRIPTION
*   This function is used to send response for  GetFolderItems command to CT.
*   This will be called in response to a AVRCP_BROWSE_GET_FOLDER_ITEMS_IND
*   message.
*
*PARAMETRS
*   avrcp              - Task
*   avrcp_response_type- response. avrcp_response_browsing_success on Success.
*   uint16             - UID Counter. 0 for non database aware players
*   uint16             - number of items returned
*   uint16             - size of the item list in bytes
*   Source             - item list
*****************************************************************************/
void AvrcpBrowseGetFolderItemsResponse( AVRCP*              avrcp,         
                                        avrcp_response_type response,     
                                        uint16              uid_counter, 
                                        uint16              num_items,  
                                        uint16              item_list_size,
                                        Source              item_list)
{
    AVBP *avbp = (AVBP*)avrcp->avbp_task;

    if((SourceBoundary(item_list) < item_list_size) ||
       (!num_items && item_list_size) || 
       (item_list_size > (avbp->avbp_mtu - AVBP_MAX_FIXED_PDU_SIZE)))
    {
        AVRCP_DEBUG(("Wrong parameters\n"));
        if(item_list)
        {
            SourceEmpty(item_list);
        }
        return; 
    }
     
    if((isAvbpCheckConnected(avbp)) && 
      (avbp->blocking_cmd == AVBP_GET_FOLDER_ITEMS_PDU_ID))
    {
        MAKE_AVRCP_MESSAGE(AVRCP_INTERNAL_GET_FOLDER_ITEMS_RES);
        message->response = response;
        message->num_items = num_items;
        message->item_list_size = item_list_size;
        message->item_list = item_list;
        if(isAvrcpDatabaseEnabled(avrcpGetDeviceTask()))
        {
           message->uid_counter = uid_counter;
        }
        else
        {
           message->uid_counter = 0;
        }

        /* Queue the Response */
        MessageSend(&avbp->task,
                    AVRCP_INTERNAL_GET_FOLDER_ITEMS_RES,
                    message);
    }
    else
    {
        AVRCP_INFO(("Wrong State. Ignoring the response\n"));
        if(item_list)
        {
            SourceEmpty(item_list);
        }
    }
}
示例#4
0
void ML::MsgLoopReqSend(PS_MlRequestType pLoop_Type)
{
    S_MaintenanceLoopRequest   maintenanceLoopRequest ;
    S_H245Msg                  h245Msg ;

    oscl_memcpy((int8*)&maintenanceLoopRequest.mlRequestType, (int8*)pLoop_Type, sizeof(S_MlRequestType)) ;

    h245Msg.Type1 = H245_MSG_REQ ;
    h245Msg.Type2 = MSGTYP_ML_REQ ;
    h245Msg.pData = (uint8*) & maintenanceLoopRequest ;

    MessageSend(&h245Msg) ;
}
void avrcpSendGetCapsResponse(AVRCP *avrcp, 
                            avrcp_response_type response, 
                            avrcp_capability_id caps, 
                            uint16 size_caps_list, 
                            Source caps_list)
{
    MAKE_AVRCP_MESSAGE(AVRCP_INTERNAL_GET_CAPS_RES);
    message->caps_id = caps;        
    message->response = response;        
    message->size_caps_list = size_caps_list;
    message->caps_list = caps_list;
    MessageSend(&avrcp->task, AVRCP_INTERNAL_GET_CAPS_RES, message);
}
/* Send the indicator list to the app so it can parse it for any non-HFP indicators it is interested in */
static void hfpSendUnhandledIndicatorListToApp(hfp_link_data* link, uint16 register_index, uint16 cind_index, uint16 min_range, uint16 max_range)
{
    MAKE_HFP_MESSAGE(HFP_EXTRA_INDICATOR_INDEX_IND);
    message->priority = hfpGetLinkPriority(link);
    message->indicator_register_index = register_index;
    message->indicator_index = cind_index;
    message->min_range = min_range;
    message->max_range = max_range;
    MessageSend(theHfp->clientTask, HFP_EXTRA_INDICATOR_INDEX_IND, message);
    
    /* Store the extra indicator index internally */
    hfpStoreUnhandledIndicator(link, cind_index);
}
示例#7
0
void a2dpSendInitCfmToClient(a2dp_status_code status)
{
    MAKE_A2DP_MESSAGE(A2DP_INIT_CFM);
    message->status = status;
    MessageSend(a2dp->clientTask, A2DP_INIT_CFM, message);

    /* If the initialisation failed, free the allocated task */
    if (status != a2dp_success)
    {
        free(a2dp);
        a2dp = 0;
    }
}
示例#8
0
/****************************************************************************
NAME    
    batteryNormal
    
DESCRIPTION
    Called when the battery voltage is detected to be in a Normal state
*/
static void powerManagerHandleVbatNormal(uint8 level)
{
#ifndef NO_LED     
    bool low_batt = powerManagerIsVbatLow();
#endif    
    PM_DEBUG(("PM: Battery Normal %d\n", level));
    MessageSend(&theSink.task, EventSysBatteryOk, 0);
    
    /* If charger connected send a charger gas gauge message (these don't have any functional use but can be associated with LEDs/tones) */
    if (powerManagerIsChargerConnected())
        MessageSend(&theSink.task, (EventSysChargerGasGauge0+level), 0);
    
    /* reset any low battery warning that may be in place */
    theSink.battery_state = POWER_BATT_LEVEL0 + level;
    csr2csrHandleAgBatteryRequestRes(level);
#ifndef NO_LED 
    /* when changing from low battery state to a normal state, refresh the led state pattern
       to replace the low battery pattern should it have been shown */
    if(low_batt) LEDManagerIndicateState(stateManagerGetState());
#endif    
    AudioSetPower(powerManagerGetLBIPM());
}
void ConnectionAuthGetPriorityDeviceStatusTestExtra(
        Task theAppTask,
        const bdaddr* bd_addr, 
        bool *is_priority_device
        )
{
    CL_AUTH_GET_PRIORITY_DEVICE_STATUS_IND_TEST_EXTRA_T *new_msg = 
                    PanicUnlessMalloc(sizeof(CL_AUTH_GET_PRIORITY_DEVICE_STATUS_IND_TEST_EXTRA_T));

    new_msg->result = ConnectionAuthGetPriorityDeviceStatus(bd_addr, &(new_msg->is_priority_device));

    MessageSend(theAppTask, CL_AUTH_GET_PRIORITY_DEVICE_STATUS_IND_TEST_EXTRA, new_msg);
}
示例#10
0
/* 
 *  B-134381
 */
void ConnectionAuthSetPriorityDeviceTestExtra(
        Task theAppTask,
        const bdaddr *bd_addr,
        bool is_priority_device
        )
{
    CL_AUTH_SET_PRIORITY_DEVICE_IND_TEST_EXTRA_T *new_msg = 
                    PanicUnlessMalloc(sizeof(CL_AUTH_SET_PRIORITY_DEVICE_IND_TEST_EXTRA_T));

    new_msg->result = ConnectionAuthSetPriorityDevice(bd_addr, is_priority_device);

    MessageSend(theAppTask, CL_AUTH_SET_PRIORITY_DEVICE_IND_TEST_EXTRA, new_msg);
}
示例#11
0
void ConnectionRfcommPortNegResponse(Task appTask, Sink sink, port_par* port_params)
{
    MAKE_CL_MESSAGE(CL_INTERNAL_RFCOMM_PORTNEG_RSP);
    message->theAppTask = appTask;
    message->sink = sink;

    if (port_params)
        message->port_params = *port_params;
    else
        initPortParams(&(message->port_params));

    MessageSend(connectionGetCmTask(), CL_INTERNAL_RFCOMM_PORTNEG_RSP, message);
}
示例#12
0
void ML::MsgLoopOffSend(void)
{
    S_MaintenanceLoopOffCommand    maintenanceLoopOffCommand ;
    S_H245Msg                      h245Msg ;

    oscl_memset(&maintenanceLoopOffCommand, 0, sizeof(S_MaintenanceLoopOffCommand)) ;

    h245Msg.Type1 = H245_MSG_CMD ;
    h245Msg.Type2 = MSGTYP_ML_OFF_CMD ;
    h245Msg.pData = (uint8*) & maintenanceLoopOffCommand ;

    MessageSend(&h245Msg) ;
}
示例#13
0
void ConnectionRfcommConnectResponse(Task theAppTask, bool response, const Sink sink, uint8 local_server_channel, const rfcomm_config_params *config)
{
    /* Send an internal message */
    MAKE_CL_MESSAGE(CL_INTERNAL_RFCOMM_CONNECT_RES);
    message->theAppTask = theAppTask;
    message->response = response;
    message->sink = sink;
    message->server_channel = local_server_channel;
    
    initConfigParams(config, &message->config);
    
    MessageSend(connectionGetCmTask(), CL_INTERNAL_RFCOMM_CONNECT_RES, message);
}
static void sendSppStartServiceCfm(spp_start_status status)
{
    if (sppsClientTask)
    {
        MAKE_SPP_MESSAGE(SPP_START_SERVICE_CFM);
        message->status = status;
        MessageSend(sppsClientTask, SPP_START_SERVICE_CFM, message);
    }
#if SPP_DEBUG_LIB
    else
        SPP_DEBUG(("sppsClientTask is NULL!\n"));
#endif
}
static void sendSppStopServiceCfm(Task theClientTask, spp_stop_status status)
{
    if (theClientTask)
    {
        MAKE_SPP_MESSAGE(SPP_STOP_SERVICE_CFM);
        message->status = status;
        MessageSend(theClientTask, SPP_STOP_SERVICE_CFM, message);
    }
#if SPP_DEBUG_LIB
    else
        SPP_DEBUG(("theClientTask is NULL!\n"));
#endif
}
void sendGetValueTextResponse(AVRCP *avrcp,
                             avrcp_response_type response, 
                             uint16 number_of_values, 
                             uint16 size_values, 
                             Source values)
{
    MAKE_AVRCP_MESSAGE(AVRCP_INTERNAL_GET_APP_VALUE_TEXT_RES);
    message->response = response;
    message->number_of_values = number_of_values;
    message->size_values_list = size_values;
    message->values_list = values;
    MessageSend(&avrcp->task, AVRCP_INTERNAL_GET_APP_VALUE_TEXT_RES, message);
}
void sendPlayStatusResponse(AVRCP *avrcp,
                            avrcp_response_type response, 
                            uint32 song_length, 
                            uint32 song_elapsed, 
                            avrcp_play_status play_status)
{
    MAKE_AVRCP_MESSAGE(AVRCP_INTERNAL_GET_PLAY_STATUS_RES);
    message->response = response;
    message->song_length = song_length;
    message->song_elapsed = song_elapsed;
    message->play_status = play_status;
    MessageSend(&avrcp->task, AVRCP_INTERNAL_GET_PLAY_STATUS_RES, message);
}
示例#18
0
/****************************************************************************
NAME 
	hidDisconnectingRemoteExit
DESCRIPTION
	Called whenever the HID instance exits the remote disconnecting state.
	Sends a HID_DISCONNECT_IND message to the applications and stops the
	disconnect timer.
RETURNS
	void
*/
static void hidDisconnectingRemoteExit(HID *hid)
{
    MAKE_HID_MESSAGE(HID_DISCONNECT_IND);
	HID_PRINT(("hidDisconnectingRemoteExit\n"));

	/* Send HID_DISCONNECT_IND to application */
	message->hid = hid;
    message->status = hid->disconnect_status;
    MessageSend(hid->app_task, HID_DISCONNECT_IND, message);

	/* Stop disconnect timer */
    MessageCancelAll(&hid->task, HID_INTERNAL_DISCONNECT_TIMEOUT_IND);
}
static void sendUnhandledIndicatorToApp(hfp_link_data* link, uint16 index, uint16 value)
{
    /*
        We have received an indicator not defined by the HFP spec. Pass it 
        up to the application as it might want to make use of these extra
        indicators that some AGs send out.
    */
    MAKE_HFP_MESSAGE(HFP_EXTRA_INDICATOR_UPDATE_IND);
    message->priority = hfpGetLinkPriority(link);
    message->index = index;
    message->value = value;
    MessageSend(theHfp->clientTask, HFP_EXTRA_INDICATOR_UPDATE_IND, message);
}
示例#20
0
void ConnectionRegisterServiceRecord(Task appTask, uint16 num_rec_bytes, const uint8 *service_record)
{
	/* Check some record has been supplied */
	if((num_rec_bytes == 0) || (service_record == NULL))
	{
		/* Return Failure if there is no service record passed */
		MAKE_CL_MESSAGE(CL_SDP_REGISTER_CFM);
		message->status = fail;
		message->service_handle = 0;
		MessageSend(appTask, CL_SDP_REGISTER_CFM, message);
        
	}
	else
	{
		/* Send an internal message to the state machine */
		MAKE_CL_MESSAGE(CL_INTERNAL_SDP_REGISTER_RECORD_REQ);
		message->theAppTask = appTask;
		message->record_length = num_rec_bytes;
			message->record = (uint8 *) service_record;
		MessageSend(connectionGetCmTask(), CL_INTERNAL_SDP_REGISTER_RECORD_REQ, message);
	}
}
/****************************************************************************
NAME
    sendReliableWriteExecuteCfm

DESCRIPTION
    Send the GATT_RELIABLE_WRITE_EXECUTE_CFM message.

RETURNS

*/
static void sendReliableWriteExecuteCfm(Task task,
                                        uint16 cid,
                                        uint16 handle, 
                                        gatt_status_t status)
{
    MAKE_GATT_MESSAGE(GATT_RELIABLE_WRITE_EXECUTE_CFM);

    message->cid = cid;
    message->handle = handle;
    message->status = gatt_message_status(status);

    MessageSend(task, GATT_RELIABLE_WRITE_EXECUTE_CFM, message);
}
示例#22
0
/****************************************************************************
NAME
    sendErrorToClient

DESCRIPTION
    Helper function to send the error message to the client task
*/
static void sendErrorToClient(void)
{
    /* Build the plugin error message to let the application know something serious in the plugin has failed */
    AUDIO_PLUGIN_DSP_IND_T * message = PanicUnlessNew(AUDIO_PLUGIN_DSP_IND_T);
    message->id = SUB_PLUGIN_FATAL_ERROR;
    message->size_value = 1;
    message->value[0] = 0;
    
    /* Ensure all streams have been disconnected and DSP turned off before sending error (also free's all memory used by the plugin to prevent memory leak) */
    CsrSubwooferPluginDisconnect();
    
    MessageSend(plugin_data->app_task, AUDIO_PLUGIN_DSP_IND, message);
}
/****************************************************************************
* NAME    
*   avrcpHandleGetElementAttributesCommand    
*
* DESCRIPTION
*   Handle the incoming Get Element Attributes command
* 
* PARAMETERS
*   avrcp       - AVRCP Instance
*   ptr         - Pointer to the data packet
*   packet_size - Packet size
*******************************************************************************/
void avrcpHandleGetElementAttributesCommand(AVRCP       *avrcp,
                                        const uint8     *ptr, 
                                        uint16          packet_size)
{
    uint16 data_offset=9;
    uint32 identifier_high = 0, identifier_low = 0;
    uint8 attribute_count=0;
    Source source=0;
    
   if(packet_size >= AVRCP_GET_ELEMENTS_HDR_SIZE)
   {
        data_offset=9;
        identifier_high = convertUint8ValuesToUint32(&ptr[0]);
        identifier_low = convertUint8ValuesToUint32(&ptr[4]);
        attribute_count= ptr[8];
        packet_size -= data_offset;

        if(packet_size)
        {
            if(!(source=avrcpSourceFromConstData(avrcp, 
                                            ptr+data_offset, 
                                            packet_size)))
            {
                packet_size = 0;
            }
        }
    }


   {
    MAKE_AVRCP_MESSAGE(AVRCP_GET_ELEMENT_ATTRIBUTES_IND);

    message->avrcp = avrcp;
    message->identifier_high = identifier_high;
    message->identifier_low = identifier_low;
    message->number_of_attributes = attribute_count;
    message->size_attributes = packet_size;
    message->attributes = source;

#ifdef AVRCP_ENABLE_DEPRECATED 
    /* Deprecated fields will be removed later */
    message->metadata_packet_type = avrcp_packet_type_single;
    message->transaction =  avrcp->rsp_transaction_label;
    message->no_packets = 1;
    message->ctp_packet_type = AVCTP0_PACKET_TYPE_SINGLE;
    message->data_offset = 0;
#endif 

    MessageSend(avrcp->clientTask, AVRCP_GET_ELEMENT_ATTRIBUTES_IND, message);
   }
}
示例#24
0
文件: sink_mapc.c 项目: jrryu/HW--FW
/****************************************************************************
NAME	
	handleMapcMnsConnectCfm
    
DESCRIPTION
    handle after receiving MAPC_MNS_CONNECT_CFM_T
    
PARAMS
    pMessage    message
    
RETURNS
	void
*/
static void handleMapcMnsConnectCfm(MAPC_MNS_CONNECT_CFM_T* pMsg)
{
    mapc_link_priority device_id = mapcGetLinkFromBdAddr( &pMsg->addr );
    mapcState * state = NULL;

    /* ensure device_id has been correctly retrieved */
    if(device_id != mapc_invalid_link)
        state = &(theSink.rundata->mapc_data.state[device_id]);
            
    MAPC_DEBUG(("MAPC:MAPC_MNS_CONNECT_CFM:"));
        
    if(pMsg->status == mapc_pending)
    {
        MAPC_DEBUG(("Connection Pending. channel = %x \n", pMsg->mnsChannel));
        if(state)        
            state->mnsHandle     = pMsg->mnsSession;
    }
    else if(pMsg->status == mapc_success)
    {
        MAPC_DEBUG(("Connection Successfull \n"));
        
        if(state)        
        {
            state->mnsHandle     = pMsg->mnsSession;
            state->mnsChannel    = pMsg->mnsChannel;
        
            /* Send an message to indicate the mns service connection success */
            MessageSend(&theSink.task, EventSysMapcMnsSuccess, 0);
        }        
    }
    else
    {
        MAPC_DEBUG(("MnS Connection Failed\n"));
        
        /* Send an message to indicate the mns service connection success */
        MessageSend(&theSink.task, EventSysMapcMnsFailed, 0);
    }
}
示例#25
0
/****************************************************************************
NAME	
	connectionHandleSdpUnregisterCfm

DESCRIPTION
	Handle the response from BlueStack to an SDP unregister request

RETURNS
	void	
*/
void connectionHandleSdpUnregisterCfm(connectionSdpState *state, const SDS_UNREGISTER_CFM_T *cfm)
{
    if (state->sdpLock)
    {
        /* Send response to the client */
        MAKE_CL_MESSAGE(CL_SDP_UNREGISTER_CFM);
        message->status = (connection_lib_status) cfm->result;
        message->service_handle = cfm->svc_rec_hndl;
        MessageSend(state->sdpLock, CL_SDP_UNREGISTER_CFM, message);
        
        /* Reset the resource lock */
        state->sdpLock = 0;
    }
}
void aghfpHandleChldParse(Task task, const struct aghfpHandleChldParse *data)
{
	MAKE_AGHFP_MESSAGE(AGHFP_INTERNAL_CALL_HOLD_REQ);
    message->action = (uint16)(*data->cmd.data - '0');
    if ( data->cmd.length>1 )
    {
        (void)UtilGetNumber(data->cmd.data+1,data->cmd.data+data->cmd.length-1, &message->index);
    }
    else
    {
        message->index = 0;
    }
    MessageSend(task, AGHFP_INTERNAL_CALL_HOLD_REQ, message);
}
示例#27
0
文件: tzcmrptd.c 项目: arksoftgit/10c
static zSHORT
zwfnTZCMRPTD_LoadNewAudittrail( zVIEW vSubtask, zPVIEW vTZBRAU2O )
{
   zVIEW    vTZCMCPL;
   zVIEW    vKZDBHQUA;
   zULONG   ulZKey;
   zCHAR    szZKey[18];
   zSHORT   nRC;

   if ( GetViewByName( &vTZCMCPL, "TZCMCPL", vSubtask, zLEVEL_TASK ) < 0 )
      return( -1 );

   if ( CheckExistenceOfEntity( vTZCMCPL, "CPLR" ) == zCURSOR_SET )
   {

      if ( ActivateEmptyObjectInstance( &vKZDBHQUA, "KZDBHQUA", vSubtask,
                                        zSINGLE ) >= 0 )
      {
         SetNameForView( vKZDBHQUA, "KZDBHQUA", vSubtask, zLEVEL_TASK );
         CreateEntity( vKZDBHQUA, "EntitySpec", zPOS_AFTER );
         CreateEntity( vKZDBHQUA, "QualAttrib", zPOS_AFTER );
      }
      else
         return( -1 );

      GetIntegerFromAttribute( (zPLONG)&ulZKey, vTZCMCPL, "CPLR", "ZKey" );
      SetAttributeFromString( vKZDBHQUA, "EntitySpec", "EntityName", "CPLR" );
      SetAttributeFromString( vKZDBHQUA, "QualAttrib", "EntityName", "CPLR" );
      SetAttributeFromString( vKZDBHQUA, "QualAttrib", "AttributeName", "ZKey" );
      SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Oper", "=" );
      zltoa( ulZKey, szZKey );
      SetAttributeFromString( vKZDBHQUA, "QualAttrib", "Value", szZKey );


      nRC = ActivateObjectInstance( vTZBRAU2O, "TZBRAU2O", vSubtask,
                                    vKZDBHQUA, zSINGLE | zLEVEL_APPLICATION );
      DropObjectInstance( vKZDBHQUA );
      SetNameForView( *vTZBRAU2O, "TZBRAU2O", vSubtask, zLEVEL_TASK );
   }
   else
   {
      MessageSend( vSubtask, "CM00299", "Audit Trail:",
                   "There are no Audit Trail Information for a non-repository LPLR.",
                   zMSGQ_OBJECT_CONSTRAINT_WARNING, zBEEP );
      SetWindowActionBehavior( vSubtask, zWAB_StayOnWindow, 0, 0 );
      return( -1 );
   }

   return( 0 );
} // zwfnTZCMRPTD_LoadNewAudittrail
示例#28
0
/****************************************************************************
NAME	
	HfpVoiceRecognitionEnable

DESCRIPTION
	Enable / disable voice recognition function at the AG. An SLC for the 
	supplied profile instance (hfp) must already be established before calling 
	this function. The enable flag determines whether a request will be made 
	to the AG to enabe or disable its voice recognition function. The message 
	returned indicates whether the command was recognised by the AG or not. 
	
	The AG may autonomously notify the HFP device of a change in the state of
	its voice recognition function. This notification will be passed on to the 
	application using a HFP_VOICE_RECOGNITION_IND message.

MESSAGE RETURNED
	HFP_VOICE_RECOGNITION_ENABLE_CFM

RETURNS
	void
*/
void HfpVoiceRecognitionEnable(HFP *hfp, bool enable)
{
#ifdef HFP_DEBUG_LIB
	if (!hfp)
		HFP_DEBUG(("Null hfp task ptr passed in.\n"));
#endif

	{
		/* Send an internal message to kick off SLC creation */
		MAKE_HFP_MESSAGE(HFP_INTERNAL_AT_BVRA_REQ);
		message->enable = enable;
		MessageSend(&hfp->task, HFP_INTERNAL_AT_BVRA_REQ, message);
	}
}
示例#29
0
static void adc_result_handler(vm_adc_source_type source, uint8 reading) {
	
	bool vref_first_update = FALSE;
	
	if (source == VM_ADC_SRC_VREF) {
		
		if (battery_probe.vref_reading == 255) {
			
			vref_first_update = TRUE;
		}
		
		battery_probe.vref_reading = reading;
	}
	else if (source == battery_probe.source) {
		
		battery_probe.source_reading = reading;
	}
	else {
		
		/** should not happen, but if it happens, we should not panic **/
		
		return;
	}
	
	/*******************
	  
	  condition 1: both reading must be valid
	  contition 2: either this is a source update or it is the vref update for the first time, that is, only first time vref update, we throw the message
	  
	  ******************/
	if ((battery_probe.source_reading != 255) && (battery_probe.vref_reading != 255) &&
		((source == battery_probe.source) || (source == VM_ADC_SRC_VREF && vref_first_update == TRUE))) {
		
		/** to avoid integer overflow **/
		unsigned long src, vref;
		uint32* mV;
		
		src = battery_probe.source_reading;
		vref = battery_probe.vref_reading;
		
		if (vref == 0) { /** to avoid division overflow **/
			return;
		}
		
		mV = (uint32*)malloc(sizeof(uint32));
		*mV = 1250UL * src / vref;
		
		MessageSend(battery_probe.client, BATTERY_PROBING_MESSAGE, mV);
	}
}
示例#30
0
void ConnectionL2capConnectResponse(Task appTask, bool response, uint16 psm, uint16 connection_id, uint8 identifier, uint16 conftab_length, uint16* conftab)
{
	/* Send an internal message */
	MAKE_CL_MESSAGE(CL_INTERNAL_L2CAP_CONNECT_RES);
	message->theAppTask = appTask;
	message->response = response;
    message->identifier = identifier;
	message->psm_local = psm;
	message->connection_id = connection_id;
    message->length = conftab_length;
    message->data = conftab;

	MessageSend(connectionGetCmTask(), CL_INTERNAL_L2CAP_CONNECT_RES, message);
}