voip-callkit 0.0.8 → 1.0.0

package/android/src/main/java/com/test/callkit/androidcall/RetreivedTokenCallback.java

@@ -0,0 +1,5 @@
+package com.test.callkit.androidcall;
+
+public interface RetreivedTokenCallback {
+    public void onTokenRetreived(String token);
+}

package/android/src/main/java/com/test/callkit/androidcall/SettingsActivity.java

@@ -0,0 +1,182 @@
+package com.test.callkit.androidcall;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+
+import android.view.MenuItem;
+
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.ActionBar;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.preference.EditTextPreference;
+import androidx.preference.ListPreference;
+import androidx.preference.PreferenceFragmentCompat;
+
+import com.test.callkit.R;
+import com.twilio.video.AudioCodec;
+import com.twilio.video.G722Codec;
+import com.twilio.video.H264Codec;
+import com.twilio.video.IsacCodec;
+import com.twilio.video.OpusCodec;
+import com.twilio.video.PcmaCodec;
+import com.twilio.video.PcmuCodec;
+import com.twilio.video.VideoCodec;
+import com.twilio.video.Vp8Codec;
+import com.twilio.video.Vp9Codec;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SettingsActivity extends AppCompatActivity {
+  public static final String PREF_AUDIO_CODEC = "audio_codec";
+  public static final String PREF_AUDIO_CODEC_DEFAULT = OpusCodec.NAME;
+  public static final String PREF_VIDEO_CODEC = "video_codec";
+  public static final String PREF_VIDEO_CODEC_DEFAULT = Vp8Codec.NAME;
+  public static final String PREF_SENDER_MAX_AUDIO_BITRATE = "sender_max_audio_bitrate";
+  public static final String PREF_SENDER_MAX_AUDIO_BITRATE_DEFAULT = "0";
+  public static final String PREF_SENDER_MAX_VIDEO_BITRATE = "sender_max_video_bitrate";
+  public static final String PREF_SENDER_MAX_VIDEO_BITRATE_DEFAULT = "0";
+  public static final String PREF_VP8_SIMULCAST = "vp8_simulcast";
+  public static final String PREF_ENABLE_AUTOMATIC_SUBSCRIPTION = "enable_automatic_subscription";
+  public static final boolean PREF_ENABLE_AUTOMATIC_SUBSCRIPTION_DEFAULT = true;
+  public static final boolean PREF_VP8_SIMULCAST_DEFAULT = false;
+
+  private static final String[] VIDEO_CODEC_NAMES =
+    new String[]{Vp8Codec.NAME, H264Codec.NAME, Vp9Codec.NAME};
+
+  private static final String[] AUDIO_CODEC_NAMES =
+    new String[]{
+      IsacCodec.NAME, OpusCodec.NAME, PcmaCodec.NAME, PcmuCodec.NAME, G722Codec.NAME
+    };
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setupActionBar();
+    SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+    SettingsFragment settingsFragment = SettingsFragment.newInstance(sharedPreferences);
+    getSupportFragmentManager()
+      .beginTransaction()
+      .replace(android.R.id.content, settingsFragment)
+      .commit();
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    switch (item.getItemId()) {
+      case android.R.id.home:
+        finish();
+        return true;
+      default:
+        return super.onOptionsItemSelected(item);
+    }
+  }
+
+  private void setupActionBar() {
+    ActionBar actionBar = getSupportActionBar();
+    if (actionBar != null) {
+      // Show the Up button in the action bar.
+      actionBar.setDisplayHomeAsUpEnabled(true);
+    }
+  }
+
+  public static class SettingsFragment extends PreferenceFragmentCompat {
+    private SharedPreferences sharedPreferences;
+
+    public static SettingsFragment newInstance(SharedPreferences sharedPreferences) {
+      SettingsFragment settingsFragment = new SettingsFragment();
+      settingsFragment.sharedPreferences = sharedPreferences;
+
+      return settingsFragment;
+    }
+
+//        @Override
+//        public void onCreatePrefe
+//        ences(Bundle savedInstanceState, String rootKey) {
+//            addPreferencesFromResource(R.xml.settings);
+//            setHasOptionsMenu(true);
+//            setupCodecListPreference(
+//                    AudioCodec.class,
+//                    PREF_AUDIO_CODEC,
+//                    PREF_AUDIO_CODEC_DEFAULT,
+//                    (ListPreference) findPreference(PREF_AUDIO_CODEC));
+//            setupCodecListPreference(
+//                    VideoCodec.class,
+//                    PREF_VIDEO_CODEC,
+//                    PREF_VIDEO_CODEC_DEFAULT,
+//                    (ListPreference) findPreference(PREF_VIDEO_CODEC));
+//            setupSenderBandwidthPreferences(
+//                    PREF_SENDER_MAX_AUDIO_BITRATE,
+//                    PREF_SENDER_MAX_AUDIO_BITRATE_DEFAULT,
+//                    (EditTextPreference) findPreference(PREF_SENDER_MAX_AUDIO_BITRATE));
+//            setupSenderBandwidthPreferences(
+//                    PREF_SENDER_MAX_VIDEO_BITRATE,
+//                    PREF_SENDER_MAX_VIDEO_BITRATE_DEFAULT,
+//                    (EditTextPreference) findPreference(PREF_SENDER_MAX_VIDEO_BITRATE));
+//        }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+      int id = item.getItemId();
+      if (id == android.R.id.home) {
+        startActivity(new Intent(getActivity(), SettingsActivity.class));
+        return true;
+      }
+      return super.onOptionsItemSelected(item);
+    }
+
+    private void setupCodecListPreference(
+      Class codecClass, String key, String defaultValue, ListPreference preference) {
+      List<String> codecEntries = new ArrayList<>();
+      if (codecClass == AudioCodec.class) {
+        Collections.addAll(codecEntries, AUDIO_CODEC_NAMES);
+      } else {
+        Collections.addAll(codecEntries, VIDEO_CODEC_NAMES);
+      }
+
+      // Remove H264 if not supported
+//            CodecUtils utils = new CodecUtils();
+//            if (!utils.isH264Supported()) {
+//                codecEntries.remove(H264Codec.NAME);
+//            }
+      String[] codecStrings = codecEntries.toArray(new String[codecEntries.size()]);
+
+      // Saved value
+      final String value = sharedPreferences.getString(key, defaultValue);
+
+      // Bind values
+      preference.setEntries(codecStrings);
+      preference.setEntryValues(codecStrings);
+      preference.setValue(value);
+      preference.setSummary(value);
+      preference.setOnPreferenceChangeListener(
+        (preference1, newValue) -> {
+          preference1.setSummary(newValue.toString());
+          return true;
+        });
+    }
+
+    @Override
+    public void onCreatePreferences(@Nullable Bundle savedInstanceState, @Nullable String rootKey) {
+
+    }
+
+//        private void setupSenderBandwidthPreferences(
+//                String key, String defaultValue, EditTextPreference editTextPreference) {
+//            String value = sharedPreferences.getString(key, defaultValue);
+//
+//            // Set layout with input type number for edit text
+//            editTextPreference.setDialogLayoutResource(R.layout.preference_dialog_number_edittext);
+//            editTextPreference.setSummary(value);
+//            editTextPreference.setOnPreferenceChangeListener(
+//                    (preference, newValue) -> {
+//                        preference.setSummary(newValue.toString());
+//                        return true;
+//                    });
+//        }
+//    }
+
+  }
+}

