C++ cJSON_AddNumberToObject函数代码示例

void csImgGoogle::sendImgURIToClient(int _width, int _height, const QUrl & url )
{
    // add with and hight and make a jason message
    char *out;
    cJSON *json_send;
    json_send=cJSON_CreateObject();
    cJSON_AddStringToObject(json_send,"CMD",     "CREATE");
    cJSON_AddStringToObject(json_send,"TYPE",    "Image");
    cJSON_AddNumberToObject(json_send,"OID", -1);
    cJSON_AddStringToObject(json_send,"URI",     url.toString().toStdString().c_str());
    cJSON_AddNumberToObject(json_send,"WIDTH",   _width);
    cJSON_AddNumberToObject(json_send,"HEIGHT",  _height);


    float pos[2];
    pos[0]  = 0.0f;
    pos[1]  = 0.0f;

    cJSON_AddItemToObject(json_send,"POS", cJSON_CreateFloatArray(pos,2));
    pos[0]  = 1.0f;
    pos[1]  = 1.0f;
    cJSON_AddItemToObject(json_send,"SCALE", cJSON_CreateFloatArray(pos,2));

    out=cJSON_PrintUnformatted(json_send);
    cJSON_Delete(json_send);

    pte_Url->setPlainText(QString(out));
    sm->sendData((char *)out);
    free(out);
}

//After finish called , remember free memery
char *CreateMultiplexJson(char *Type, char *cmdid)
{
	cJSON *root = NULL;
	char  *out  = NULL;

	root = cJSON_CreateObject();

	cJSON_AddStringToObject(root, "Type", Type);
	cJSON_AddStringToObject(root, "CmdID", cmdid);
	cJSON_AddStringToObject(root, "Time", setLocalTime());
	cJSON_AddStringToObject(root, "Broadcast", NONE);
	cJSON_AddStringToObject(root, "NeedAnswer", NO);
	cJSON_AddNumberToObject(root, "TeamID", status.TeamID);
	cJSON_AddNumberToObject(root, "AgentID", status.AgentID);
	cJSON_AddStringToObject(root, "Character", status.Character);
	cJSON_AddStringToObject(root, "TeamShape", status.TeamShape);
	cJSON_AddNumberToObject(root, "FuleStatus", status.Fule);
	cJSON_AddStringToObject(root, "AliveStatus", status.AliveStatus);



	out = cJSON_PrintUnformatted(root);
	cJSON_Delete(root);

	sNetOutput("->->->StatusBuffer : ",out);
	return out;

}

//TODO move to own file
int ICACHE_FLASH_ATTR http_dht_api_read(http_connection *c) {


	NODE_DBG("http_dht_api_read");
		
	//wait for whole body
	if(c->state <HTTPD_STATE_BODY_END)
		return HTTPD_CGI_MORE; 	

	//write headers
	http_SET_HEADER(c,HTTP_CONTENT_TYPE,JSON_CONTENT_TYPE);	
	http_response_OK(c);

	sensor_data data;
	sensors_get_data(&data);
		
	//create json
	cJSON *root = cJSON_CreateObject();
	cJSON_AddNumberToObject(root,"temp",data.dht22.temp);
	cJSON_AddNumberToObject(root,"hum",data.dht22.hum);

	//write json
	http_write_json(c,root);

	//delete json struct
	cJSON_Delete(root);
				
	return HTTPD_CGI_DONE;


}

void *write_sock(void *p)
{
    if(p == NULL)
	    return NULL;

    SOCKDATA *pdata = (SOCKDATA*)p;

    cJSON *root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, "needResponse", 0);
    cJSON_AddStringToObject(root, "message", pdata->msg);
    cJSON_AddNumberToObject(root, "len", pdata->size);
    char *json_str = cJSON_Print(root);

	int len;
	size_t size = strlen(json_str);
	uint8_t *buf = (uint8_t*)malloc(size+5);
	if((len=crc_data(json_str, size, buf))==-1){
        free(buf);
        cJSON_Delete(root);
		return NULL;
	}

	int nbytes;
	nbytes =send(pdata->sock_fd, buf, len, 0);

	free(buf);
    cJSON_Delete(root);

	return NULL;
}

