CATHandler.java
上传用户:shunchung
上传日期:2013-04-07
资源大小:438k
文件大小:11k
源码类别:

手机短信编程

开发平台:

Java

  1. // jSMSEngine API.
  2. // An open-source API package for sending and receiving SMS via a GSM device.
  3. // Copyright (C) 2002-2006, Thanasis Delenikas, Athens/GREECE
  4. // Web Site: http://www.jsmsengine.org
  5. //
  6. // jSMSEngine is a package which can be used in order to add SMS processing
  7. // capabilities in an application. jSMSEngine is written in Java. It allows you
  8. // to communicate with a compatible mobile phone or GSM Modem, and
  9. // send / receive SMS messages.
  10. //
  11. // jSMSEngine is distributed under the LGPL license.
  12. //
  13. // This library is free software; you can redistribute it and/or
  14. // modify it under the terms of the GNU Lesser General Public
  15. // License as published by the Free Software Foundation; either
  16. // version 2.1 of the License, or (at your option) any later version.
  17. // This library is distributed in the hope that it will be useful,
  18. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20. // Lesser General Public License for more details.
  21. // You should have received a copy of the GNU Lesser General Public
  22. // License along with this library; if not, write to the Free Software
  23. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24. //
  25. package org.jsmsengine;
  26. import java.util.logging.*;
  27. /**
  28. This class contains all the AT commands which are used during communication
  29. of the API with the GSM device.<br><br>
  30. This is the generic handler. It should be compatible with all devices. However, "should" is
  31. a big word... Some GSM modems may need slightly different AT commands to work. In this
  32. case, subclassing of CATHandler() is required.<br><br>
  33. <strong>Note for those creating subclassed versions of CATHandler for their own modems:</strong><br>
  34. All methods that are marked as "<strong>***Critical method***</strong>" should be implemented, 
  35. otherwise the jSMSEngine API will not work. The Non-Critical may be left unimplemented - they should 
  36. not affect the normal jSMSEngine API operation.
  37. */
  38. public class CATHandler
  39. {
  40. protected CSerialDriver serialDriver;
  41. protected Logger log;
  42. public CATHandler(CSerialDriver serialDriver, Logger log)
  43. {
  44. this.serialDriver = serialDriver;
  45. this.log = log;
  46. }
  47. /**
  48. Sends a couple of "AT" commands in order to sync with modem.<br>
  49. Useful with auto-baud-detecting GSM devices.<br>
  50. <strong>***Critical method***</strong>
  51. */
  52. public void sync() throws Exception
  53. {
  54. serialDriver.send("ATr");
  55. serialDriver.getResponse();
  56. serialDriver.send("ATr");
  57. serialDriver.getResponse();
  58. }
  59. /**
  60. This command should soft-reset the modem.<br>
  61. Soft-reset is not available for all GSM devices, and the operation is not 
  62. critical.<br>
  63. <strong>***Non-Critical method***</strong>
  64. */
  65. public void reset() throws Exception
  66. {
  67. serialDriver.send("AT+CFUN=1r");
  68. try { Thread.sleep(10000); } catch (Exception e) {}
  69. serialDriver.getResponse();
  70. }
  71. /**
  72. Sets Echo off.<br>
  73. <strong>***Critical method***</strong>
  74. */
  75. public void echoOff() throws Exception
  76. {
  77. serialDriver.send("ATE0r");
  78. serialDriver.getResponse();
  79. }
  80. /**
  81. Other initialization commands.<br>
  82. This is left empty, but you might need to add specific code for your specific modem.<br>
  83. <strong>***Non-Critical method***</strong>
  84. */
  85. public void init() throws Exception
  86. {
  87. }
  88. /**
  89. Sends an "AT" command and waits for response.<br>
  90. <strong>***Critical method***</strong>
  91. @return  True if GSM device responded with "OK".
  92. */
  93. public boolean isAlive() throws Exception
  94. {
  95. serialDriver.send("ATr");
  96. return (serialDriver.getResponse().indexOf("OKr") >= 0);
  97. }
  98. /**
  99. Requests status regarding PIN.<br>
  100. <strong>***Critical method***</strong>
  101. @return  True if GSM device is waiting for PIN to be entered.
  102. */
  103. public boolean waitingForPin() throws Exception
  104. {
  105. serialDriver.send("AT+CPIN?r");
  106. return (serialDriver.getResponse().indexOf("SIM PIN") >= 0);
  107. }
  108. /**
  109. Enters PIN.<br>
  110. <strong>***Critical method***</strong>
  111. @return  True if GSM device unlocked. False if PIN is wrong.
  112. */
  113. public boolean enterPin(String pin) throws Exception
  114. {
  115. serialDriver.send(CUtils.substituteSymbol("AT+CPIN="{1}"r", "{1}", pin));
  116. Thread.sleep(5000);
  117. if (serialDriver.getResponse().indexOf("OKr") >= 0)
  118. {
  119. try { Thread.sleep(10000); } catch (Exception e) {} 
  120. return true;
  121. }
  122. else return false;
  123. }
  124. /**
  125. Sets verbose mode for error reporting.<br>
  126. <strong>***Non-Critical method***</strong>
  127. @return  True if GSM device accepted the option.
  128. */
  129. public boolean setVerboseErrors() throws Exception
  130. {
  131. serialDriver.send("AT+CMEE=1r");
  132. return (serialDriver.getResponse().equalsIgnoreCase("OKr"));
  133. }
  134. /**
  135. Sets PDU operation.<br>
  136. <strong>***Critical method***</strong>
  137. @return  True if GSM device supports PDU operation.
  138. */
  139. public boolean setPduMode() throws Exception
  140. {
  141. serialDriver.send("AT+CMGF=0r");
  142. return (serialDriver.getResponse().equalsIgnoreCase("OKr"));
  143. }
  144. /**
  145. Disable GSM device originated delivery notifications.<br>
  146. <strong>***Critical method***</strong>
  147. @return  True if GSM device disabled notifications.
  148. */
  149. public boolean  disableIndications() throws Exception
  150. {
  151. serialDriver.send("AT+CNMI=0,0,0,0r");
  152. return (serialDriver.getResponse().equalsIgnoreCase("OKr"));
  153. }
  154. /**
  155. Returns the Manufacturer string.<br>
  156. <strong>***Critical method***</strong>
  157. @return  The Manufacturer string.
  158. */
  159. public String getManufacturer() throws Exception
  160. {
  161. serialDriver.send("AT+CGMIr");
  162. return serialDriver.getResponse();
  163. }
  164. /**
  165. Returns the Model string.<br>
  166. <strong>***Critical method***</strong>
  167. @return  The Model string.
  168. */
  169. public String getModel() throws Exception
  170. {
  171. serialDriver.send("AT+CGMMr");
  172. return serialDriver.getResponse();
  173. }
  174. /**
  175. Returns the GSM Device serial number.<br>
  176. <strong>***Critical method***</strong>
  177. @return  The GSM Device serial number.
  178. */
  179. public String getSerialNo() throws Exception
  180. {
  181. serialDriver.send("AT+CGSNr");
  182. return serialDriver.getResponse();
  183. }
  184. /**
  185. Returns the IMSI (International Mobile Subscriber Identity).<br>
  186. <strong>***Critical method***</strong>
  187. @return  The IMSI String.
  188. */
  189. public String getImsi() throws Exception
  190. {
  191. serialDriver.send("AT+CIMIr");
  192. return serialDriver.getResponse();
  193. }
  194. /**
  195. Returns the GSM device software version.<br>
  196. <strong>***Critical method***</strong>
  197. @return  The software version.
  198. */
  199. public String getSwVersion() throws Exception
  200. {
  201. serialDriver.send("AT+CGMRr");
  202. return serialDriver.getResponse();
  203. }
  204. /**
  205. Returns the battery level.<br>
  206. <strong>***Critical method***</strong>
  207. @return  The battery level.
  208. */
  209. public String getBatteryLevel() throws Exception
  210. {
  211. serialDriver.send("AT+CBCr");
  212. return serialDriver.getResponse();
  213. }
  214. /**
  215. Returns the signal level.<br>
  216. <strong>***Critical method***</strong>
  217. @return  The signal level.
  218. */
  219. public String getSignalLevel() throws Exception
  220. {
  221. serialDriver.send("AT+CSQr");
  222. return serialDriver.getResponse();
  223. }
  224. /**
  225. Sets the preferred message storage to Memory.<br>
  226. <strong>***Non-Critical method***</strong>
  227. @return  True if operated succeded.
  228. */
  229. public boolean setStorageMEM() throws Exception
  230. {
  231. serialDriver.send("AT+CPMS="ME"r");
  232. return (serialDriver.getResponse().equalsIgnoreCase("OKr"));
  233. }
  234. /**
  235. Sets the preferred message storage to SIM.<br>
  236. <strong>***Non-Critical method***</strong>
  237. @return  True if operated succeded.
  238. */
  239. public boolean setStorageSIM() throws Exception
  240. {
  241. serialDriver.send("AT+CPMS="SM"r");
  242. return (serialDriver.getResponse().equalsIgnoreCase("OKr"));
  243. }
  244. /**
  245. Switches GSM device to command mode.<br>
  246. <strong>***Critical method***</strong>
  247. */
  248. public void switchToCmdMode() throws Exception
  249. {
  250. serialDriver.send("+++");
  251. serialDriver.clearBuffer();
  252. }
  253. /**
  254. Keeps the GSM link open for sending multiple messages in less time.<br>
  255. Not critical. If this option is supported, message dispatch may be a little 
  256. faster.<br>
  257. <strong>***Non-Critical method***</strong>
  258. @return  True if operated succeded.
  259. */
  260. public boolean keepGsmLinkOpen() throws Exception
  261. {
  262. serialDriver.send("AT+CMMS=1r");
  263. return (serialDriver.getResponse().equalsIgnoreCase("OKr"));
  264. }
  265. /**
  266. Sends a message.<br>
  267. In case of errors, it rerties up to three times to complete the operation 
  268. before it returns failure.<br>
  269. <strong>***Critical method***</strong>
  270. @return  True if operated succeded.
  271. */
  272. public boolean sendMessage(int size, String pdu) throws Exception
  273. {
  274. int responseRetries, errorRetries;
  275. String response;
  276. boolean sent;
  277. errorRetries = 0;
  278. while (true)
  279. {
  280. responseRetries = 0;
  281. serialDriver.send(CUtils.substituteSymbol("AT+CMGS="{1}"r", ""{1}"", "" + size));
  282. Thread.sleep(100);
  283. while (!serialDriver.dataAvailable())
  284. {
  285. responseRetries ++;
  286. if (responseRetries == 4) throw new NoResponseException();
  287. log.log(Level.SEVERE, "ATHandler().SendMessage(): Still waiting for response (I) (" + responseRetries + ")...");
  288. Thread.sleep(5000);
  289. }
  290. responseRetries = 0;
  291. serialDriver.clearBuffer();
  292. serialDriver.send(pdu);
  293. serialDriver.send((char) 26);
  294. response = serialDriver.getResponse();
  295. while (response.length() == 0)
  296. {
  297. responseRetries ++;
  298. if (responseRetries == 4)  throw new NoResponseException();
  299. log.log(Level.SEVERE, "ATHandler().SendMessage(): Still waiting for response (II) (" + responseRetries + ")...");
  300. response = serialDriver.getResponse();
  301. }
  302. if (response.indexOf("OKr") >= 0)
  303. {
  304. sent = true;
  305. break;
  306. }
  307. else if (response.indexOf("CMS ERROR:") >= 0)
  308. {
  309. errorRetries ++;
  310. if (errorRetries == 4)
  311. {
  312. log.log(Level.SEVERE, "GSM CMS Errors: Quit retrying, message lost...");
  313. sent = false;
  314. break;
  315. }
  316. else log.log(Level.SEVERE, "GSM CMS Errors: Possible collision, retrying...");
  317. }
  318. else sent = false;
  319. }
  320. return sent;
  321. }
  322. /**
  323. Returns the list of messages.<br>
  324. <strong>***Critical method***</strong>
  325. @return  True if operated succeded.
  326. */
  327. public String listMessages(int messageClass) throws Exception
  328. {
  329. String command;
  330. switch (messageClass)
  331. {
  332. case CIncomingMessage.CLASS_ALL:
  333. serialDriver.send("AT+CMGL=4r");
  334. break;
  335. case CIncomingMessage.CLASS_REC_UNREAD:
  336. serialDriver.send("AT+CMGL=0r");
  337. break;
  338. case CIncomingMessage.CLASS_REC_READ:
  339. serialDriver.send("AT+CMGL=1r");
  340. break;
  341. case CIncomingMessage.CLASS_STO_UNSENT:
  342. serialDriver.send("AT+CMGL=2r");
  343. break;
  344. case CIncomingMessage.CLASS_STO_SENT:
  345. serialDriver.send("AT+CMGL=3r");
  346. break;
  347. }
  348. return serialDriver.getResponse();
  349. }
  350. /**
  351. Deletes a message from GSM device memory.<br>
  352. <strong>***Critical method***</strong>
  353. @return  True if operated succeded.
  354. */
  355. public boolean deleteMessage(int memIndex) throws Exception
  356. {
  357. serialDriver.send(CUtils.substituteSymbol("AT+CMGD={1}r", "{1}", "" + memIndex));
  358. return (serialDriver.getResponse().equalsIgnoreCase("OKr"));
  359. }
  360. }