package/android/src/main/java/com/test/callkit/androidcall/VoipBackgroundService.java

@@ -0,0 +1,105 @@
+package com.test.callkit.androidcall;
+
+import android.annotation.SuppressLint;
+import android.app.ActivityManager;
+import android.app.KeyguardManager;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.IBinder;
+import android.util.Log;
+
+
+public class VoipBackgroundService extends Service
+{
+    public static boolean isServiceRunningInForeground(Context context, Class<?> serviceClass) {
+        ActivityManager manager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+        for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
+            if (serviceClass.getName().equals(service.service.getClassName())) {
+                if (service.foreground) {
+                    return true;
+                }
+
+            }
+        }
+        return false;
+    }
+
+
+    @Override
+    public IBinder onBind(Intent intent)
+    {
+        return null;
+    }
+
+    @Override
+    public void onTaskRemoved(Intent rootIntent)
+    {
+        super.onTaskRemoved(rootIntent);
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId)
+    {
+        Log.d("MySipService", "onStartCommand");
+        if(intent.hasExtra("connectionId") && intent.hasExtra("username"))
+        {
+            String connectionId = intent.getStringExtra("connectionId");
+            String username = intent.getStringExtra("username");
+            ApiCalls apiCalls =  new ApiCalls();
+            apiCalls.gettwiliotoken(connectionId, new RetreivedTokenCallback() {
+                @SuppressLint("MissingPermission")
+                @Override
+                public void onTokenRetreived(String token) {
+                    Log.d("onTokenRetreived",token);
+                    if(!isServiceRunningInForeground(VoipBackgroundService.this,VoipForegroundService.class)) {
+                        show_call_notification("incoming",token,username,connectionId);
+
+                        KeyguardManager km = (KeyguardManager) getApplicationContext().getSystemService(Context.KEYGUARD_SERVICE);
+                        KeyguardManager.KeyguardLock kl = km.newKeyguardLock("name");
+                        kl.disableKeyguard();
+                    }
+
+                }
+            });
+        }
+        return START_NOT_STICKY;
+    }
+
+
+
+    public void show_call_notification(String action, String token,String username,String roomName)
+    {
+        Log.d("show_call_notification",action);
+        Intent serviceIntent = new Intent(this, VoipForegroundService.class);
+        serviceIntent.setAction(action);
+        serviceIntent.putExtra("token",token);
+        serviceIntent.putExtra("username",username);
+        serviceIntent.putExtra("roomName",roomName);
+
+
+
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+
+            VoipBackgroundService.this.startForegroundService(serviceIntent);
+
+        } else {
+            VoipBackgroundService.this.startService(serviceIntent);
+        }
+    }
+
+
+
+    @Override
+    public void onCreate()
+    {
+        super.onCreate();
+
+
+
+
+    }
+
+}