int  RUCE_Roto_SetEntry(RUCE_Roto* This, RUCE_Roto_Entry* Sorc)
{
    cJSON* Entries = cJSON_GetObjectItem(This -> Ptr, "Entries");
    if(! Entries) return 0;
    
    char* Name = String_GetChars(& Sorc -> Name);
    cJSON* Entry = cJSON_GetObjectItem(Entries, Name);
    
    cJSON* NewEntry = cJSON_CreateObject();
    cJSON_AddNumberToObject(NewEntry, "VOT", Sorc -> VOT);
    cJSON_AddNumberToObject(NewEntry, "InvarLeft", Sorc -> InvarLeft);
    cJSON_AddNumberToObject(NewEntry, "InvarRight", Sorc -> InvarRight);
    cJSON_AddNumberToObject(NewEntry, "Overlap", Sorc -> Overlap);
    if(! Entry)
    {
        //Create new entry
        cJSON_AddItemToObject(Entries, Name, NewEntry);
    }else
    {
        //Modify existing entry
        cJSON_ReplaceItemInObject(Entries, Name, NewEntry);
    }
    
    return 1;
}

/* cJson object out */
cJSON *Category::OutJsonObjectFormat(){

    cJSON *category;
    char *out;

    char IDBuf[1024];
    memset(IDBuf, 0, sizeof(IDBuf) );

    /* create cJSON object */
    category = cJSON_CreateObject();

    /* id */
    cJSON_AddNumberToObject( category, "id", this->id );


    /* parent id */
    cJSON_AddNumberToObject( category, "parentid", this->parentid );


    /* name */
    sprintf(IDBuf, "%s", this->name.c_str());
    cJSON_AddStringToObject( category, "name", IDBuf );

    /* print */
    out = cJSON_Print( category );
    
    ESLog::ISLog("cJson Category: %s\n",__FILE__, __LINE__,  out );

    free(out);

    return category;
}

static void getmonitorinfo(HttpConn *conn) {
    char str[256] = {0};
    int inputStatus = 0, outChn = 0;
    cJSON *result = cJSON_CreateObject();
    char* jsonstring;
    int outValidBitrate = 0;
    unsigned int outstatus = 0;
    for(outChn=0; outChn<clsProgram._outChannelCntMax; outChn++){
        ChnBypass_read(tmpip, outChn);
        RecordInputChnUseStatus(outChn);
    }
    OutChn_validBitrateGet(tmpip, 1, &outValidBitrate);
    GetOutChannelStatus(tmpip, 1, &outstatus);
    cJSON_AddNumberToObject(result,"outValidBitrate", outValidBitrate);
    cJSON_AddNumberToObject(result,"outstatus", outstatus);
    outValidBitrate = 0;
    outstatus = 0;
    OutChn_validBitrateGet(tmpip, 2, &outValidBitrate);
    GetOutChannelStatus(tmpip, 2, &outstatus);
    cJSON_AddNumberToObject(result,"outValidBitrate2", outValidBitrate);
    cJSON_AddNumberToObject(result,"outstatus2", outstatus);

    int errRslt = FlagInputSignal(tmpip, &inputStatus);
    ShowNeedChnDataButNoInputWarning(errRslt, inputStatus, result);

    jsonstring = cJSON_PrintUnformatted(result);
    //printf("--getmonitorinfo---->>>%d\n",strlen(jsonstring));
    memcpy(str, jsonstring, strlen(jsonstring));
    //释放内存
    cJSON_Delete(result);
    free(jsonstring);
    render(str);
}

