开发者中心

说明

飞天智能物联网平台对外提供HTTPSRest方式的接口，所有的请求均采用POST方法。编码方式为UTF-8，消息体参数及返回结果为JSON格式。

注意：使用API前需要先获取Appkey和Appsecret。Appkey用于标识访问的应用，AppSecret用于传输数据时，对传输报文进行签名。

报文签名说明:

第一步：各接口中非空参数按照参数名ascii码从小到大排序，使用URL键值对的格式，拼接成待签名字符串，即

key1=value1&key2=value2&key3=value3

拼接成字符串。

假设发送的参数为：

{ appkey : 9A0A8659F005D6984697E2CA0A9CF3B7, timestamp :20181221162001, nonce : dpRxkhjbauiclpKoqt }

则待签名数据 appkey=9A0A8659F005D6984697E2CA0A9CF3B7&nonce=dpRxkhjbauiclpKoqt&timestamp=20181221162001

第二步：使用apisecret作为签名密钥，对A进行签名，得到签名结果B

B=HmacSHA256(A, appsecret);

第三步：将B加入到参数列表中，得出最终发送的数据为：

{ appkey : 9A0A8659F005D6984697E2CA0A9CF3B7, timestamp :20181221162001, nonce : dpRxkhjbauiclpKoqt, sign:Base64(B) }

签名示例：

														  
												
												import java.io.BufferedReader;
												import java.io.InputStream;
												import java.io.InputStreamReader;
												import java.io.OutputStream;
												import java.net.HttpURLConnection;
												import java.net.URL;
												import java.security.MessageDigest;
												import java.security.SecureRandom;
												import java.text.SimpleDateFormat;
												import java.util.Arrays;
												import java.util.Base64;
												import java.util.Date;
												import java.util.HashMap;
												import java.util.Map;
												import java.util.Random;
												import java.util.Set;
												import javax.crypto.Mac;
												import javax.crypto.spec.SecretKeySpec;


												import com.alibaba.fastjson.JSON;
													
													
													
															                                                      
												public static void main(String[] args) {
													try{
														String appsecert = "<你的appsecret>";          							//应用appsecret
														Map<String,Object> data = new HashMap<String,Object>();					//待签名数据，请参照签名生成流程生成
														String sign = generateSignature(data, appsecert, "HMAC-SHA256");        //生成数据签名
														}catch(Exception e){
															e.printStackTrace();
														}
												   }
												 
												 
												public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
													throws Exception {
													Set keySet = data.keySet();
													String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
													Arrays.sort(keyArray);
													StringBuilder sb = new StringBuilder();
													for (String k : keyArray) {
														if (k.equals("sign")) {
															continue;
														}

														if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
															data.remove(k);
															continue;
														}

														Object value = data.get(k);
														if (value instanceof Integer) {
															value = sb.append(k).append("=").append(value).append("&");
														} else {
															if (String.valueOf(value).trim().length() > 0) {
																sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
															}
														}
													}
													String sbr = sb.substring(0, sb.length() - 1);
													if ("MD5".equals(signType)) {
														java.security.MessageDigest md = MessageDigest.getInstance("MD5");
														byte[] array = md.digest(sbr.getBytes("UTF-8"));
														return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
													} else if ("HMAC-SHA256".equals(signType)) {
														Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
														SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
														sha256_HMAC.init(secret_key);
														byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
														return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
													}
													return null;
												}

使用流程

第一步：创建我的应用

为了正常运行开发环境，您需要建立一个应用并获得相应的【应用标识】、【应用安全密钥】和【应用服务器地址】，具体步骤如下：

1.点击进入飞天智能管理平台登录页面，登录飞天智能管理平台。

2.在管理平台左侧列表中，点击【添加应用】，跳转至添加应用界面，进行应用添加。

3.输入【应用名称】，应用描述（可选），点击【保存】按钮后，页面跳转至应用列表可查看新添加应用的【应用标识】【应用安全密钥】【应用服务器地址】等关键信息，在API初始化时需要用到这些参数。

第二步：集成您需要的接口

应用添加完成之后，您可以根据您的业务需要进行接口集成，请参见RESTful接口详细介绍。

设备绑定

请求地址：https://serverurl/v1/audio/

