The sendSMS.ro Java class source is provided for your use or extension

  1. package com.sendsms;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.net.ConnectException;
  8. import java.net.HttpURLConnection;
  9. import java.net.URL;
  10. import java.net.URLEncoder;
  11. import java.text.SimpleDateFormat;
  12. import java.util.Calendar;
  13. import java.util.HashMap;
  14. import java.util.Iterator;
  15. import java.util.Set;
  16.  
  17. import org.json.JSONObject;
  18.  
  19.  
  20. public class Api {
  21.     
  22.     private String apiUrl = "http://api.sendsms.ro/json";
  23.     private String username;
  24.     private String password;
  25.     
  26.     private String encodingScheme = "UTF-8";
  27.     
  28.     private boolean debug = false;
  29.     
  30.     /**
  31.      * Instantiates a new instance of the API
  32.      * 
  33.      * @param username Your sendSMS.ro username
  34.      * @param password Your sendSMS.ro password
  35.      */
  36.     
  37.     public Api(String username, String password) {
  38.         this.username = username;
  39.         this.password = password;
  40.     }
  41.     
  42.     /**
  43.      * Set's the debugging state
  44.      * 
  45.      * (if on it will print lines to the console, default: off)
  46.      * 
  47.      * @param state
  48.      */
  49.     
  50.     public void setDebugging(boolean state) {
  51.         this.debug = state;
  52.     }
  53.     
  54.     private static java.util.HashMap<String, String> createParams(String action) {
  55.         HashMap<String, String> map = new HashMap<String, String>();
  56.         map.put("action", action);
  57.         return map;
  58.     }
  59.     
  60.     private static void addParameter(java.util.Map<String, String> map, String key, String value) {
  61.         if(value != null) {
  62.             map.put(key, value);
  63.         }
  64.     }
  65.     
  66.     private static void addParameter(java.util.Map<String, String> map, String key, Integer value) {
  67.         if(value != null) {
  68.             map.put(key, String.valueOf(value));
  69.         }
  70.     }
  71.     
  72.     
  73.     private static String convertStreamToString(InputStream is) {
  74.         /*
  75.          * To convert the InputStream to String we use the
  76.          * BufferedReader.readLine() method. We iterate until the BufferedReader
  77.          * return null which means there's no more data to read. Each line will
  78.          * appended to a StringBuilder and returned as String.
  79.          */
  80.         BufferedReader reader = new BufferedReader(new InputStreamReader(is));
  81.         StringBuilder sb = new StringBuilder();
  82.  
  83.         String line = null;
  84.         try {
  85.             while ((line = reader.readLine()) != null) {
  86.                 sb.append(line + "\n");
  87.             }
  88.         } catch (IOException e) {
  89.             e.printStackTrace();
  90.         } finally {
  91.             try {
  92.                 is.close();
  93.             } catch (IOException e) {
  94.                 e.printStackTrace();
  95.             }
  96.         }
  97.         return sb.toString();
  98.     }
  99.     
  100.     private JSONObject call(java.util.Map<String, String> map) {
  101.         String workingUrl = apiUrl;
  102.         String key = null;
  103.         String val = null;
  104.         try {
  105.             workingUrl += "?username="+URLEncoder.encode(username, encodingScheme);
  106.             workingUrl += "&password="+URLEncoder.encode(password, encodingScheme);
  107.             
  108.             Set<String> keys = map.keySet();
  109.             Iterator<String> i = keys.iterator();
  110.             
  111.             
  112.             while(i.hasNext()) {
  113.                 key = (String) i.next();
  114.                 val = map.get(key);
  115.                 if(val != null) {
  116.                     workingUrl += "&"+URLEncoder.encode(key, encodingScheme) + "=" +URLEncoder.encode(val, encodingScheme);
  117.                 }
  118.             }
  119.             
  120.             debug("URL to be called "+workingUrl);
  121.             
  122.             URL url = new URL(workingUrl);
  123.             HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
  124.             
  125.  
  126.             String result = convertStreamToString(urlConnection.getInputStream());
  127.             
  128.             if(result != null) {
  129.                 if(result.length() > 0) {
  130.                     /* Something */
  131.                     JSONObject json = new JSONObject(result);
  132.                     return json;
  133.                 }
  134.             }
  135.         } catch(ConnectException e) {
  136.             debug("Connection error "+ e.getMessage());
  137.         } catch(Exception e) {
  138.             e.printStackTrace();
  139.         }
  140.         
  141.         return null;
  142.     }
  143.     
  144.     private boolean validateResult(JSONObject json) {
  145.         if(json != null) {
  146.             try {
  147.                 int status = json.getInt("status");
  148.             
  149.                 if(status >= 0) {
  150.                     /* OK! */
  151.                     return true;
  152.                 }
  153.                 debug("result was "+json.toString());
  154.             } catch(Exception e) {
  155.                 e.printStackTrace();
  156.             }
  157.         }
  158.         
  159.         return false;
  160.     }
  161.     
  162.     private void debug(String data) {
  163.         if(this.debug) {
  164.             Calendar cal = Calendar.getInstance();
  165.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  166.             String str = "[" + sdf.format(cal.getTime()) + "] "+data;
  167.             System.out.println(str);
  168.         }
  169.     }
  170.     
  171.     /**
  172.      * Send's a message via sendSMS.ro
  173.      * 
  174.      * @param to The destination of the message
  175.      * @param text The text of the message
  176.      * @param from The source of the message (where the user will see it came from)
  177.      * @param report_mask Delivery report mask (See API documentation)
  178.      * @param report_url Delivery report URL (See API documentation)
  179.      * @param charset Character set encoding (default: UTF-8)
  180.      * @param data_coding Data coding (See API documentation)
  181.      * @return
  182.      */
  183.     public String message_send(String to, String text, String from, Integer report_mask, String report_url, String charset, Integer data_coding) {
  184.         HashMap<String, String> map = new HashMap<String, String>();
  185.         addParameter(map, "action", "message_send");
  186.         addParameter(map, "to", to);
  187.         addParameter(map, "text", text);
  188.         addParameter(map, "from", from);
  189.         addParameter(map, "report_mask", report_mask);
  190.         addParameter(map, "report_url", report_url);
  191.         addParameter(map, "charset", charset);
  192.         addParameter(map, "data_coding", data_coding);
  193.         
  194.         JSONObject result = call(map);
  195.         
  196.         if(validateResult(result)) {
  197.             /* Return the message ID */
  198.             try {
  199.                 return result.getString("details");
  200.             } catch(Exception e) {
  201.                 e.printStackTrace();
  202.             }
  203.         }
  204.         
  205.         return null;
  206.     }
  207.     
  208.     /**
  209.      * Check your balance
  210.      * 
  211.      * @return The balance
  212.      */
  213.     public Double user_get_balance() {
  214.         HashMap<String, String> map = createParams("user_get_balance");
  215.         JSONObject result = call(map);
  216.         if(validateResult(result)) {
  217.             try {
  218.                 return Double.valueOf(result.getDouble("details"));
  219.             } catch(Exception e) {
  220.                 e.printStackTrace();
  221.             }
  222.         }
  223.         return null;
  224.     }
  225.     
  226.     /**
  227.      * Check the status of a message
  228.      * @param message_id The message ID you wish to check
  229.      * @return A JSONObject containing keys status, cost and parts see ApiExample.java
  230.      */
  231.     public JSONObject message_status(String message_id) {
  232.         HashMap<String, String> map = createParams("message_status");
  233.         addParameter(map, "message_id", message_id);
  234.         JSONObject result = call(map);
  235.         if (validateResult(result)) {
  236.             try {
  237.                 return result.getJSONObject("details");
  238.             } catch (Exception e) {
  239.                 e.printStackTrace();
  240.             }
  241.         }
  242.         return null;
  243.     }
  244.     
  245.     
  246.     
  247.     
  248.     
  249.     
  250.  
  251. }