C++ CCAPP_DEBUG函数代码示例

/**
 * gets the device name
 * @returns - a pointer to the device name
 */
cc_deviceinfo_ref_t CCAPI_DeviceInfo_getDeviceHandle () 
{
   static const char *fname="CCAPI_DeviceInfo_getDeviceHandle";
   CCAPP_DEBUG(DEB_F_PREFIX"Entering\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));
   CCAPP_DEBUG(DEB_F_PREFIX"returned 0 (default)\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));
   return 0;
}

/**
 *
 * CCApp Provider main routine.
 *
 * @param   arg - CCApp msg queue
 *
 * @return  void
 *
 * @pre     None
 */
void CCApp_task(void * arg)
{
    static const char fname[] = "CCApp_task";
    phn_syshdr_t   *syshdr = NULL;
    appListener *listener = NULL;
    void * msg;

    //initialize the listener list
    sll_lite_init(&sll_list);

    CCAppInit();

    while (1) {
        msg = cprGetMessage(ccapp_msgq, TRUE, (void **) &syshdr);
        if ( msg) {
#if DEBUG
            dump_msg("CCAPPTASKDUMPMSG", (unsigned int *)msg, syshdr->Len, syshdr->Cmd);
#else
            CCAPP_DEBUG(DEB_F_PREFIX"Received Cmd[%d] for app[%d]\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),
                    syshdr->Cmd, syshdr->Usr.UsrInfo);
#endif

            listener = getCcappListener(syshdr->Usr.UsrInfo);
            if (listener != NULL) {
                (* ((appListener)(listener)))(msg, syshdr->Cmd);
            } else {
                CCAPP_DEBUG(DEB_F_PREFIX"Event[%d] doesn't have a dedicated listener.\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),
                        syshdr->Usr.UsrInfo);
            }
            cprReleaseSysHeader(syshdr);
            cprReleaseBuffer(msg);
        }
    }
}

void ccsnap_gen_deviceEvent(ccapi_device_event_e event, cc_device_handle_t handle){
    const char* fname = "ccsnap_gen_deviceEvent";

    cc_device_info_t *device_info = CCAPI_Device_getDeviceInfo(handle);
    if ( device_info != NULL ) {
        CCAPP_DEBUG(DEB_F_PREFIX"data->ref_count=%d \n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->ref_count);

        switch (event) {
            case CCAPI_DEVICE_EV_NOTIFYPROMPT:
              CCAPP_DEBUG(DEB_F_PREFIX"data->not_prompt=%s \n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->not_prompt);
              CCAPP_DEBUG(DEB_F_PREFIX"data->not_prompt_prio=%d \n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->not_prompt_prio);
              CCAPP_DEBUG(DEB_F_PREFIX"data->not_prompt_prog=%d \n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->not_prompt_prog);
              break;
            case CCAPI_DEVICE_EV_STATE:
              CCAPP_DEBUG(DEB_F_PREFIX"setting property %s to %s\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), "FullyRegistered", ((device_info->ins_state == CC_STATE_INS) ? "1" : "0"));
              //intentional follow through to let the debugs get printed.
            default:
              CCAPP_DEBUG(DEB_F_PREFIX"data->name=%s \n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->name);
              CCAPP_DEBUG(DEB_F_PREFIX"data->mwi_lamp=%d \n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->mwi_lamp);
              CCAPP_DEBUG(DEB_F_PREFIX"data->ins_state=%02X \n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->ins_state);
              CCAPP_DEBUG(DEB_F_PREFIX"data->cucm_mode=%02X \n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->cucm_mode);
              CCAPP_DEBUG(DEB_F_PREFIX"data->ins_cause=%02X \n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->ins_cause);
              break;

        }

        CCAPI_DeviceListener_onDeviceEvent(event, handle, device_info);
    }
    CCAPI_Device_releaseDeviceInfo(device_info);
}

/**
 * Ask the platform to sync with versions got from call control
 * or outside entity.  As part of the sync, platform downloads
 * the files if required.
 *
 * @param   cfg_ver     - version stamp for config file
 * @param   dp_ver      - version stamp for the dialplan file
 * @param   softkey_ver - version stamp for the softkey file.
 *
 * @return  none
 */
void
platform_sync_cfg_vers (char *cfg_ver, char *dp_ver, char *softkey_ver)
{
    static const char fname[] = "platform_sync_cfg_vers";
    char empty_string[] = "";
    feature_update_t msg;

    if (cfg_ver == NULL) {
        cfg_ver = empty_string;
    }
    if (dp_ver == NULL) {
        dp_ver = empty_string;
    }
    if (softkey_ver == NULL) {
        softkey_ver = empty_string;
    }

    CCAPP_DEBUG(DEB_F_PREFIX"cfg_ver=%s dp_ver=%s sk_ver=%s\n", DEB_F_PREFIX_ARGS(PLAT_API, fname),
        cfg_ver, dp_ver, softkey_ver);

    msg.sessionType = SESSIONTYPE_CALLCONTROL;
    msg.featureID = DEVICE_SYNC_CONFIG_VERSION;
    msg.update.ccFeatUpd.data.cfg_ver_data.cfg_ver = strlib_malloc(cfg_ver, strlen(cfg_ver));
    msg.update.ccFeatUpd.data.cfg_ver_data.dp_ver = strlib_malloc(dp_ver, strlen(dp_ver));
    msg.update.ccFeatUpd.data.cfg_ver_data.softkey_ver = strlib_malloc(softkey_ver, strlen(softkey_ver));

    if ( ccappTaskPostMsg(CCAPP_FEATURE_UPDATE, &msg, sizeof(feature_update_t), CCAPP_CCPROVIER) != CPR_SUCCESS ) {
        CCAPP_DEBUG(DEB_F_PREFIX"failed to send platform_sync_cfg_vers msg \n",
                DEB_F_PREFIX_ARGS(PLAT_API, fname));
    }
}

/**
 * getStream Statistics
 * @param handle - call handle
 * @return stream stats
 */
cc_return_t  CCAPI_CallInfo_getStreamStatistics(cc_callinfo_ref_t handle, cc_int32_t stats[], cc_int32_t *count)
{
  static const char *fname="CCAPI_CallInfo_getStreamStatistics";
  CCAPP_DEBUG(DEB_F_PREFIX"Entering\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));
  CCAPP_DEBUG(DEB_F_PREFIX"returned CC_SUCCESS (default)\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));
 // todo
 return CC_SUCCESS;
}

/**
* Get Conference Participants
* @param [in] handle - call handle
* @param [in/out] participantHandles - array of participant handles to be returned
* @param [in/out] count - in:  size of array provided in participantHandles; out:  number of entries populated (up to original value provided)
* @return void
*/
void CCAPI_CallInfo_getConfParticipants (cc_callinfo_ref_t handle, cc_participant_ref_t participantHandles[], int* count)
{  
   cc_call_conference_ref_t              callConference   = NULL;    // conference reference (from call info)
   cc_call_conference_participant_ref_t  participant      = NULL;    // participant reference
   cc_uint16_t                           participantIndex = 0;       // participant index
   cc_uint16_t                           nodeCount        = 0;       // linked list node count

   CCAPP_DEBUG(DEB_F_PREFIX"Entering:  CCAPI_CallInfo_getConfParticipants\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF"));

   // get conference reference from the call info
   callConference = getCallConferenceRef(handle);
   if (callConference == NULL)
   {
      CCAPP_ERROR(DEB_F_PREFIX"Unable to get conference handle\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF"));
      *count = 0;
      return;
   }

   nodeCount = SLL_LITE_NODE_COUNT(&(callConference->currentParticipantsList));
   CCAPP_DEBUG(DEB_F_PREFIX"SLL NODE COUNT = [%d]\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF"), nodeCount);
   if (nodeCount <= 0)
   {      
      *count = 0;
      return;      
   }

   participant = (cc_call_conference_participant_ref_t)SLL_LITE_LINK_HEAD(&callConference->currentParticipantsList);
   while (participant != NULL)
   {
      if (participantIndex >= *count)
      {
          CCAPP_ERROR(DEB_F_PREFIX"Not Enough Room Provided To List All Participants.  Listed [%d] of [%d]\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF"), count, nodeCount);
          return;            
      }
      
      // add this participant to our list of particpiants
      participantHandles[participantIndex] = (participant->callid);
                
      // step to the next stored participant in the list
      participant = (cc_call_conference_participant_ref_t)SLL_LITE_LINK_NEXT_NODE(participant);
      participantIndex++;
   }

   // sanity check
   if (participantIndex != nodeCount)
   {  // did not find the expected number of participants!
       CCAPP_ERROR(DEB_F_PREFIX"Detected mismatch between counted participants [%d] and SLL returned nodecount [%d]\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF"),
                participantIndex, nodeCount);
       *count = 0;
       return;
   }
   
   // return number of participants
   *count = nodeCount;
   return;
}

/**
 * Get BLF state
 * @param feature - feature reference handle
 * @return cc_string_t - handle of the feature created
 */
cc_blf_state_t CCAPI_featureInfo_getBLFState(cc_featureinfo_ref_t feature) {
   static const char *fname="CCAPI_featureInfo_getBLFState";
   cc_feature_info_t  *info = (cc_feature_info_t  *)feature;
   CCAPP_DEBUG(DEB_F_PREFIX"Entering\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));

   if ( info != NULL ) {
       CCAPP_DEBUG(DEB_F_PREFIX"returned %d\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), info->blf_state);
       return info->blf_state;
   }
   return CC_SIP_BLF_UNKNOWN;
}

/*
 *  Function:    sub_hndlr_start
 *
 *  Description: does blf subscriptions upon registration.
 *
 *  Parameters: none.
 *
 *  Returns:   void
 */
void sub_hndlr_start()
{
    static const char fname[] = "sub_hndlr_start";
    int i;
    cc_uint32_t lineFeature = 0;
    cc_uint32_t featureOptionMask = 0;
    char speedDialNumber[MAX_LINE_NAME_SIZE] = {0};
    char primaryLine[MAX_LINE_NAME_SIZE] = {0};
    int transId;

    CCAPP_DEBUG(DEB_F_PREFIX"entering\n",
                DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));
    /* let the system know that subscription handler is available. */
    isAvailable = TRUE;

    /* get primary DN */
    config_get_line_string(CFGID_LINE_NAME, primaryLine, 1, sizeof(primaryLine));

    /*
     * for speeddial/BLF buttons, make presence subscriptions.
     */
    for (i = SPEEDDIAL_START_BUTTON_NUMBER; i <= MAX_REG_LINES; i++) {
        // first line must always be a calling line.
        config_get_line_value(CFGID_LINE_FEATURE, &lineFeature, sizeof(lineFeature), i);


        CCAPP_DEBUG(DEB_F_PREFIX"inst=%d, lineFeature=%d\n",
                    DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),
                    i, lineFeature);
        switch (lineFeature) {
        case cfgLineFeatureSpeedDialBLF:
            config_get_line_string(CFGID_LINE_SPEEDDIAL_NUMBER, speedDialNumber, i, sizeof(speedDialNumber));
            if (speedDialNumber[0] == 0) {
                break;
            }
            config_get_line_value(CFGID_LINE_FEATURE, &featureOptionMask, sizeof(featureOptionMask), i);

            transId = get_new_trans_id();
            transactionIds[i - 1] = transId;
            CC_BLF_subscribe(transId,
                             INT_MAX,
                             primaryLine,
                             speedDialNumber,
                             i,
                             featureOptionMask );
            break;
        default:
            break;
        }

        //Initializes native BLF handler
        ccBLFHandlerInitialized();
    }
}

/**
 * Call selection status
 * @param [in] handle - call handle
 * @return cc_boolean - selection status
 */
cc_boolean  CCAPI_CallInfo_isCallSelected(cc_callinfo_ref_t handle){
  static const char *fname="CCAPI_CallInfo_isCallSelected";
  session_data_t *data = (session_data_t *)handle;
  CCAPP_DEBUG(DEB_F_PREFIX"Entering\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));

  if ( data != NULL){
     CCAPP_DEBUG(DEB_F_PREFIX"returned %d\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->isSelected);
     return data->isSelected;
  }

  return FALSE;
}

/**
 * Get the speeddial Number
 * @param feature - feature reference handle
 * @return cc_string_t - speeddial number of the feature created
 */
cc_string_t CCAPI_featureInfo_getSpeedDialNumber(cc_featureinfo_ref_t feature) {
   static const char *fname="CCAPI_featureInfo_getSpeedDialNumber";
   cc_feature_info_t  *info;
   CCAPP_DEBUG(DEB_F_PREFIX"Entering\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));

   info = (cc_feature_info_t *) feature;
   if ( info != NULL ) {
       CCAPP_DEBUG(DEB_F_PREFIX"returned %s\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), info->speedDialNumber);
       return info->speedDialNumber;
   }
   return NULL;
}

/**
 * has capability - is the feature allowed
 * @param handle - call handle
 * @param feat_id - feature id
 * @return boolean - is Allowed
 */
cc_boolean  CCAPI_CallInfo_hasCapability(cc_callinfo_ref_t handle, cc_int32_t feat_id){
  static const char *fname="CCAPI_CallInfo_hasCapability";
  session_data_t *data = (session_data_t *)handle;
  CCAPP_DEBUG(DEB_F_PREFIX"Entering\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));

  if ( data != NULL){
     CCAPP_DEBUG(DEB_F_PREFIX"feature id:  %d , value returned %d\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),feat_id,  data->allowed_features[feat_id]);
     return data->allowed_features[feat_id];
  }

  return FALSE;
}

/**
 * get GCID
 * @param handle - call handle
 * @return GCID
 */
cc_string_t CCAPI_CallInfo_getGCID(cc_callinfo_ref_t handle){
  static const char *fname="CCAPI_CallInfo_getGCID";
  session_data_t *data = (session_data_t *)handle;
  CCAPP_DEBUG(DEB_F_PREFIX"Entering\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));

  if ( data != NULL){
     CCAPP_DEBUG(DEB_F_PREFIX"returned %s\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->gci);
     return data->gci;
  }

  return strlib_empty();
}

/**
 * get onhook reason
 * @param handle - call handle
 * @return onhook reason
 */
cc_int32_t  CCAPI_CallInfo_getOnhookReason(cc_callinfo_ref_t handle){
  static const char *fname="CCAPI_CallInfo_getOnhookReason";
  session_data_t *data = (session_data_t *)handle;
  CCAPP_DEBUG(DEB_F_PREFIX"Entering\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));

  if ( data != NULL){
     CCAPP_DEBUG(DEB_F_PREFIX"returned %d\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->cause);
     return data->cause;
  }

  return CC_CAUSE_NORMAL;
}

/**
 * get call instance number
 * @param handle - call handle
 * @return 
 */
cc_int32_t CCAPI_CallInfo_getCallInstance(cc_callinfo_ref_t handle){
  static const char *fname="CCAPI_CallInfo_getCallInstance";
  session_data_t *data = (session_data_t *)handle;
  CCAPP_DEBUG(DEB_F_PREFIX"Entering\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));

  if ( data != NULL){
     CCAPP_DEBUG(DEB_F_PREFIX"returned %d\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->inst);
     return data->inst;
  }

  return 0;
}

/**
 * get Call Type
 * @param handle - call handle
 * @return call type
 */
cc_call_type_t CCAPI_CallInfo_getCallType(cc_callinfo_ref_t handle){
  static const char *fname="CCAPI_CallInfo_getCallType";
  session_data_t *data = (session_data_t *)handle;
  CCAPP_DEBUG(DEB_F_PREFIX"Entering", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));

  if ( data != NULL){
     CCAPP_DEBUG(DEB_F_PREFIX"returned %02X", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->type);
     return data->type;
  }

  return 0;
}