接口功能：将终端设备和商户二维码牌进行绑定。上传设备编号、二维码牌标识推送给消息服务平台，验证通过后，将此设备和码牌进行绑定。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，bindDevice	是
devicesn	设备编号	是
paycode	码牌编号（收钱码的二维码内容，或唯一标识）	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

														  
															
														import java.io.BufferedReader;
														import java.io.InputStream;
														import java.io.InputStreamReader;
														import java.io.OutputStream;
														import java.net.HttpURLConnection;
														import java.net.URL;
														import java.security.MessageDigest;
														import java.security.SecureRandom;
														import java.text.SimpleDateFormat;
														import java.util.Arrays;
														import java.util.Base64;
														import java.util.Date;
														import java.util.HashMap;
														import java.util.Map;
														import java.util.Random;
														import java.util.Set;
														import javax.crypto.Mac;
														import javax.crypto.spec.SecretKeySpec;
														
														
														import com.alibaba.fastjson.JSON;
																
																
																
															                                                   
														public static void main(String[] args) {
															try {
																String serverUrl = "<你的serverUrl>"; 
																String appkey = "<你的appkey>"; 
																String appsecret = "<你的appsecret>";
																String method = "<请求的接口名>"; 
																String devicesn = "<你的设备编号>";
																String paycode = "<你的收钱码>";
																SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																String timestamp = dateFormat.format(new Date());						// 时间戳
																char[] nonceChars = new char[32];
																final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																final Random RANDOM = new SecureRandom();
																for (int index = 0; index > nonceChars.length; ++index) {
																	nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																}
																String none = new String(nonceChars); 									// 获取随机字符串
																Map<String,Object> param = new HashMap<String,Object>();
																param.put("appkey", appkey); 											// 设置参数
																.....;
																String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																param.put("sign", sign);
																String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																System.out.println(response);											// 返回结果 
															} catch (Exception e) {
																e.printStackTrace();
															}
														}
														  
														 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
															throws Exception {
																Set keySet = data.keySet();
																String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																Arrays.sort(keyArray);
																StringBuilder sb = new StringBuilder();
																for (String k : keyArray) {
																	if (k.equals("sign")) {
																		continue;
																	}
															 
																	if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																		data.remove(k);
																		continue;
																	}
															 
																	Object value = data.get(k);
																	if (value instanceof Integer) {
																		value = sb.append(k).append("=").append(value).append("&");
																	} else {
																		if (String.valueOf(value).trim().length() > 0) {
																			sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																		}
																	}
																}
																String sbr = sb.substring(0, sb.length() - 1);
																if ("MD5".equals(signType)) {
																	java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																	byte[] array = md.digest(sbr.getBytes("UTF-8"));
																	return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																} else if ("HMAC-SHA256".equals(signType)) {
																	Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																	SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																	sha256_HMAC.init(secret_key);
																	byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																	return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																}
																return null;
														 }
																											 
														public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
															throws Exception {
																StringBuffer buffer = new StringBuffer();
																HttpURLConnection httpUrlConn = null;
																try {
																	URL url = new URL(requestUrl);
																	httpUrlConn = (HttpURLConnection) url.openConnection();

																	httpUrlConn.setDoOutput(true);
																	httpUrlConn.setDoInput(true);
																	httpUrlConn.setUseCaches(false);
																	httpUrlConn.setConnectTimeout(30000);
																	httpUrlConn.setReadTimeout(60000);
																	httpUrlConn.setRequestProperty("Content-type", "application/json");

																	httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）

																	if ("GET".equalsIgnoreCase(requestMethod)) {
																		httpUrlConn.connect();
																	}

																	if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																		OutputStream outputStream = null;
																		try {
																			outputStream = httpUrlConn.getOutputStream();
																			outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																		} finally {
																			if (outputStream != null) {
																				outputStream.close();
																				outputStream = null;
																			}
																		}
																	}

																	InputStream inputStream = null;
																	InputStreamReader inputStreamReader = null;
																	BufferedReader bufferedReader = null;
																	try {
																		inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																		inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																		bufferedReader = new BufferedReader(inputStreamReader);

																		String str = null;
																		while ((str = bufferedReader.readLine()) != null) {
																			buffer.append(str);
																		}
																	} finally { 
																		if (bufferedReader != null) {
																			bufferedReader.close();
																			bufferedReader = null;
																		}
																		if (inputStreamReader != null) {
																			inputStreamReader.close();
																			inputStreamReader = null;
																		}
																		if (inputStream != null) {
																			inputStream.close();
																			inputStream = null;
																		}
																	}

																} finally {
																	if (httpUrlConn != null) {
																		httpUrlConn.disconnect();
																	}
																}
																return buffer.toString();
															}
														}

消息推送（使用设备码）

请求地址：https://serverurl/v1/audio/

