Get voice-quickstart ready for beta4 release

app/build.gradle

@@ -29,7 +29,7 @@ android {
 
 dependencies {
     testCompile 'junit:junit:4.12'
-    compile 'com.twilio:voice-android:2.0.0-beta3'
+    compile 'com.twilio:voice-android:2.0.0-beta4'
     compile 'com.android.support:design:24.2.1'
     compile 'com.android.support:appcompat-v7:24.2.1'
     compile "com.google.android.gms:play-services-gcm:9.4.0"

app/src/main/java/com/twilio/voice/quickstart/SoundPoolManager.java

@@ -0,0 +1,84 @@
+package com.twilio.voice.quickstart;
+
+import android.content.Context;
+import android.media.AudioManager;
+import android.media.SoundPool;
+
+import static android.content.Context.AUDIO_SERVICE;
+
+public class SoundPoolManager {
+
+    private boolean playing = false;
+    private boolean loaded = false;
+    private float actualVolume;
+    private float maxVolume;
+    private float volume;
+    private AudioManager audioManager;
+    private SoundPool soundPool;
+    private int ringingSoundId;
+    private int ringingStreamId;
+    private int disconnectSoundId;
+    private static SoundPoolManager instance;
+
+    private SoundPoolManager(Context context) {
+
+        // AudioManager audio settings for adjusting the volume
+        audioManager = (AudioManager) context.getSystemService(AUDIO_SERVICE);
+        actualVolume = (float) audioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
+        maxVolume = (float) audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
+        volume = actualVolume / maxVolume;
+
+        // Load the sounds
+        soundPool = new SoundPool(1, AudioManager.STREAM_MUSIC, 0);
+        soundPool.setOnLoadCompleteListener(new SoundPool.OnLoadCompleteListener() {
+            @Override
+            public void onLoadComplete(SoundPool soundPool, int sampleId, int status) {
+                loaded = true;
+            }
+
+        });
+        ringingSoundId = soundPool.load(context, R.raw.incoming, 1);
+        disconnectSoundId = soundPool.load(context, R.raw.disconnect, 1);
+    }
+
+    public static SoundPoolManager getInstance(Context context) {
+        if (instance == null) {
+            instance = new SoundPoolManager(context);
+        }
+        return instance;
+    }
+
+    public void playRinging() {
+        if (loaded && !playing) {
+            ringingStreamId = soundPool.play(ringingSoundId, volume, volume, 1, -1, 1f);
+            playing = true;
+        }
+    }
+
+    public void stopRinging() {
+        if (playing) {
+            soundPool.stop(ringingStreamId);
+            playing = false;
+        }
+    }
+
+    public void playDisconnect() {
+        if (loaded && !playing) {
+            soundPool.play(disconnectSoundId, volume, volume, 1, 0, 1f);
+            playing = false;
+        }
+    }
+
+    public void release() {
+        if (soundPool != null) {
+            soundPool.unload(ringingSoundId);
+            soundPool.unload(disconnectSoundId);
+            soundPool.release();
+            soundPool = null;
+        }
+    }
+
+    public boolean isRinging() {
+        return playing;
+    }
+}

app/src/main/java/com/twilio/voice/quickstart/VoiceActivity.java

@@ -28,12 +28,9 @@
 import com.google.android.gms.common.GoogleApiAvailability;
 import com.koushikdutta.async.future.FutureCallback;
 import com.koushikdutta.ion.Ion;
+import com.twilio.voice.Call;
 import com.twilio.voice.CallException;
-import com.twilio.voice.CallState;
-import com.twilio.voice.IncomingCall;
-import com.twilio.voice.IncomingCallMessage;
-import com.twilio.voice.IncomingCallMessageListener;
-import com.twilio.voice.OutgoingCall;
+import com.twilio.voice.CallInvite;
 import com.twilio.voice.RegistrationException;
 import com.twilio.voice.RegistrationListener;
 import com.twilio.voice.VoiceClient;
@@ -66,11 +63,8 @@ public class VoiceActivity extends AppCompatActivity {
     private FloatingActionButton speakerActionFab;
     private Chronometer chronometer;
 
-    private OutgoingCall activeOutgoingCall;
-    private IncomingCall activeIncomingCall;
-
     public static final String ACTION_SET_GCM_TOKEN = "SET_GCM_TOKEN";
-    public static final String INCOMING_CALL_MESSAGE = "INCOMING_CALL_MESSAGE";
+    public static final String INCOMING_CALL_INVITE = "INCOMING_CALL_INVITE";
     public static final String INCOMING_CALL_NOTIFICATION_ID = "INCOMING_CALL_NOTIFICATION_ID";
     public static final String ACTION_INCOMING_CALL = "INCOMING_CALL";
 
@@ -80,11 +74,11 @@ public class VoiceActivity extends AppCompatActivity {
     private String gcmToken;
     private String accessToken;
     private AlertDialog alertDialog;
+    private CallInvite activeCallInvite;
+    private Call activeCall;
 
     RegistrationListener registrationListener = registrationListener();
-    OutgoingCall.Listener outgoingCallListener = outgoingCallListener();
-    IncomingCall.Listener incomingCallListener = incomingCallListener();
-    IncomingCallMessageListener incomingCallMessageListener = incomingCallMessageListener();
+    Call.Listener callListener = callListener();
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -104,7 +98,7 @@ protected void onCreate(Bundle savedInstanceState) {
 
         /*
          * Setup the broadcast receiver to be notified of GCM Token updates
-         * or incoming call messages in this Activity.
+         * or incoming call invite in this Activity.
          */
         voiceBroadcastReceiver = new VoiceBroadcastReceiver();
         registerReceiver();
@@ -120,11 +114,10 @@ protected void onCreate(Bundle savedInstanceState) {
         setVolumeControlStream(AudioManager.STREAM_VOICE_CALL);
 
         /*
-         * Displays a call dialog if the intent contains an incoming call message
+         * Displays a call dialog if the intent contains a call invite
          */
         handleIncomingCallIntent(getIntent());
 
-
         /*
          * Ensure the microphone permission is enabled
          */
@@ -148,35 +141,6 @@ private void startGCMRegistration() {
         }
     }
 
-    private IncomingCallMessageListener incomingCallMessageListener() {
-        return new IncomingCallMessageListener() {
-            @Override
-            public void onIncomingCall(IncomingCall incomingCall) {
-                Log.d(TAG, "Incoming call from " + incomingCall.getFrom());
-                activeIncomingCall = incomingCall;
-                alertDialog = createIncomingCallDialog(VoiceActivity.this,
-                        incomingCall,
-                        answerCallClickListener(),
-                        cancelCallClickListener());
-                alertDialog.show();
-            }
-
-            @Override
-            public void onIncomingCallCancelled(IncomingCall incomingCall) {
-                Log.d(TAG, "Incoming call from " + incomingCall.getFrom() + " was cancelled");
-                if(activeIncomingCall != null &&
-                        incomingCall.getCallSid() == activeIncomingCall.getCallSid() &&
-                        incomingCall.getState() == CallState.PENDING) {
-                    activeIncomingCall = null;
-                    if (alertDialog != null) {
-                        alertDialog.dismiss();
-                    }
-                }
-            }
-
-        };
-    }
-
     private RegistrationListener registrationListener() {
         return new RegistrationListener() {
             @Override
@@ -191,42 +155,22 @@ public void onError(RegistrationException error, String accessToken, String gcmT
         };
     }
 
-    private OutgoingCall.Listener outgoingCallListener() {
-        return new OutgoingCall.Listener() {
+    private Call.Listener callListener() {
+        return new Call.Listener() {
             @Override
-            public void onConnected(OutgoingCall outgoingCall) {
+            public void onConnected(Call call) {
                 Log.d(TAG, "Connected");
+                activeCall = call;
             }
 
             @Override
-            public void onDisconnected(OutgoingCall outgoingCall) {
+            public void onDisconnected(Call call) {
                 resetUI();
                 Log.d(TAG, "Disconnect");
             }
 
             @Override
-            public void onDisconnected(OutgoingCall outgoingCall, CallException error) {
-                resetUI();
-                Log.e(TAG, String.format("Error: %d, %s", error.getErrorCode(), error.getMessage()));
-            }
-        };
-    }
-
-    private IncomingCall.Listener incomingCallListener() {
-        return new IncomingCall.Listener() {
-            @Override
-            public void onConnected(IncomingCall incomingCall) {
-                Log.d(TAG, "Connected");
-            }
-
-            @Override
-            public void onDisconnected(IncomingCall incomingCall) {
-                resetUI();
-                Log.d(TAG, "Disconnected");
-            }
-
-            @Override
-            public void onDisconnected(IncomingCall incomingCall, CallException error) {
+            public void onDisconnected(Call call, CallException error) {
                 resetUI();
                 Log.e(TAG, String.format("Error: %d, %s", error.getErrorCode(), error.getMessage()));
             }
@@ -273,10 +217,30 @@ protected void onPause() {
         isReceiverRegistered = false;
     }
 
+    @Override
+    public void onDestroy() {
+        SoundPoolManager.getInstance(this).release();
+        super.onDestroy();
+    }
+
     private void handleIncomingCallIntent(Intent intent) {
-        if (intent != null && intent.getAction() != null && intent.getAction() == VoiceActivity.ACTION_INCOMING_CALL) {
-            IncomingCallMessage incomingCallMessage = intent.getParcelableExtra(INCOMING_CALL_MESSAGE);
-            VoiceClient.handleIncomingCallMessage(getApplicationContext(), incomingCallMessage, incomingCallMessageListener);
+
+        if (intent != null && intent.getAction() != null && intent.getAction() == ACTION_INCOMING_CALL) {
+            activeCallInvite = intent.getParcelableExtra(INCOMING_CALL_INVITE);
+            if (!activeCallInvite.isCancelled()) {
+                SoundPoolManager.getInstance(this).playRinging();
+                alertDialog = createIncomingCallDialog(VoiceActivity.this,
+                        activeCallInvite,
+                        answerCallClickListener(),
+                        cancelCallClickListener());
+                alertDialog.show();
+                notificationManager.cancel(intent.getIntExtra(INCOMING_CALL_NOTIFICATION_ID, 0));
+            } else {
+                if (alertDialog != null && alertDialog.isShowing()) {
+                    SoundPoolManager.getInstance(this).stopRinging();
+                    alertDialog.cancel();
+                }
+            }
         }
     }
 
@@ -308,13 +272,9 @@ public void onReceive(Context context, Intent intent) {
                 retrieveAccessToken();
             } else if (action.equals(ACTION_INCOMING_CALL)) {
                 /*
-                 * Remove the notification from the notification drawer
-                 */
-                notificationManager.cancel(intent.getIntExtra(VoiceActivity.INCOMING_CALL_NOTIFICATION_ID, 0));
-                /*
-                 * Handle the incoming call message
+                 * Handle the incoming call invite
                  */
-                VoiceClient.handleIncomingCallMessage(getApplicationContext(), (IncomingCallMessage)intent.getParcelableExtra(INCOMING_CALL_MESSAGE), incomingCallMessageListener);
+                handleIncomingCallIntent(intent);
             }
         }
     }
@@ -336,19 +296,19 @@ private DialogInterface.OnClickListener cancelCallClickListener() {
 
             @Override
             public void onClick(DialogInterface dialogInterface, int i) {
-                activeIncomingCall.reject();
+                activeCallInvite.reject(VoiceActivity.this);
                 alertDialog.dismiss();
             }
         };
     }
 
-    public static AlertDialog createIncomingCallDialog(Context context, IncomingCall incomingCall, DialogInterface.OnClickListener answerCallClickListener, DialogInterface.OnClickListener cancelClickListener) {
+    public static AlertDialog createIncomingCallDialog(Context context, CallInvite callInvite, DialogInterface.OnClickListener answerCallClickListener, DialogInterface.OnClickListener cancelClickListener) {
         AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(context);
         alertDialogBuilder.setIcon(R.drawable.ic_call_black_24dp);
         alertDialogBuilder.setTitle("Incoming Call");
         alertDialogBuilder.setPositiveButton("Accept", answerCallClickListener);
         alertDialogBuilder.setNegativeButton("Reject", cancelClickListener);
-        alertDialogBuilder.setMessage(incomingCall.getFrom() + " is calling.");
+        alertDialogBuilder.setMessage(callInvite.getFrom() + " is calling.");
         return alertDialogBuilder.create();
     }
 
@@ -363,7 +323,7 @@ private View.OnClickListener callActionFabClickListener() {
         return new View.OnClickListener() {
             @Override
             public void onClick(View v) {
-                activeOutgoingCall = VoiceClient.call(getApplicationContext(), accessToken, twiMLParams, outgoingCallListener);
+                activeCall = VoiceClient.call(getApplicationContext(), accessToken, twiMLParams, callListener);
                 setCallUI();
             }
         };
@@ -373,6 +333,7 @@ private View.OnClickListener hangupActionFabClickListener() {
         return new View.OnClickListener() {
             @Override
             public void onClick(View v) {
+                SoundPoolManager.getInstance(VoiceActivity.this).playDisconnect();
                 resetUI();
                 disconnect();
             }
@@ -392,19 +353,16 @@ public void onClick(View v) {
      * Accept an incoming Call
      */
     private void answer() {
-        activeIncomingCall.accept(incomingCallListener);
+        activeCallInvite.accept(VoiceActivity.this, callListener);
     }
 
     /*
      * Disconnect an active Call
      */
     private void disconnect() {
-        if (activeOutgoingCall != null) {
-            activeOutgoingCall.disconnect();
-            activeOutgoingCall = null;
-        } else if (activeIncomingCall != null) {
-            activeIncomingCall.reject();
-            activeIncomingCall = null;
+        if (activeCall != null) {
+            activeCall.disconnect();
+            activeCall = null;
         }
     }