src/de/ub0r/android/websms/connector/sms/CommandReceiverSMS.java

   1 /*
   2  * Copyright (C) 2010 Felix Bechstein
   3  *
   4  * This file is part of WebSMS.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it under
   7  * the terms of the GNU General Public License as published by the Free Software
   8  * Foundation; either version 3 of the License, or (at your option) any later
   9  * version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  14  * details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program; If not, see <http://www.gnu.org/licenses/>.
  18  */
  19 package de.ub0r.android.websms.connector.sms;
  20
  21 import java.util.ArrayList;
  22
  23 import android.content.BroadcastReceiver;
  24 import android.content.Context;
  25 import android.content.Intent;
  26 import android.content.SharedPreferences;
  27 import android.preference.PreferenceManager;
  28 import android.telephony.gsm.SmsManager;
  29 import android.util.Log;
  30 import android.widget.Toast;
  31 import de.ub0r.android.andGMXsms.R;
  32 import de.ub0r.android.andGMXsms.Connector.WebSMSException;
  33 import de.ub0r.android.websms.connector.ConnectorCommand;
  34 import de.ub0r.android.websms.connector.ConnectorSpec;
  35 import de.ub0r.android.websms.connector.Constants;
  36 import de.ub0r.android.websms.connector.ConnectorSpec.SubConnectorSpec;
  37
  38 /**
  39  * Receives commands coming as broadcast from WebSMS.
  40  *
  41  * @author flx
  42  */
  43 @SuppressWarnings("deprecation")
  44 public class CommandReceiverSMS extends BroadcastReceiver {
  45         /** Tag for debug output. */
  46         private static final String TAG = "WebSMS.sms";
  47
  48         /** Preference key: enabled. */
  49         private static final String PREFS_ENABLED = "enable_sms";
  50
  51         /** Internal {@link ConnectorSpec}. */
  52         private static ConnectorSpec conector = null;
  53
  54         /**
  55          * Init ConnectorSpec.
  56          *
  57          * @param context
  58          *            context
  59          * @return ConnectorSpec
  60          */
  61         private static synchronized ConnectorSpec getSpecs(final Context context) {
  62                 if (conector == null) {
  63                         conector = new ConnectorSpec(TAG, context
  64                                         .getString(R.string.connector_sms_name));
  65                         conector.setAuthor(// .
  66                                         context.getString(R.string.connector_sms_author));
  67                         conector.setBalance(null);
  68                         conector.setPrefsIntent(null);
  69                         conector.setPrefsTitle(null);
  70                         conector.setCapabilities(ConnectorSpec.CAPABILITIES_SEND);
  71                         conector.addSubConnector(TAG, conector.getName(),
  72                                         SubConnectorSpec.FEATURE_MULTIRECIPIENTS);
  73                 }
  74                 final SharedPreferences p = PreferenceManager
  75                                 .getDefaultSharedPreferences(context);
  76                 if (p.getBoolean(PREFS_ENABLED, false)) {
  77                         conector.setReady();
  78                 } else {
  79                         conector.setStatus(ConnectorSpec.STATUS_INACTIVE);
  80                 }
  81                 return conector;
  82         }
  83
  84         /**
  85          * Send a message.
  86          *
  87          * @param command
  88          *            command comming from intent
  89          * @throws WebSMSException
  90          *             WebSMSException
  91          */
  92         private void send(final ConnectorCommand command) throws WebSMSException {
  93                 try {
  94                         SmsManager sm = SmsManager.getDefault();
  95                         for (String t : command.getRecipients()) {
  96                                 ArrayList<String> messages = sm
  97                                                 .divideMessage(command.getText());
  98                                 sm.sendMultipartTextMessage(t, null, messages, null, null);
  99                                 for (String m : messages) {
 100                                         Log.d(TAG, "send sms: " + t + " text: " + m);
 101                                 }
 102                         }
 103                 } catch (Exception e) {
 104                         throw new WebSMSException(e.toString());
 105                 }
 106         }
 107
 108         /**
 109          * Send INFO Broadcast back to WebSMS.
 110          *
 111          * @param context
 112          *            context
 113          * @param specs
 114          *            {@link ConnectorSpec}; if null, getSpecs() is called to get
 115          *            them
 116          */
 117         private void sendInfo(final Context context, final ConnectorSpec specs) {
 118                 ConnectorSpec c = specs;
 119                 if (c == null) {
 120                         c = getSpecs(context);
 121                 }
 122                 final Intent i = new Intent(Constants.ACTION_CONNECTOR_INFO);
 123                 specs.setToIntent(i);
 124                 Log.d(TAG, "send broadcast: " + i.getAction());
 125                 context.sendBroadcast(i);
 126         }
 127
 128         /**
 129          * {@inheritDoc}
 130          */
 131         @Override
 132         public final void onReceive(final Context context, final Intent intent) {
 133                 final String action = intent.getAction();
 134                 Log.d(TAG, "action: " + action);
 135                 if (action == null) {
 136                         return;
 137                 }
 138                 if (Constants.ACTION_CONNECTOR_UPDATE.equals(action)) {
 139                         this.sendInfo(context, null);
 140                 } else if (Constants.ACTION_CONNECTOR_RUN_SEND.equals(action)) {
 141                         final ConnectorCommand command = new ConnectorCommand(intent);
 142                         if (command.getType() == ConnectorCommand.TYPE_SEND) {
 143                                 final ConnectorSpec specs = CommandReceiverSMS
 144                                                 .getSpecs(context);
 145                                 if (specs.hasStatus(ConnectorSpec.STATUS_READY)) {
 146                                         // check internal status
 147                                         try {
 148                                                 this.send(command);
 149                                         } catch (WebSMSException e) {
 150                                                 Log.e(TAG, null, e);
 151                                                 Toast.makeText(context,
 152                                                                 specs.getName() + ": " + e.getMessage(),
 153                                                                 Toast.LENGTH_LONG).show();
 154                                         } finally {
 155                                                 this.sendInfo(context, specs);
 156                                         }
 157                                 }
 158                         }
 159                 }
 160         }
 161 }