接口功能：向指定的设备推送语音消息。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，push	是
devicesn	设备编号，可以指定设备编号向该设备推送消息	是
message	播报金额，int类型，单位：分	是
push_template	语音模板（1支付宝；2微信；3扫码（默认）；4银联）	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
nonce	请求时的nonce，原样带回
pushsn	消息流水号
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

																		
																			
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String devicesn = "<你的设备编号>";
																		Integer message = "<播报金额>";
																		Integer push_template = "<你的模板编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

消息推送（使用收钱码）

请求地址：https://serverurl/v1/audio/

接口功能：向指定的设备推送语音消息。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，pushByPaycode	是
paycode	收钱码，指定收钱码，向绑定的设备推送消息	是
message	播报金额，int类型，单位：分	是
push_template	语音模板（1支付宝；2微信；3扫码（默认）；4银联）	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String paycode = "<你的收钱码>";
																		Integer message = "<播报金额>";
																		Integer push_template = "<你的模板编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

消息推送(使用设备码)

请求地址：https://serverurl/v1/audio/

接口功能：云打印播报一体机指音箱在播报收款金额的同时打印商品消费明细小票。向指定的设备推送语音消息，根据打印模版打印商品消费明细小票。

参数名

参数说明

value是否必须

appkey

应用appkey

是

method

请求的接口名，push

是

devicesn

设备编号，可以指定设备编号向该设备推送消息

是

message

播报金额，int类型，单位：分

是

push_template

语音模板（1支付宝；2微信；3扫码（默认）；4银联）

是

ticketinfo

打印模板	传参	打印结果
商户名称：{1} 时间：{2} 金额：{3}	String ticketinfo = "张三水果店&2020.06.08&100元"	商户名称：张三水果店时间：2020.06.08 金额：100元
商户名称：@name 时间：@time 金额：@money	{"name":"张三", "time":"2020.06.08", "money":"100元"}	商户名称：张三水果店时间：2020.06.08 金额：100元

打印模板的参数分为@key方式和{1}{2}...两种方式。以上为两种打印模板的传参样例，具体参数根据打印模板内容（可去管理平台查看）来设定

否

ticket_template

打印模板编号，非必传，若不传依次优先级为设备，企业，若两个范围下都没有打印模板则检查是否有ticketinfo，如果传了ticketinfo则返回对应错误，如果没有传ticketinfo则直接播报不打印

否

timestamp

时间戳，格式yyyyMMddHHmmss

是

nonce

client端产生的随机字符串。长度不超过32位

是

sign

请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”

是

