src/de/ub0r/android/websms/connector/common/ConnectorCommand.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
  20 package de.ub0r.android.websms.connector.common;
  21
  22 import java.util.ArrayList;
  23
  24 import android.content.Intent;
  25 import android.os.Bundle;
  26
  27 /**
  28  * A Command send to a Connector.
  29  *
  30  * @author flx
  31  */
  32 public final class ConnectorCommand {
  33
  34         /** Key to find command in a Bundle. */
  35         private static final String EXTRAS_COMMAND = "command";
  36
  37         /** Command: type. */
  38         private static final String TYPE = "command_type";
  39         /** Command: type - bootstrap. */
  40         public static final short TYPE_BOOTSTRAP = 1;
  41         /** Command: type - update. */
  42         public static final short TYPE_UPDATE = 2;
  43         /** Command: type - send. */
  44         public static final short TYPE_SEND = 4;
  45         /** Command: default sender. */
  46         private static final String DEFSENDER = "command_defsender";
  47         /** Command: default prefix. */
  48         private static final String DEFPREFIX = "command_defprefix";
  49         /** Command: recipients. */
  50         private static final String RECIPIENTS = "command_reciepients";
  51         /** Command: text. */
  52         private static final String TEXT = "command_text";
  53         /** Command: flashsms. */
  54         private static final String FLASHSMS = "command_flashsms";
  55         /** Command: timestamp. */
  56         private static final String TIMESTAMP = "command_timestamp";
  57         /** Command: custom sender. */
  58         private static final String CUSTOMSENDER = "command_customsender";
  59
  60         /** {@link Bundle} represents the ConnectorSpec. */
  61         private final Bundle bundle;
  62
  63         /**
  64          * Create command with type update.
  65          *
  66          * @return created command
  67          */
  68         public static ConnectorCommand update() {
  69                 return new ConnectorCommand(TYPE_UPDATE);
  70         }
  71
  72         /**
  73          * Create command with type bootstrap.
  74          *
  75          * @return created command
  76          */
  77         public static ConnectorCommand bootstrap() {
  78                 return new ConnectorCommand(TYPE_BOOTSTRAP);
  79         }
  80
  81         /**
  82          * Create Command with type "send".
  83          *
  84          * @param defPrefix
  85          *            default prefix
  86          * @param defSender
  87          *            default sender
  88          * @param recipients
  89          *            reciepients
  90          * @param text
  91          *            text
  92          * @param flashSMS
  93          *            flashsms
  94          * @param timestamp
  95          *            timestamp for sending
  96          * @param customSender
  97          *            custom sender
  98          * @return created command
  99          */
 100         public static ConnectorCommand send(final String defPrefix,
 101                         final String defSender, final String[] recipients,
 102                         final String text, final boolean flashSMS, final long timestamp,
 103                         final String customSender) {
 104                 ConnectorCommand ret = send(defPrefix, defSender, recipients, text,
 105                                 flashSMS);
 106                 ret.setSendLater(timestamp);
 107                 ret.setCustomSender(customSender);
 108                 return ret;
 109         }
 110
 111         /**
 112          * Create Command with type "send".
 113          *
 114          * @param defPrefix
 115          *            default prefix
 116          * @param defSender
 117          *            default sender
 118          * @param recipients
 119          *            reciepients
 120          * @param text
 121          *            text
 122          * @param flashSMS
 123          *            flashsms
 124          * @return created command
 125          */
 126         public static ConnectorCommand send(final String defPrefix,
 127                         final String defSender, final String[] recipients,
 128                         final String text, final boolean flashSMS) {
 129                 final Bundle b = new Bundle();
 130                 b.putShort(TYPE, TYPE_SEND);
 131                 b.putString(DEFPREFIX, defPrefix);
 132                 b.putString(DEFSENDER, defSender);
 133                 final int l = recipients.length;
 134                 ArrayList<String> r = new ArrayList<String>(l);
 135                 for (int i = 0; i < l; i++) {
 136                         final String s = recipients[i];
 137                         if (s != null && s.trim().length() > 0) {
 138                                 r.add(s);
 139                         }
 140                 }
 141                 b.putStringArray(RECIPIENTS, r.toArray(new String[0]));
 142                 b.putString(TEXT, text);
 143                 b.putBoolean(FLASHSMS, flashSMS);
 144                 b.putLong(TIMESTAMP, -1);
 145                 b.putString(CUSTOMSENDER, null);
 146                 return new ConnectorCommand(b);
 147         }
 148
 149         /**
 150          * Create Command with type.
 151          *
 152          * @param type
 153          *            type
 154          */
 155         private ConnectorCommand(final Short type) {
 156                 this.bundle = new Bundle();
 157                 this.bundle.putShort(TYPE, type);
 158         }
 159
 160         /**
 161          * Create Command from {@link Bundle}.
 162          *
 163          * @param b
 164          *            Bundle
 165          */
 166         private ConnectorCommand(final Bundle b) {
 167                 this.bundle = b;
 168         }
 169
 170         /**
 171          * Create Command from {@link Intent}.
 172          *
 173          * @param i
 174          *            Intent
 175          */
 176         public ConnectorCommand(final Intent i) {
 177                 Bundle e = i.getExtras();
 178                 if (e != null) {
 179                         this.bundle = e.getBundle(EXTRAS_COMMAND);
 180                 } else {
 181                         this.bundle = new Bundle();
 182                 }
 183         }
 184
 185         /**
 186          * Set this {@link ConnectorCommand} to an {@link Intent}. Creates new
 187          * Intent if needed.
 188          *
 189          * @param intent
 190          *            {@link Intent}.
 191          * @return the same {@link Intent}
 192          */
 193         public Intent setToIntent(final Intent intent) {
 194                 Intent i = intent;
 195                 if (i == null) {
 196                         switch (this.getType()) {
 197                         case TYPE_BOOTSTRAP:
 198                                 i = new Intent(CommandReceiver.ACTION_CONNECTOR_RUN_BOOSTRAP);
 199                                 break;
 200                         case TYPE_UPDATE:
 201                                 i = new Intent(CommandReceiver.ACTION_CONNECTOR_RUN_UPDATE);
 202                                 break;
 203                         case TYPE_SEND:
 204                                 i = new Intent(CommandReceiver.ACTION_CONNECTOR_RUN_SEND);
 205                                 break;
 206                         default:
 207                                 return null;
 208                         }
 209                 }
 210                 i.putExtra(EXTRAS_COMMAND, this.getBundle());
 211                 return i;
 212         }
 213
 214         /**
 215          * @return internal bundle
 216          */
 217         public Bundle getBundle() {
 218                 return this.bundle;
 219         }
 220
 221         /**
 222          * @return type
 223          */
 224         public short getType() {
 225                 if (this.bundle != null) {
 226                         return this.bundle.getShort(TYPE);
 227                 } else {
 228                         return 0;
 229                 }
 230         }
 231
 232         /**
 233          * @return default sender
 234          */
 235         public String getDefSender() {
 236                 return this.bundle.getString(DEFSENDER);
 237         }
 238
 239         /**
 240          * @return default prefix
 241          */
 242         public String getDefPrefix() {
 243                 return this.bundle.getString(DEFPREFIX);
 244         }
 245
 246         /**
 247          * @return recipients
 248          */
 249         public String[] getRecipients() {
 250                 return this.bundle.getStringArray(RECIPIENTS);
 251         }
 252
 253         /**
 254          * @return text
 255          */
 256         public String getText() {
 257                 return this.bundle.getString(TEXT);
 258         }
 259
 260         /**
 261          * @return flashsms
 262          */
 263         public boolean getFlashSMS() {
 264                 return this.bundle.getBoolean(FLASHSMS, false);
 265         }
 266
 267         /**
 268          * @return timestamp for sending
 269          */
 270         public long getSendLater() {
 271                 return this.bundle.getLong(TIMESTAMP, -1);
 272         }
 273
 274         /**
 275          * Set timestamp for sending later.
 276          *
 277          * @param timestamp
 278          *            timestamp
 279          */
 280         public void setSendLater(final long timestamp) {
 281                 this.bundle.putLong(TIMESTAMP, timestamp);
 282         }
 283
 284         /**
 285          * @return custom sender
 286          */
 287         public String getCustomSender() {
 288                 return this.bundle.getString(CUSTOMSENDER);
 289         }
 290
 291         /**
 292          * Set custom sender.
 293          *
 294          * @param customSender
 295          *            custom sender
 296          */
 297         public void setCustomSender(final String customSender) {
 298                 this.bundle.putString(CUSTOMSENDER, customSender);
 299         }
 300 }