void create_json_test(void)
{
    cJSON* pRoot = cJSON_CreateObject();
    cJSON* pArray = cJSON_CreateArray();
    cJSON_AddItemToObject(pRoot, "students_info", pArray);
    
    cJSON* pItem = cJSON_CreateObject();
    cJSON_AddStringToObject(pItem, "name", "chenzhongjing");
    cJSON_AddStringToObject(pItem, "sex", "male");
    cJSON_AddNumberToObject(pItem, "age", 28);
    cJSON_AddItemToArray(pArray, pItem);
    
    pItem = cJSON_CreateObject();
    cJSON_AddStringToObject(pItem, "name", "fengxuan");
    cJSON_AddStringToObject(pItem, "sex", "male");
    cJSON_AddNumberToObject(pItem, "age", 24);
    cJSON_AddItemToArray(pArray, pItem);
    
    pItem = cJSON_CreateObject();
    cJSON_AddStringToObject(pItem, "name", "tuhui");
    cJSON_AddStringToObject(pItem, "sex", "male");
    cJSON_AddNumberToObject(pItem, "age", 22);
    cJSON_AddItemToArray(pArray, pItem);
    
    char* szJSON = cJSON_Print(pRoot);
    printf("%s", szJSON);
    cJSON_Delete(pRoot);
    free(szJSON);
    
    return;
}

int Pack_swm_set_mon_objs_req(susi_comm_data_t * pCommData, char ** outputStr)
{
	char * out = NULL;
	int outLen = 0;
	cJSON *root = NULL, *pSUSICommDataItem = NULL;
	if(pCommData == NULL || outputStr == NULL) return outLen;
	root = cJSON_CreateObject();
	pSUSICommDataItem = cJSON_CreateObject();
	cJSON_AddItemToObject(root, AGENTINFO_BODY_STRUCT, pSUSICommDataItem);
	cJSON_AddNumberToObject(pSUSICommDataItem, AGENTINFO_CMDTYPE, pCommData->comm_Cmd);
#ifdef COMM_DATA_WITH_JSON
	cJSON_AddNumberToObject(pSUSICommDataItem, AGENTINFO_REQID, pCommData->reqestID);
#endif

	{
		mon_obj_info_list monObjList = NULL;
		mon_obj_info_list * pMonObjList = &monObjList;
		if(!pCommData->message) return false;
		memcpy(pMonObjList, pCommData->message, sizeof(mon_obj_info_list));
		if(!monObjList) return false;
		cJSON_AddSWMThrInfoToObject(root, SWM_THR_INFO, monObjList);
	}

	out = cJSON_PrintUnformatted(root);
	outLen = strlen(out) + 1;
	*outputStr = (char *)(malloc(outLen));
	memset(*outputStr, 0, outLen);
	strcpy(*outputStr, out);
	cJSON_Delete(root);	
	printf("%s\n",out);	
	free(out);
	return outLen;
}