参数名	参数说明
code	返回响应码
msg	结果描述
nonce	请求时的nonce，原样带回
pushsn	消息流水号
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

																										
																											
																								import java.io.BufferedReader;
																								import java.io.InputStream;
																								import java.io.InputStreamReader;
																								import java.io.OutputStream;
																								import java.net.HttpURLConnection;
																								import java.net.URL;
																								import java.security.MessageDigest;
																								import java.security.SecureRandom;
																								import java.text.SimpleDateFormat;
																								import java.util.Arrays;
																								import java.util.Base64;
																								import java.util.Date;
																								import java.util.HashMap;
																								import java.util.Map;
																								import java.util.Random;
																								import java.util.Set;
																								import javax.crypto.Mac;
																								import javax.crypto.spec.SecretKeySpec;
																								
																								
																								import com.alibaba.fastjson.JSON;
																										
																										
																										
																									                                                   
																								public static void main(String[] args) {
																									try {
																										String serverUrl = "<你的serverUrl>"; 
																										String appkey = "<你的appkey>"; 
																										String appsecret = "<你的appsecret>";
																										String method = "<请求的接口名>"; 
																										String devicesn = "<你的设备编号>";
																										Integer message = "<播报金额>";
																										Integer push_template = "<你的模板编号>";
																										String ticketinfo = "<小票数据>";
																										Integer ticket_template = "<你的打印模板编号>";
																										SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																										String timestamp = dateFormat.format(new Date());						// 时间戳
																										char[] nonceChars = new char[32];
																										final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																										final Random RANDOM = new SecureRandom();
																										for (int index = 0; index > nonceChars.length; ++index) {
																											nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																										}
																										String none = new String(nonceChars); 									// 获取随机字符串
																										Map<String,Object> param = new HashMap<String,Object>();
																										param.put("appkey", appkey); 											// 设置参数
																										.....;
																										String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																										param.put("sign", sign);
																										String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																										System.out.println(response);											// 返回结果 
																									} catch (Exception e) {
																										e.printStackTrace();
																									}
																								}
																								  
																								 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																									throws Exception {
																										Set keySet = data.keySet();
																										String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																										Arrays.sort(keyArray);
																										StringBuilder sb = new StringBuilder();
																										for (String k : keyArray) {
																											if (k.equals("sign")) {
																												continue;
																											}
																									 
																											if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																												data.remove(k);
																												continue;
																											}
																									 
																											Object value = data.get(k);
																											if (value instanceof Integer) {
																												value = sb.append(k).append("=").append(value).append("&");
																											} else {
																												if (String.valueOf(value).trim().length() > 0) {
																													sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																												}
																											}
																										}
																										String sbr = sb.substring(0, sb.length() - 1);
																										if ("MD5".equals(signType)) {
																											java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																											byte[] array = md.digest(sbr.getBytes("UTF-8"));
																											return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																										} else if ("HMAC-SHA256".equals(signType)) {
																											Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																											SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																											sha256_HMAC.init(secret_key);
																											byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																											return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																										}
																										return null;
																								 }
																																					 
																								public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																									throws Exception {
																										StringBuffer buffer = new StringBuffer();
																										HttpURLConnection httpUrlConn = null;
																										try {
																											URL url = new URL(requestUrl);
																											httpUrlConn = (HttpURLConnection) url.openConnection();
																								
																											httpUrlConn.setDoOutput(true);
																											httpUrlConn.setDoInput(true);
																											httpUrlConn.setUseCaches(false);
																											httpUrlConn.setConnectTimeout(30000);
																											httpUrlConn.setReadTimeout(60000);
																											httpUrlConn.setRequestProperty("Content-type", "application/json");
																								
																											httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																								
																											if ("GET".equalsIgnoreCase(requestMethod)) {
																												httpUrlConn.connect();
																											}
																								
																											if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																												OutputStream outputStream = null;
																												try {
																													outputStream = httpUrlConn.getOutputStream();
																													outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																												} finally {
																													if (outputStream != null) {
																														outputStream.close();
																														outputStream = null;
																													}
																												}
																											}
																								
																											InputStream inputStream = null;
																											InputStreamReader inputStreamReader = null;
																											BufferedReader bufferedReader = null;
																											try {
																												inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																												inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																												bufferedReader = new BufferedReader(inputStreamReader);
																								
																												String str = null;
																												while ((str = bufferedReader.readLine()) != null) {
																													buffer.append(str);
																												}
																											} finally { 
																												if (bufferedReader != null) {
																													bufferedReader.close();
																													bufferedReader = null;
																												}
																												if (inputStreamReader != null) {
																													inputStreamReader.close();
																													inputStreamReader = null;
																												}
																												if (inputStream != null) {
																													inputStream.close();
																													inputStream = null;
																												}
																											}
																								
																										} finally {
																											if (httpUrlConn != null) {
																												httpUrlConn.disconnect();
																											}
																										}
																										return buffer.toString();
																									}
																								}

消息推送（使用收钱码）

请求地址：https://serverurl/v1/audio/

参数名

参数说明

value是否必须

appkey

应用appkey

是

method

请求的接口名，pushByPaycode

是

paycode

收钱码，指定收钱码，向绑定的设备推送消息

是

message

播报金额，int类型，单位：分

是

push_template

语音模板（1支付宝；2微信；3扫码（默认）；4银联）

是

ticketinfo

打印模板	传参	打印结果
商户名称：{1} 时间：{2} 金额：{3}	String ticketinfo = "张三水果店&2020.06.08&100元"	商户名称：张三水果店时间：2020.06.08 金额：100元
商户名称：@name 时间：@time 金额：@money	{"name":"张三", "time":"2020.06.08", "money":"100元"}	商户名称：张三水果店时间：2020.06.08 金额：100元

打印模板的参数分为@key方式和{1}{2}...两种方式。以上为两种打印模板的传参样例，具体参数根据打印模板内容（可去管理平台查看）来设定

否

ticket_template

否

timestamp

时间戳，格式yyyyMMddHHmmss

是

nonce

client端产生的随机字符串。长度不超过32位

是

sign

请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”

是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String paycode = "<你的收钱码>";
																		Integer message = "<播报金额>";
																		Integer push_template = "<你的模板编号>";
																		String ticketinfo = "<小票数据>";
																		Integer ticket_template = "<你的打印模板编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

TTS消息推送（使用设备码）

请求地址：https://serverurl/v1/audio/

参数名

参数说明

value是否必须

appkey

应用appkey

是

method