package/android/src/main/java/com/test/callkit/androidcall/VoipForegroundService.java

@@ -0,0 +1,213 @@
+package com.test.callkit.androidcall;
+
+import android.annotation.SuppressLint;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.IBinder;
+import android.os.Vibrator;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationCompat;
+
+import com.test.callkit.R;
+
+import java.util.Objects;
+
+public class VoipForegroundService extends Service {
+    private String INCOMING_CHANNEL_ID = "IncomingCallChannel";
+    private String INCOMING_CHANNEL_NAME = "Incoming Call Channel";
+    private String ONGOING_CHANNEL_ID = "OngoingCallChannel";
+    private String ONGOING_CHANNEL_NAME = "Ongoing Call Channel";
+    private NotificationManager mNotificationManager;
+    NotificationCompat.Builder notificationBuilder;
+    public static MediaPlayer ringtone;
+    public static Vibrator vibrator;
+    String username="",token="",roomName="";
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        stop_ringtone();
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        String action = intent.getAction();
+        Log.d("VoipForegroundService","onStartCommand "+action);
+        switch (action)
+        {
+            case "incoming":
+                build_incoming_call_notification(intent);
+                break;
+            case "answered":
+                build_answered_call_notification();
+                break;
+
+        }
+        return START_NOT_STICKY;
+    }
+
+
+
+    @SuppressLint("MissingPermission")
+    public void build_incoming_call_notification(Intent intent)
+    {
+
+        ringtone = new MediaPlayer();
+        username = intent.getStringExtra("username");
+        token = intent.getStringExtra("token");
+        roomName = intent.getStringExtra("roomName");
+        Log.d("VoipForegroundService","build_incoming_call_notification for "+username);
+
+        try {
+            Intent receiveCallAction = new Intent(getApplicationContext(), VoipForegroundServiceActionReceiver.class);
+            receiveCallAction.putExtra("token",token);
+            receiveCallAction.putExtra("roomName",roomName);
+            receiveCallAction.putExtra("username",username);
+
+            receiveCallAction.setAction("RECEIVE_CALL");
+
+            Intent cancelCallAction = new Intent(getApplicationContext(), VoipForegroundServiceActionReceiver.class);
+            cancelCallAction.putExtra("token",token);
+            cancelCallAction.putExtra("roomName",roomName);
+            cancelCallAction.putExtra("username",username);
+
+            cancelCallAction.setAction("CANCEL_CALL");
+
+            Intent fullscreenCallAction = new Intent(getApplicationContext(), VoipForegroundServiceActionReceiver.class);
+            fullscreenCallAction.putExtra("token",token);
+            fullscreenCallAction.putExtra("roomName",roomName);
+            fullscreenCallAction.putExtra("username",username);
+
+            fullscreenCallAction.setAction("FULLSCREEN_CALL");
+
+            PendingIntent receiveCallPendingIntent = PendingIntent.getBroadcast(getApplicationContext(), 1200, receiveCallAction, PendingIntent.FLAG_UPDATE_CURRENT);
+            PendingIntent cancelCallPendingIntent = PendingIntent.getBroadcast(getApplicationContext(), 1201, cancelCallAction, PendingIntent.FLAG_UPDATE_CURRENT);
+            PendingIntent fullscreenCallPendingIntent = PendingIntent.getBroadcast(getApplicationContext(), 1202, fullscreenCallAction, PendingIntent.FLAG_UPDATE_CURRENT);
+
+            notificationBuilder = null;
+            Uri alarmSound = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
+            notificationBuilder = new NotificationCompat.Builder(this, INCOMING_CHANNEL_ID)
+                    .setContentTitle(username)
+                    .setContentText("Incoming Call")
+                    .setSmallIcon(android.R.drawable.btn_star)
+                    .setPriority(NotificationCompat.PRIORITY_HIGH)
+                    .setCategory(NotificationCompat.CATEGORY_CALL)
+                    .setSound(alarmSound)
+
+                    .addAction(new NotificationCompat.Action.Builder(
+                            0,
+                            "reject",
+                            cancelCallPendingIntent).build())
+                    .addAction(new NotificationCompat.Action.Builder(
+                            0,
+                           "answer",
+                            receiveCallPendingIntent).build())
+                    .setAutoCancel(false)
+
+                    .setFullScreenIntent(fullscreenCallPendingIntent, true);
+            long[] pattern = {0, 100, 1000, 300};
+            vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
+            AudioManager am = (AudioManager) VoipForegroundService.this.getSystemService(Context.AUDIO_SERVICE);
+            if (am.getRingerMode() != AudioManager.RINGER_MODE_SILENT)
+            {
+                vibrator.vibrate(pattern, 0);
+            }
+//            Uri sound = Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.call);
+//            try
+//            {
+//                ringtone.setDataSource(getApplicationContext(), sound);
+//                ringtone.setAudioStreamType(AudioManager.STREAM_RING);
+//                ringtone.prepare();
+//                ringtone.setLooping(true);
+//                ringtone.start();
+//
+//            }
+//            catch (Exception e)
+//            {
+//                Log.d("VoipForegroundService","1 "+e.toString());
+//
+//            }
+
+            createIncomingChannel();
+            startForeground(120, notificationBuilder.build());
+
+
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            Log.d("VoipForegroundService","2 "+e.toString());
+
+        }
+
+    }
+    public void build_answered_call_notification()
+    {
+        stop_ringtone();
+        stopSelf();
+    }
+
+
+    @SuppressLint("MissingPermission")
+    public void stop_ringtone()
+    {
+        try {
+            ringtone.stop();
+            ringtone.release();
+            ringtone = null;
+            vibrator.cancel();
+
+        }
+        catch (Exception e)
+        {
+
+        }
+    }
+    public void createOngoingChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+
+            NotificationChannel channel = new NotificationChannel(ONGOING_CHANNEL_ID, ONGOING_CHANNEL_NAME, NotificationManager.IMPORTANCE_DEFAULT);
+            channel.setDescription(ONGOING_CHANNEL_NAME);
+
+            channel.setSound(null,null);
+            Objects.requireNonNull(getApplicationContext().getSystemService(NotificationManager.class)).createNotificationChannel(channel);
+
+        }
+    }
+    public void createIncomingChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+
+            NotificationChannel channel = new NotificationChannel(INCOMING_CHANNEL_ID, INCOMING_CHANNEL_NAME, NotificationManager.IMPORTANCE_HIGH);
+            channel.setDescription(INCOMING_CHANNEL_NAME);
+
+            channel.setSound(null,null);
+
+
+            Objects.requireNonNull(getApplicationContext().getSystemService(NotificationManager.class)).createNotificationChannel(channel);
+
+        }
+    }
+
+}