int PublishData(jNet *pJnet, int source)
{
    int res;

    cJSON *root, *son1, *son2;
    char *out;

    root = cJSON_CreateArray();

    cJSON_AddItemToArray(root, son1=cJSON_CreateObject());
    cJSON_AddStringToObject(son1, "hwid", gAgent);
    cJSON_AddStringToObject(son1, "type", "AGENT");
    cJSON_AddItemToObject(son1, "values", son2=cJSON_CreateObject());
    cJSON_AddNumberToObject(son2, "temperature", GetRandTemp());
    if (source == 0)  cJSON_AddFalseToObject(son2, "error");
    else cJSON_AddTrueToObject(son2, "error");

    cJSON_AddItemToArray(root, son1=cJSON_CreateObject());
    cJSON_AddStringToObject(son1, "hwid", "ABCDEF0123456");
    cJSON_AddStringToObject(son1, "type", "SENSOR");
    cJSON_AddItemToObject(son1, "values", son2=cJSON_CreateObject());
    cJSON_AddNumberToObject(son2, "lumen", Read8591(0));
    cJSON_AddNumberToObject(son2, "Volt", Read8591(3));

    out=cJSON_PrintUnformatted(root);
    cJSON_Delete(root);
    printf("Publishing %s\n", out);

    res = jNetPublishT(pJnet, gTopicUp, out);
    //printf("result %d\n", res);
    free(out);
    return res;
}

		byte* buildAuthRequest(std::string username, int &byteLen,std::string APIKEY, std::string SECRETKEY)
		{
			std::string timeStamp = getODataUTCDateFilter();
			std::string params;
			params.append("apiKey");
			params.append(APIKEY);
			params.append("timeStamp");
			params.append(timeStamp);
			params.append("user");
			params.append(username);
			params.append("version1.5");

			unsigned char hmac_digest[20];
			memset(hmac_digest, 0, 20);
			CHMAC_SHA1 hmac_sha1;
			hmac_sha1.HMAC_SHA1((unsigned char *)params.c_str(),params.length(), (unsigned char *)SECRETKEY.c_str(), SECRETKEY.length(),hmac_digest);
			std::string hmac = urlencode(base64_encode(hmac_digest, 20));

			cJSON *payloadJSON;
			payloadJSON = cJSON_CreateObject();
			cJSON_AddStringToObject(payloadJSON,"apiKey", APIKEY.c_str());
			cJSON_AddStringToObject(payloadJSON,"version", "1.5");
			cJSON_AddStringToObject(payloadJSON,"timeStamp", timeStamp.c_str());
			cJSON_AddStringToObject(payloadJSON,"user", username.c_str());
			cJSON_AddStringToObject(payloadJSON,"signature", hmac.c_str());
            cJSON_AddNumberToObject(payloadJSON, "keepalive", WARP_KEEP_ALIVE_TIME_INTERVAL);//recoverytime
            cJSON_AddNumberToObject(payloadJSON, "recoverytime", RECOVERY_ALLOWANCE_TIME);
			char* cRet = cJSON_PrintUnformatted(payloadJSON);
			std::string payload = cRet;
			free(cRet);

			cJSON_Delete(payloadJSON);

			return buildWarpRequest(RequestType::auth, payload, byteLen);
		}

cJSON *status_error_json(void)
{
	struct status_error_t *e;
	int pe;
	struct cJSON *ea;
	
	if ((pe = pthread_mutex_lock(&status_errs_mt))) {
		hlog(LOG_ERR, "status_error_json(): could not lock status_errs_mt: %s", strerror(pe));
		return NULL;
	}
	
	ea = cJSON_CreateArray();
	
	for (e = status_errs; (e); e = e->next) {
		if (e->ends < now) // don't display expired alarms
			continue;
			
		cJSON *ej = cJSON_CreateObject();
		cJSON_AddStringToObject(ej, "err", e->err);
		cJSON_AddNumberToObject(ej, "set", e->set);
		cJSON_AddNumberToObject(ej, "start", e->started);
		cJSON_AddNumberToObject(ej, "end", e->ends);
		cJSON_AddItemToArray(ea, ej);
	}
	
	if ((pe = pthread_mutex_unlock(&status_errs_mt))) {
		hlog(LOG_ERR, "status_error_json(): could not unlock status_errs_mt: %s", strerror(pe));
	}
	
	return ea;
}