请求的接口名，pushTTS

是

devicesn

设备编号

是

message

播报消息内容(使用utf-8编码，最长60字)

是

ticketinfo

打印模板	传参	打印结果
商户名称：{1} 时间：{2} 金额：{3}	String ticketinfo = "张三水果店&2020.06.08&100元"	商户名称：张三水果店时间：2020.06.08 金额：100元
商户名称：@name 时间：@time 金额：@money	{"name":"张三", "time":"2020.06.08", "money":"100元"}	商户名称：张三水果店时间：2020.06.08 金额：100元

打印模板的参数分为@key方式和{1}{2}...两种方式。以上为两种打印模板的传参样例，具体参数根据打印模板内容（可去管理平台查看）来设定

否

ticket_template

否

timestamp

时间戳，格式yyyyMMddHHmmss

是

nonce

client端产生的随机字符串。长度不超过32位

是

sign

请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”

是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String paycode = "<你的设备编号>";
																		String message = "<播报消息内容>";
																		String ticketinfo = "<小票数据>";
																		Integer ticket_template = "<你的打印模板编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

TTS消息推送（使用收钱码）

请求地址：https://serverurl/v1/audio/

参数名

参数说明

value是否必须

appkey

应用appkey

是

method

请求的接口名，pushTTSByPayCode

是

paycode

收钱码，指定收钱码，向绑定的设备推送消息

是

message

播报消息内容(使用utf-8编码，最长60字)

是

ticketinfo

打印模板	传参	打印结果
商户名称：{1} 时间：{2} 金额：{3}	String ticketinfo = "张三水果店&2020.06.08&100元"	商户名称：张三水果店时间：2020.06.08 金额：100元
商户名称：@name 时间：@time 金额：@money	{"name":"张三", "time":"2020.06.08", "money":"100元"}	商户名称：张三水果店时间：2020.06.08 金额：100元

打印模板的参数分为@key方式和{1}{2}...两种方式。以上为两种打印模板的传参样例，具体参数根据打印模板内容（可去管理平台查看）来设定

否

ticket_template

否

timestamp

时间戳，格式yyyyMMddHHmmss

是

nonce

client端产生的随机字符串。长度不超过32位

是

sign

请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”

是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String paycode = "<你的收钱码>";
																		String message = "<播报消息内容>";
																		String ticketinfo = "<小票数据>";
																		Integer ticket_template = "<你的打印模板编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

TTS消息推送（使用设备码）

请求地址：https://serverurl/v1/audio/

接口功能：向指定的设备推送语音消息，不需要预先添加模板，使用平台的TTS功能。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，pushTTS	是
devicesn	设备编号	是
message	播报消息内容(使用utf-8编码，最大60字)	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String devicesn = "<你的设备编号>";
																		String message = "<播报消息内容>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

TTS消息推送（使用收钱码）

请求地址：https://serverurl/v1/audio/

接口功能：向指定的设备推送语音消息，不需要预先添加模板，使用平台的TTS功能。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，pushTTSByPayCode	是
paycode	收钱码，指定收钱码，向绑定的设备推送消息	是
message	播报消息内容(使用utf-8编码，最大60字)	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String paycode = "<你的收钱码>";
																		String message = "<播报消息内容>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

优惠金消息推送(使用设备码)

请求地址：https://serverurl/v1/audio/

接口功能：向指定的设备推送语音消息。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，pushdiscount	是
devicesn	设备编号，可以指定设备编号向该设备推送消息	是
message	播报金额，int类型，单位：分	是
push_template	语音模板（1支付宝；2微信；3扫码（默认）；4银联）	是
field_discount_amt	优惠金额，单位：分	是
field_discount_template	优惠金额模板	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String devicesn = "<你的设备编号>";
																		Integer message = "<播报金额>";
																		Integer push_template = "<你的模板编号>";
																		Integer field_discount_amt = "<优惠金额>";
																		Integer field_discount_template = "<你的优惠金模板编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

优惠金消息推送(使用收钱码)

请求地址：https://serverurl/v1/audio/

接口功能：向指定的设备推送语音消息。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，pushbypaycodediscount	是
paycode	收钱码，指定收钱码，向绑定的设备推送消息	是
message	播报金额，int类型，单位：分	是
push_template	语音模板（1支付宝；2微信；3扫码（默认）；4银联）	是
field_discount_amt	优惠金额，单位：分	是
field_discount_template	优惠金额模板	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String paycode = "<你的收钱码>";
																		Integer message = "<播报金额>";
																		Integer push_template = "<你的模板编号>";
																		Integer field_discount_amt = "<优惠金额>";
																		Integer field_discount_template = "<你的优惠金模板编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

