Enable sending of SMSMessages longer than 160 characters, with sent and delivery confirmation (#20)

* added files to .gitignore

* removed modules.xml, as it was added to .gitignore

* added to .gitignore all patterns present in default .gitignore generated by Android Studio

* checkSetup() is not performed for messages sent without listeners

* messages too long to fit into a single SMS are split into multiple messages and sent (still have to implement passing of PendingIntents)

* implemented sent confirmation for multipart text message, code needs to be polished and optimized

* removed duplicate `for` cycle

* inglobated setState() method into setReceived()

* removed useless check for null listener, as it cannot be null

* fixed specification, added TODO

* removed unused import

* changed HIDDEN_CHARACTER from a Unicode character to a GSM character;
removed useless intentAction local variable;
fixed import in a test.

* added a TODO;
now when SMSSentBroadcastReceiver calls a listener because message sending failed, it passes to the listener the SentState with most occurrences

* improved comments and formatting

* removed duplicate TODO

* fixed comments and TODOs

* added method reconstructMessage()

* fixed TODOs and authors

* removed usage of WeakReference<>

* improved performance of method onReceive(), now sentState given to the listener is not the one with most occurrences, but the first one to contain an error.

* added a timestamp to Message to distinguish messages with equal Peer and content but sent (or received) in different moments, also added methods equals() and hashCode() to allow comparison of messages;
bumped minimum SDK version to 19 (Android 4.4 KitKat, released in 2013) to allow usage of Objects.hash().

* modified SMSReceivedBroadcastReceiver to handle multi-part text messages;
SMSPeer accepts null or empty Strings in its constructors, as messages can be received by unknown numbers.

* added author

* added check for GSM characters, for now if the message contains other characters it won't be considered valid

* removed timestamp, as it's not actually useful

* removed sentState field from SMSPart, as it's now useless

* use binary search on ordered array messageParts instead of linear search

* fixed TODOs; formatting

* modified SMSDeliveredBroadcastReceiver to handle multi-part text messages;
SMSHandler now handles all messages as multi-part text messages (composed by only 1 part if they fit a single SMS);
removed handling of single SMS messages from SMSSentBroadcastReceiver

* fixed documentation

* removed useless multiplication in SMSPeer.hashCode()

* added TODOs

* added zeroes padding to messageCounter when converted to a String, to make binary searches on intent actions' names work correctly;
converted messageCounter to a long, to avoid overflows when intents are being created too quickly.

* fixed GSM characters regex

* split GSM_CHARACTERS_REGEX into two regex, to avoid doing identical checks multiple times when looking for characters from the GSM extension set;
checkMessageText() correctly parses messages to find if they fit MAX_MSG_TEXT_LEN

* moved SMSPeer.telephoneNumber validity check to when messages are sent, because we might receive SMS messages from peers who don't have a valid phone number (such as carriers)

* fixed a comparison in SMSManager;
added TODOs to remind me of classes to test;
started writing instrumented test for SMS reception.

* first successful attempt at receiving a dummy SMS message, however this method relies on SMSManager.getInstance().sendMessage() working correctly.

* marked tests in SMSPeerTest which need to be moved to SMSManager tests;
used Mockito to verify if SMSReceivedBroadcastReceiver receives messages, but it doesn't work at the moment.

* removed an hardwiring

* Implemented Google Library

Still everything to test

* adapted test to new SMSManager public interface

* Rewritten tests, fixed one class, added emulator exception

* Codacy improvements

* Applied suggested changes:

+ Added author tag (and standardized specs)
* Modified parseMessage() structure
* Extracted exception messages into static final fields
* Extracted RegEx string into static final field
* Used String.format()
- Removed fail() assertions

* updated Mockito; added a TODO; fixed a test.

* renamed test, to be the same as the class it's testing

* updated TODOs

* skeleton of class SMSManagerInstrumentedTest; formatting

* formatting; tried to mock SmsManager in SMSManagerInstrumentedTest, but I can't because final classes cannot be mocked.

* deleted all instrumented tests because I won't be able to get them to work before the review

* removal of code used for instrumented tests

* removal of code used for instrumented tests

* imported powermock, removed methods used only in tests

* used PowerMock in test to mock static method SmsManager.getDefault()

* added TODO; added author; formatting; moved tests on Peer's number validity to SMSManagerTest, because the check happens when the SMSMessage is sent.

* added tests for messages containing Unicode characters and characters from the GSM extension table.

* Update README.md

* Changes:

+ Added exception types
- Removed throws clause on unchecked exceptions
* Enhanced tests
* Updated gradle

* added tests for messages containing Unicode characters and characters from the GSM extension table.

* added test for addPadding()

* improved performance of checkMessageTest()

* improved code after automated inspection

* formatting; added author.

* fixed imports

* improved performance of checkMessageText by avoiding multiple calls of String.matches() when the message contains Unicode characters.

* fixed documentation of SMSPeer

* improved performance of checkMessageText() by removing a useless check

* removed a useless variable, improved documentation

* fixes requested by Mattia Fanan in his code review: #20

* removed unused import

* removed `equals()` and `hashCode()` from interface `Message`

* Test Fixes:

Major fixes:
* Overridden prefix auto-detection
Small fixes:
* Syntax and typo fixes

* changes requested by Marco Mariotto in his code review: #20

* fixed errors resulting from merge

* removed useless imports

* added missing specifications.

* added message to exception thrown in SMSManager

* removed SMSPart and SMSPartTest, since BroadcastReceivers now use a counter; removed method addPadding() in SMSManager since its only use was for binary searches on SMSPart arrays

* combined nested if statements

* renamed all occurrences of UTF-16 to UCS-2, since that's the name of the encoding used in SMS messages

* removed Map used to keep track of different messages coming from different addresses, since that can't happen;
reorganized methods and added try-catch statements for possible exceptions, as in AOSP's Messaging app.

* formatting

* removed duplicate import

* fixed specifications

Co-authored-by: Cogno-Marco <marco.cognolato.98@gmail.com>
Co-authored-by: Matteo Carnelos <matteo.carnelos@studenti.unipd.it>

Author: 3 people

app/build.gradle

@@ -5,7 +5,7 @@ android {
     buildToolsVersion "29.0.2"
     defaultConfig {
         applicationId 'com.eis.smslibproject'
-        minSdkVersion 15
+        minSdkVersion 19
         targetSdkVersion 29
         versionCode 1
         versionName "1.0"

smslibrary/build.gradle

@@ -6,7 +6,7 @@ android {
 
 
     defaultConfig {
-        minSdkVersion 15
+        minSdkVersion 19
         targetSdkVersion 29
         versionCode 1
         versionName "1.0"
@@ -37,5 +37,7 @@ dependencies {
     testImplementation 'org.mockito:mockito-core:1.10.19'
     androidTestImplementation 'androidx.test.ext:junit:1.1.1'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
-    implementation 'com.github.CremaLuca:android-preferences:2.3'
+    testImplementation 'org.powermock:powermock-core:1.6.6'
+    testImplementation 'org.powermock:powermock-module-junit4:1.6.6'
+    testImplementation 'org.powermock:powermock-api-mockito:1.6.6'
 }

smslibrary/src/main/java/com/eis/communication/Message.java

@@ -3,20 +3,23 @@
 import java.io.Serializable;
 
 /**
- * Encapsulation of a message in the network
+ * Encapsulates data to be sent (or received) to (from) a certain peer.
+ *
  * @param <D> Data to be transmitted
  * @param <P> Peer type of users of the network
  */
-public interface  Message<D, P extends Peer> extends Serializable {
+public interface Message<D, P extends Peer> extends Serializable {
 
     /**
-     * Retrieves the data sent or to be sent in the network
+     * Retrieves the data received or to be sent in the network
+     *
      * @return data contained in this message
      */
     D getData();
 
     /**
-     * Retrieves the sender or the destination
+     * Retrieves the sender or the destination of this message
+     *
      * @return Peer associated with this message
      */
     P getPeer();

smslibrary/src/main/java/com/eis/smslibrary/SMSCore.java

@@ -12,31 +12,10 @@
  * Wrapper for the {@link android.telephony} library.
  * This class is only used to interface with the core sms library of Android.
  *
- * @author Luca Crema, Marco Cognolato
+ * @author Luca Crema, Marco Cognolato, Giovanni Velludo
  */
 final class SMSCore {
 
-    static SmsManager manager;
-
-    /**
-     * Sets up a given valid custom manager
-     * @param manager The custom manager to set up to send messages
-     *
-     * @author Marco Cognolato
-     */
-    static void setManager(SmsManager manager){
-        SMSCore.manager = manager;
-    }
-
-    /**
-     * @return Returns the pre-set up manager if not null, else returns the default manager
-     *
-     * @author Marco Cognolato
-     */
-    private static SmsManager getManager(){
-        return manager == null ? SmsManager.getDefault() : manager;
-    }
-
     /**
      * Calls the library method to send a single message
      *
@@ -46,7 +25,7 @@ private static SmsManager getManager(){
      * @param deliveredPI {@link PendingIntent} for a broadcast on message received, can be null
      */
     static void sendMessage(@NonNull final String message, @NonNull final String phoneNumber, @Nullable final PendingIntent sentPI, @Nullable final PendingIntent deliveredPI) {
-        getManager().sendTextMessage(phoneNumber, null, message, sentPI, deliveredPI);
+        SmsManager.getDefault().sendTextMessage(phoneNumber, null, message, sentPI, deliveredPI);
     }
 
     /**
@@ -58,7 +37,7 @@ static void sendMessage(@NonNull final String message, @NonNull final String pho
      * @param deliveredPIs {@link ArrayList}  of pending intents for a broadcast on message delivered, can be null
      */
     static void sendMessages(@NonNull final ArrayList<String> messages, @NonNull final String phoneNumber, @Nullable final ArrayList<PendingIntent> sentPIs, @Nullable final ArrayList<PendingIntent> deliveredPIs) {
-        getManager().sendMultipartTextMessage(phoneNumber, null, messages, sentPIs, deliveredPIs);
+        SmsManager.getDefault().sendMultipartTextMessage(phoneNumber, null, messages, sentPIs, deliveredPIs);
     }
 
 }

smslibrary/src/main/java/com/eis/smslibrary/SMSDeliveredBroadcastReceiver.java

@@ -9,32 +9,44 @@
 
 import com.eis.smslibrary.listeners.SMSDeliveredListener;
 
+import java.util.ArrayList;
+
 /**
  * Broadcast receiver for delivered messages, called by Android Library.
  * Must be instantiated and set as receiver with context.registerReceiver(...).
  * There has to be one different DeliveredBroadcastReceiver per message sent,
  * so every IntentFilter name has to be different
  *
- * @author Marco Cognolato
+ * @author Marco Cognolato, Giovanni Velludo
  */
 public class SMSDeliveredBroadcastReceiver extends BroadcastReceiver {
-    private SMSDeliveredListener listener;
-    private SMSMessage message;
+
+    private final SMSDeliveredListener listener;
+    private final SMSMessage message;
+    private short partsToDeliverCounter;
 
     /**
      * Constructor for the custom {@link BroadcastReceiver}.
      *
-     * @param message  that will be sent.
-     * @param listener to be called when the operation is completed.
+     * @param parts    the parts of the message to be delivered.
+     * @param listener the listener to be called when the operation is completed
+     * @param peer     the peer to whom the message will be delivered.
      */
-    SMSDeliveredBroadcastReceiver(@NonNull final SMSMessage message, @NonNull final SMSDeliveredListener listener) {
+    SMSDeliveredBroadcastReceiver(@NonNull final ArrayList<String> parts,
+                                  @NonNull final SMSDeliveredListener listener,
+                                  @NonNull final SMSPeer peer) {
+        StringBuilder fullMessageText = new StringBuilder();
+        for (String part : parts) {
+            fullMessageText.append(part);
+        }
         this.listener = listener;
-        this.message = message;
+        this.message = new SMSMessage(peer, fullMessageText.toString());
+        this.partsToDeliverCounter = (short) parts.size(); // they can't be more than 255
     }
 
     /**
      * This method is subscribed to the intent of a message delivered, and will be called whenever a message is delivered using this library.
-     * It interprets the state of the message delivering: {@link SMSMessage.DeliveredState#MESSAGE_DELIVERED} if it has been correctly sent,
+     * It interprets the state of the message delivering: {@link SMSMessage.DeliveredState#MESSAGE_DELIVERED} if it has been correctly delivered,
      * some other state otherwise; then calls the listener and unregisters itself.
      */
     @Override
@@ -53,9 +65,9 @@ public void onReceive(Context context, Intent intent) {
                 break;
         }
 
-        if (listener != null) //extra check, even though listener should never be null
-            listener.onSMSDelivered(message, deliveredState);
-
+        if (deliveredState == SMSMessage.DeliveredState.MESSAGE_DELIVERED &&
+                --partsToDeliverCounter > 0) return;
+        listener.onSMSDelivered(message, deliveredState);
         context.unregisterReceiver(this);
     }
 }

smslibrary/src/main/java/com/eis/smslibrary/SMSManager.java

@@ -4,21 +4,27 @@
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
+import android.telephony.SmsManager;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.eis.communication.CommunicationManager;
+import com.eis.smslibrary.exceptions.InvalidTelephoneNumberException;
 import com.eis.smslibrary.listeners.SMSDeliveredListener;
 import com.eis.smslibrary.listeners.SMSReceivedServiceListener;
 import com.eis.smslibrary.listeners.SMSSentListener;
 
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
+import java.util.ArrayList;
+
 import it.lucacrema.preferences.PreferencesManager;
 
 /**
  * Communication handler for SMSs. It's a Singleton, you should
  * access it with {@link #getInstance}
  *
- * @author Luca Crema, Marco Mariotto, Alberto Ursino, Marco Tommasini, Marco Cognolato
+ * @author Luca Crema, Marco Mariotto, Alberto Ursino, Marco Tommasini, Marco Cognolato, Giovanni Velludo
+ * @since 29/11/2019
  */
 @SuppressWarnings({"WeakerAccess", "unused"})
 public class SMSManager implements CommunicationManager<SMSMessage> {
@@ -43,7 +49,7 @@ public class SMSManager implements CommunicationManager<SMSMessage> {
      * same action name for every message we would have a conflict and we wouldn't
      * know what message has been sent
      */
-    private int messageCounter;
+    private long messageCounter;
 
     /**
      * Private constructor for Singleton
@@ -67,37 +73,41 @@ public static SMSManager getInstance() {
      * Requires {@link android.Manifest.permission#SEND_SMS}
      *
      * @param message to be sent in the channel to a peer
+     * @throws InvalidTelephoneNumberException If message.peer.invalidityReason is not null.
      */
     @Override
-    public void sendMessage(final @NonNull SMSMessage message) {
+    public void sendMessage(final @NonNull SMSMessage message)
+            throws InvalidTelephoneNumberException {
         sendMessage(message, null, null, null);
     }
 
     /**
-     * Sends a message to a destination peer via SMS then
-     * calls the listener.
+     * Sends a message to a destination peer via SMS then calls the listener.
+     * Requires {@link android.Manifest.permission#SEND_SMS}
      *
      * @param message      to be sent in the channel to a peer
      * @param sentListener called on message sent or on error, can be null
      * @param context      The context of the application used to setup the listener
+     * @throws InvalidTelephoneNumberException If message.peer.invalidityReason is not null.
      */
     public void sendMessage(final @NonNull SMSMessage message,
                             final @Nullable SMSSentListener sentListener,
-                            Context context) {
+                            Context context) throws InvalidTelephoneNumberException {
         sendMessage(message, sentListener, null, context);
     }
 
     /**
-     * Sends a message to a destination peer via SMS then
-     * calls the listener.
+     * Sends a message to a destination peer via SMS then calls the listener.
+     * Requires {@link android.Manifest.permission#SEND_SMS}
      *
      * @param message           to be sent in the channel to a peer
      * @param deliveredListener called on message delivered or on error, can be null
      * @param context           The context of the application used to setup the listener
+     * @throws InvalidTelephoneNumberException If message.peer.invalidityReason is not null.
      */
     public void sendMessage(final @NonNull SMSMessage message,
                             final @Nullable SMSDeliveredListener deliveredListener,
-                            Context context) {
+                            Context context) throws InvalidTelephoneNumberException {
         sendMessage(message, null, deliveredListener, context);
     }
 
@@ -109,56 +119,78 @@ public void sendMessage(final @NonNull SMSMessage message,
      * @param sentListener      called on message sent or on error, can be null
      * @param deliveredListener called on message delivered or on error, can be null
      * @param context           The context of the application used to setup the listener
+     * @throws InvalidTelephoneNumberException If message.peer.invalidityReason is not null.
      */
     public void sendMessage(final @NonNull SMSMessage message,
                             final @Nullable SMSSentListener sentListener,
                             final @Nullable SMSDeliveredListener deliveredListener,
-                            Context context) {
-        PendingIntent sentPI = setupNewSentReceiver(message, sentListener, context);
-        PendingIntent deliveredPI = setupNewDeliverReceiver(message, deliveredListener, context);
-        SMSCore.sendMessage(getSMSContent(message), message.getPeer().getAddress(), sentPI, deliveredPI);
+                            Context context) throws InvalidTelephoneNumberException {
+        if (message.getPeer().getInvalidityReason() != null) {
+            InvalidTelephoneNumberException.Type invReason =
+                    message.getPeer().getInvalidityReason();
+            String invMessage = message.getPeer().getInvalidityMessage();
+            throw new InvalidTelephoneNumberException(invReason, invMessage);
+        }
+        ArrayList<String> texts = SmsManager.getDefault().divideMessage(getSMSContent(message));
+        ArrayList<PendingIntent> sentPIs =
+                setupNewSentReceiver(texts, sentListener, message.getPeer(), context);
+        ArrayList<PendingIntent> deliveredPIs =
+                setupNewDeliverReceiver(texts, deliveredListener, message.getPeer(), context);
+        SMSCore.sendMessages(texts, message.getPeer().getAddress(), sentPIs, deliveredPIs);
     }
 
     /**
      * Creates a new {@link SMSSentBroadcastReceiver} and registers it to receive broadcasts
-     * with action {@value SENT_MESSAGE_INTENT_ACTION}
+     * with actions {@value SENT_MESSAGE_INTENT_ACTION}
      *
-     * @param message  that will be sent
-     * @param listener to call on broadcast received
-     * @param context  The context of the application used to setup the listener
-     * @return a {@link PendingIntent} to be passed to SMSCore
+     * @param texts    the parts of the message to be sent.
+     * @param listener the listener to call on broadcast received.
+     * @param context  the context of the application used to setup the listener
+     * @return an {@link ArrayList} of {@link PendingIntent} to be passed to SMSCore.
      */
-    private PendingIntent setupNewSentReceiver(final @NonNull SMSMessage message,
-                                               final @Nullable SMSSentListener listener,
-                                               Context context) {
+    private ArrayList<PendingIntent> setupNewSentReceiver(
+            final @NonNull ArrayList<String> texts, final @Nullable SMSSentListener listener,
+            final @NonNull SMSPeer peer, Context context) {
         if (listener == null || context == null)
-            return null; //Doesn't make any sense to have a BroadcastReceiver if there is no listener or context
+            return null; //Doesn't make any sense to have a BroadcastReceiver if there is no listener
 
-        SMSSentBroadcastReceiver onSentReceiver = new SMSSentBroadcastReceiver(message, listener);
-        String actionName = SENT_MESSAGE_INTENT_ACTION + (messageCounter++);
-        context.registerReceiver(onSentReceiver, new IntentFilter(actionName));
-        return PendingIntent.getBroadcast(context, 0, new Intent(actionName), 0);
+        ArrayList<PendingIntent> intents = new ArrayList<>();
+        IntentFilter intentFilter = new IntentFilter();
+        for (String text : texts) {
+            String actionName = SENT_MESSAGE_INTENT_ACTION + messageCounter++;
+            intents.add(PendingIntent.getBroadcast(context, 0, new Intent(actionName), 0));
+            intentFilter.addAction(actionName);
+        }
+        SMSSentBroadcastReceiver onSentReceiver = new SMSSentBroadcastReceiver(texts, listener, peer);
+        context.registerReceiver(onSentReceiver, intentFilter);
+        return intents;
     }
 
     /**
      * Creates a new {@link SMSDeliveredBroadcastReceiver} and registers it to receive broadcasts
-     * with action {@value DELIVERED_MESSAGE_INTENT_ACTION}
+     * with actions {@value DELIVERED_MESSAGE_INTENT_ACTION}
      *
-     * @param message  that will be sent
-     * @param listener to call on broadcast received
-     * @param context  The context of the application used to setup the listener
-     * @return a {@link PendingIntent} to be passed to SMSCore
+     * @param texts    the parts of the message to be delivered.
+     * @param listener the listener to call on broadcast received.
+     * @param context  the context of the application used to setup the listener
+     * @return an {@link ArrayList} of {@link PendingIntent} to be passed to SMSCore.
      */
-    private PendingIntent setupNewDeliverReceiver(final @NonNull SMSMessage message,
-                                                  final @Nullable SMSDeliveredListener listener,
-                                                  Context context) {
+    private ArrayList<PendingIntent> setupNewDeliverReceiver(
+            final @NonNull ArrayList<String> texts, final @Nullable SMSDeliveredListener listener,
+            final @NonNull SMSPeer peer, Context context) {
         if (listener == null || context == null)
             return null; //Doesn't make any sense to have a BroadcastReceiver if there is no listener
 
-        SMSDeliveredBroadcastReceiver onDeliveredReceiver = new SMSDeliveredBroadcastReceiver(message, listener);
-        String actionName = DELIVERED_MESSAGE_INTENT_ACTION + (messageCounter++);
-        context.registerReceiver(onDeliveredReceiver, new IntentFilter(actionName));
-        return PendingIntent.getBroadcast(context, 0, new Intent(actionName), 0);
+        ArrayList<PendingIntent> intents = new ArrayList<>();
+        IntentFilter intentFilter = new IntentFilter();
+        for (String text : texts) {
+            String actionName = DELIVERED_MESSAGE_INTENT_ACTION + messageCounter++;
+            intents.add(PendingIntent.getBroadcast(context, 0, new Intent(actionName), 0));
+            intentFilter.addAction(actionName);
+        }
+        SMSDeliveredBroadcastReceiver onDeliverReceiver = new SMSDeliveredBroadcastReceiver(texts, listener, peer);
+        context.registerReceiver(onDeliverReceiver, intentFilter);
+        return intents;
     }
 
     /**