static void api_response(int res, int total, const linkage_base_st *link_base)
{
	cJSON *root;
    cJSON *list_array;
    cJSON *list_item;
	char *json_out;
	int i;

	root=cJSON_CreateObject();

	cJSON_AddNumberToObject(root, FIELD_STATUS, res);

	if(res >=0){
		cJSON_AddItemToObject(root, "list", list_array =cJSON_CreateArray());
		for(i=0; i<total; i++){
			cJSON_AddItemToArray(list_array, list_item =cJSON_CreateObject());
			cJSON_AddNumberToObject(list_item, FIELD_LID, link_base[i].lid);
			cJSON_AddStringToObject(list_item, FIELD_LNKNAME, link_base[i].lnkname);
			cJSON_AddStringToObject(list_item, FIELD_TRGIEEE, link_base[i].trgieee);
			cJSON_AddStringToObject(list_item, FIELD_TRGEP, link_base[i].trgep);
			cJSON_AddStringToObject(list_item, FIELD_TRGCND, link_base[i].trgcnd);
			cJSON_AddStringToObject(list_item, FIELD_LNKACT, link_base[i].lnkact);
			cJSON_AddNumberToObject(list_item, FIELD_ENABLE, link_base[i].enable);
		}
	}

	json_out=cJSON_Print(root);
	cJSON_Delete(root);

	fprintf(cgiOut,"%s\n", json_out);
	free(json_out);
}

int json_return(evhtp_request_t *req, int err_no, const char *md5sum, int post_size)
{
    //json sample:
    //{"ret":true,"info":{"size":"1024", "md5":"edac35fd4b0059d3218f0630bc56a6f4"}}
    //{"ret":false,"error":{"code":"1","message":"\u9a8c\u8bc1\u5931\u8d25"}}
    cJSON *j_ret = cJSON_CreateObject();
    cJSON *j_ret_info = cJSON_CreateObject();
    if(err_no == -1)
    {
        cJSON_AddBoolToObject(j_ret, "ret", 1);
        cJSON_AddStringToObject(j_ret_info, "md5", md5sum);
        cJSON_AddNumberToObject(j_ret_info, "size", post_size);
        cJSON_AddItemToObject(j_ret, "info", j_ret_info);
    }
    else
    {
        cJSON_AddBoolToObject(j_ret, "ret", 0);
        cJSON_AddNumberToObject(j_ret_info, "code", err_no);
        LOG_PRINT(LOG_DEBUG, "post_error_list[%d]: %s", err_no, post_error_list[err_no]);
        cJSON_AddStringToObject(j_ret_info, "message", post_error_list[err_no]);
        cJSON_AddItemToObject(j_ret, "error", j_ret_info);
    }
    char *ret_str_unformat = cJSON_PrintUnformatted(j_ret);
    LOG_PRINT(LOG_DEBUG, "ret_str_unformat: %s", ret_str_unformat);
    evbuffer_add_printf(req->buffer_out, "%s", ret_str_unformat);
    evhtp_headers_add_header(req->headers_out, evhtp_header_new("Content-Type", "application/json", 0, 0));
    cJSON_Delete(j_ret);
    free(ret_str_unformat);
    return 0;
}

int auth_client_check_server(time_t current_time)
{
	static time_t last_time = 0;
	char *msgstr;
	cJSON *msgJS;
	cJSON *dataJS;

	if (current_time - last_time < 300)
	{
		return 0;
	}
	last_time = current_time;

	msgJS = cJSON_CreateObject();
	cJSON_AddStringToObject(msgJS, "out_topic", "a/ac/usrmgr/query");
	cJSON_AddNumberToObject(msgJS, "deadline", current_time + 10);

	dataJS = cJSON_CreateObject();
	cJSON_AddStringToObject(dataJS, "mod", "a/local/auth");
	cJSON_AddStringToObject(dataJS, "cmd", "check_config_update");
	cJSON_AddStringToObject(dataJS, "group", auth_user_ac_account);
	cJSON_AddNumberToObject(dataJS, "config_version", auth_config_version);

	cJSON_AddItemToObject(msgJS, "data", dataJS);

	msgstr = cJSON_PrintUnformatted(msgJS);
	printf("%s\n", msgstr);
	auth_mqtt_publish("a/local/proxy", msgstr, strlen(msgstr));

	cJSON_Delete(msgJS);
	free(msgstr);

	return 0;
}