验证码推送(使用设备码)

请求地址：https://serverurl/v1/audio/

接口功能：向指定的设备推送验证码消息。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，pushverifycode	是
devicesn	设备编号，可以指定设备编号向该设备推送消息	是
verify_code	验证码（可选，可手动输入，也可自动生成，自动生成可调用验证码验证接口）	否
push_template	验证码模板	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String devicesn = "<你的设备编号>";
																		String verifyCode = "<你的验证码>";
																		Integer pushTemplat = "<你的验证码模板编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

验证码推送(使用收钱码)

请求地址：https://serverurl/v1/audio/

接口功能：向指定的设备推送验证码消息。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，pushverifycodebypaycode	是
paycode	收钱码，指定收钱码，向绑定的设备推送消息	是
verify_code	验证码验证码（可选，可手动输入，也可自动生成，自动生成可调用验证码验证接口）	否
push_template	验证码模板	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String paycode = "<你的收钱码>";
																		String verifyCode = "<你的验证码>";
																		Integer pushTemplat = "<你的验证码模板编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

推送验证码验证(使用设备码)

请求地址：https://serverurl/v1/audio/

接口功能：验证向指定的设备推送的验证码（推送验证码的方式为自动生成的方式，验证接口才有效）。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，checkverifycode	是
devicesn	设备编号	是
verify_code	验证码（自动生成的验证码）	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String devicesn = "<你的设备编号>";
																		String verifyCode = "<你的验证码>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

推送验证码验证(使用收钱码)

请求地址：https://serverurl/v1/audio/

接口功能：验证向指定的设备推送的验证码（推送验证码的方式为自动生成的方式，验证接口才有效）。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，checkverifycode	是
paycode	收钱码	是
verify_code	验证码（自动生成的验证码）	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
pushsn	消息流水号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String paycode = "<你的收钱码>";
																		String verifyCode = "<你的验证码>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

动态二维码显示设置

请求地址：https://serverurl/v1/audio/

接口功能：对带屏音箱设置显示二维码/或普通文本。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，refreshQr	是
devicesn	设备编号	是
qrcode	二维码内容	是
message	文本内容（最大长度64）	否
timestamp	时间戳，格式yyyyMMddHHmmss	否
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String devicesn = "<你的设备编号>";
																		String qrcode = "<你的二维码内容>";
																		String message = "<你的文本内容>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

获取码牌绑定的设备

请求地址：https://serverurl/v1/audio/

接口功能：上传二维码牌编号，获取二维码牌对应绑定的设备编号。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，getBindDevice	是
paycode	码牌编号（收钱码的二维码内容，或唯一标识）	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机字符串。长度不超过32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
devicesn	返回绑定的设备编号
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String paycode = "<你的收钱码>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

获取设备信息

请求地址：https://serverurl/v1/audio/

接口功能：检查某个指定的设备的信息。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，getDeviceInfo	是
devicesn	设备编号	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机数。最大长度32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
status	设备的绑定状态(0未绑定，1已绑定)
state	设备状态（0正常，1禁用）
is_online	是否在线（0在线，1离线）
version	当前版本
last_online_time	最后在线时间
last_offline_time	最后离线时间
location_info	设备定位信息,例：{"descp","北京市海淀区学清路靠近汇智大厦"}
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String devicesn = "<你的设备编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

设备解绑

请求地址：https://serverurl/v1/audio/

接口功能：解除终端设备和二维码牌的绑定关系。

参数名	参数说明	value是否必须
appkey	应用appkey	是
method	请求的接口名，unbindDevice	是
devicesn	设备编号	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机数。最大长度32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String method = "<请求的接口名>"; 
																		String devicesn = "<你的设备编号>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

设置开关机模板

请求地址：https://serverurl/v1/config/

接口功能：设置全局生效/范围生效的播报模板信息。

参数名	参数说明	value是否必须
appkey	应用appkey	是
config_name	配置的模板名称，最大长度32	是
config_content	模板内容，长度限制：开机模板最大长度25 关机模板最大长度25	是
config_type	设置类型。可选值为： 1：开机模板 2：关机模板	是
config_scope	生效范围。可选值为： 1：企业全局生效 2：部分机构生效 3：部分设备生效设置为2或3时，由config_target指定具体生效的机构编号或设备编号	是
config_target	生效的机构编号/设备编号列表。使用”,”（半角英文逗号）分隔。批量设置最多支持10个机构/设备，此参数最大长度1024字符	否
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机数。最大长度32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String config_name = "<模板名称>"; 
																		String config_content = "<模板内容>";
																		int config_type = "<设置类型>";
																		int config_scope = "<生效范围>";
																		String config_target = "<生效的机构编号/设备编号列表>";
																		
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