package/android/src/main/java/com/test/callkit/androidcall/VoipForegroundServiceActionReceiver.java

@@ -0,0 +1,79 @@
+package com.test.callkit.androidcall;
+
+import android.annotation.SuppressLint;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.RequiresApi;
+
+import com.test.callkit.CallKitVoipPlugin;
+
+
+public class VoipForegroundServiceActionReceiver  extends BroadcastReceiver {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (intent != null ) {
+            String action = intent.getAction();
+            String token = intent.getStringExtra("token");
+            String roomName = intent.getStringExtra("roomName");
+            String username = intent.getStringExtra("username");
+
+
+            if (action != null) {
+                performClickAction(context, action,token,roomName,username);
+            }
+
+            // Close the notification after the click action is performed.
+
+
+        }
+    }
+    @SuppressLint("MissingPermission")
+    private void performClickAction(Context context, String action, String token, String roomName, String username) {
+        Log.d("performClickAction","action "+action + "   "+username);
+
+        if (action.equals("RECEIVE_CALL")) {
+
+            Intent dialogIntent = new Intent(context, CallActivity.class);
+            dialogIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            dialogIntent.putExtra("auto_answer",true);
+            dialogIntent.putExtra("token",token);
+            dialogIntent.putExtra("roomName",roomName);
+            dialogIntent.putExtra("username",username);
+
+            context.startActivity(dialogIntent);
+        }
+        else if (action.equals("FULLSCREEN_CALL")) {
+
+
+            Intent dialogIntent = new Intent(context, CallActivity.class);
+
+            dialogIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            dialogIntent.putExtra("auto_answer",false);
+            dialogIntent.putExtra("token",token);
+            dialogIntent.putExtra("roomName",roomName);
+            dialogIntent.putExtra("username",username);
+
+            context.startActivity(dialogIntent);
+        }
+        else if (action.equals("CANCEL_CALL")) {
+            context.stopService(new Intent(context, VoipForegroundService.class));
+            Intent it = new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
+            context.sendBroadcast(it);
+            end_call(username,roomName);
+
+        }
+    }
+
+    public void end_call( String username,String connectionId)
+    {
+        CallKitVoipPlugin instance = CallKitVoipPlugin.getInstance();
+        instance.notifyEvent("RejectCall",username,connectionId);
+
+
+    }
+
+}