设置广告模板

请求地址：https://serverurl/v1/config/

接口功能：设置全局生效/范围生效的播报模板信息。

参数名	参数说明	value是否必须
appkey	应用appkey	是
config_name	配置的模板名称，最大长度32	是
config_content	模板内容，最大长度50	是
config_type	设置类型。可选值为：3	是
config_scope	生效范围。可选值为： 1：企业全局生效 2：部分机构生效 3：部分设备生效设置为2或3时，由config_target指定具体生效的机构编号或设备编号	是
config_target	生效的机构编号/设备编号列表。使用”,”（半角英文逗号）分隔。批量设置最多支持10个机构/设备，此参数最大长度1024字符	否
config_rules	播报规则。可选值： 1、每次开机后播报一次 2、定时播报，每间隔n分钟播报一次，n由config_value参数指定 3、固定播报，每n次收款到账后播报一次，n由config_value参数指定	是
config_value	播报规则设置值，当config_rules为2或3时有效。指定广告播报的间隔时间或间隔次数	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机数。最大长度32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String config_name = "<模板名称>"; 
																		String config_content = "<模板内容>";
																		int config_type = "<设置类型>";
																		int config_scope = "<生效范围>";
																		String config_target = "<生效的机构编号/设备编号列表>";
																		int config_rules = "<播报规则>";
																		String config_value = "<播报规则设置值>";
																		
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}

设置自定义播报模板

请求地址：https://serverurl/v1/config/

接口功能：设置针对设备的个性化播报模板信息。

参数名	参数说明	value是否必须
appkey	应用appkey	是
config_name	配置的模板名称，最大长度32	是
config_content	模板内容，最大长度25	是
config_type	设置类型。可选值为：4	是
config_scope	生效范围。固定值3 由config_target指定具体生效的设备编号	是
config_target	生效的设备编号列表。使用”,”（半角英文逗号）分隔。批量设置最多支持10个设备，此参数最大长度1024字符	是
config_rules	播报规则。可选值： 1、作为前缀播报 2、作为后缀播报 3、仅播报自定义部分+金额 4、仅播报自定义部分	是
timestamp	时间戳，格式yyyyMMddHHmmss	是
nonce	client端产生的随机数。最大长度32位	是
sign	请求参数的签名 Base64(HmacSHA256(待签名参数, appsecret)) 其中待签名字符串生成方式详见“报文签名说明”	是

参数名	参数说明
code	返回响应码
msg	结果描述
nonce	请求时的nonce，原样带回
sign	响应数据的签名 Base64(HmacSHA256(待签名参数, appsecret)) 待签名参数生成规则和请求签名生成规则相同

JAVA

															  
																
																import java.io.BufferedReader;
																import java.io.InputStream;
																import java.io.InputStreamReader;
																import java.io.OutputStream;
																import java.net.HttpURLConnection;
																import java.net.URL;
																import java.security.MessageDigest;
																import java.security.SecureRandom;
																import java.text.SimpleDateFormat;
																import java.util.Arrays;
																import java.util.Base64;
																import java.util.Date;
																import java.util.HashMap;
																import java.util.Map;
																import java.util.Random;
																import java.util.Set;
																import javax.crypto.Mac;
																import javax.crypto.spec.SecretKeySpec;
																
																
																import com.alibaba.fastjson.JSON;
																		
																		
																		
																	                                                   
																public static void main(String[] args) {
																	try {
																		String serverUrl = "<你的serverUrl>"; 
																		String appkey = "<你的appkey>"; 
																		String appsecret = "<你的appsecret>";
																		String config_name = "<模板名称>"; 
																		String config_content = "<模板内容>";
																		int config_type = "<设置类型>";
																		int config_scope = "<生效范围>";
																		String config_target = "<生效的设备编号列表>";
																		int config_rules = "<播报规则>";
																		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
																		String timestamp = dateFormat.format(new Date());						// 时间戳
																		char[] nonceChars = new char[32];
																		final String SYMBOLS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
																		final Random RANDOM = new SecureRandom();
																		for (int index = 0; index > nonceChars.length; ++index) {
																			nonceChars[index] = SYMBOLS.charAt(RANDOM.nextInt(SYMBOLS.length()));
																		}
																		String none = new String(nonceChars); 									// 获取随机字符串
																		Map<String,Object> param = new HashMap<String,Object>();
																		param.put("appkey", appkey); 											// 设置参数
																		.....;
																		String sign = generateSignature(param, appsecret, "HMAC-SHA256");		// 请参照签名示例生成 
																		param.put("sign", sign);
																		String response = httpRequest(serverUrl, "POST", JSON.toJSONString(param));
																		System.out.println(response);											// 返回结果 
																	} catch (Exception e) {
																		e.printStackTrace();
																	}
																}
																  
																 public static String generateSignature(final Map<String,Object> data, String appsecret, String signType) // 签名生成方法
																	throws Exception {
																		Set keySet = data.keySet();
																		String[] keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
																		Arrays.sort(keyArray);
																		StringBuilder sb = new StringBuilder();
																		for (String k : keyArray) {
																			if (k.equals("sign")) {
																				continue;
																			}
																	 
																			if (data.get(k) == null || "null".equals(data.get(k))) { 				// 参数值为空，则不参与签名
																				data.remove(k);
																				continue;
																			}
																	 
																			Object value = data.get(k);
																			if (value instanceof Integer) {
																				value = sb.append(k).append("=").append(value).append("&");
																			} else {
																				if (String.valueOf(value).trim().length() > 0) {
																					sb.append(k).append("=").append(String.valueOf(value).trim()).append("&");
																				}
																			}
																		}
																		String sbr = sb.substring(0, sb.length() - 1);
																		if ("MD5".equals(signType)) {
																			java.security.MessageDigest md = MessageDigest.getInstance("MD5");
																			byte[] array = md.digest(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array);					// 16进制base64形式
																		} else if ("HMAC-SHA256".equals(signType)) {
																			Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
																			SecretKeySpec secret_key = new SecretKeySpec(appsecret.getBytes("UTF-8"), "HmacSHA256");
																			sha256_HMAC.init(secret_key);
																			byte[] array = sha256_HMAC.doFinal(sbr.getBytes("UTF-8"));
																			return Base64.getUrlEncoder().encodeToString(array); 					// 16进制base64形式
																		}
																		return null;
																 }
																													 
																public static String httpRequest(String requestUrl, String requestMethod, String outputStr) // 发送请求方法
																	throws Exception {
																		StringBuffer buffer = new StringBuffer();
																		HttpURLConnection httpUrlConn = null;
																		try {
																			URL url = new URL(requestUrl);
																			httpUrlConn = (HttpURLConnection) url.openConnection();
																
																			httpUrlConn.setDoOutput(true);
																			httpUrlConn.setDoInput(true);
																			httpUrlConn.setUseCaches(false);
																			httpUrlConn.setConnectTimeout(30000);
																			httpUrlConn.setReadTimeout(60000);
																			httpUrlConn.setRequestProperty("Content-type", "application/json");
																
																			httpUrlConn.setRequestMethod(requestMethod);								// 设置请求方式（GET/POST）
																
																			if ("GET".equalsIgnoreCase(requestMethod)) {
																				httpUrlConn.connect();
																			}
																
																			if (null != outputStr && outputStr.length() > 0) {							// 当有数据需要提交时
																				OutputStream outputStream = null;
																				try {
																					outputStream = httpUrlConn.getOutputStream();
																					outputStream.write(outputStr.getBytes("UTF-8"));					// 注意编码格式，防止中文乱码
																				} finally {
																					if (outputStream != null) {
																						outputStream.close();
																						outputStream = null;
																					}
																				}
																			}
																
																			InputStream inputStream = null;
																			InputStreamReader inputStreamReader = null;
																			BufferedReader bufferedReader = null;
																			try {
																				inputStream = httpUrlConn.getInputStream();								// 将返回的输入流转换成字符串
																				inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
																				bufferedReader = new BufferedReader(inputStreamReader);
																
																				String str = null;
																				while ((str = bufferedReader.readLine()) != null) {
																					buffer.append(str);
																				}
																			} finally { 
																				if (bufferedReader != null) {
																					bufferedReader.close();
																					bufferedReader = null;
																				}
																				if (inputStreamReader != null) {
																					inputStreamReader.close();
																					inputStreamReader = null;
																				}
																				if (inputStream != null) {
																					inputStream.close();
																					inputStream = null;
																				}
																			}
																
																		} finally {
																			if (httpUrlConn != null) {
																				httpUrlConn.disconnect();
																			}
																		}
																		return buffer.toString();
																	}
																}