Sinch Video clling APi not working when app is cleared from recents

Question

I am using sinch Video calling API for my android application. But when the app is in the background, whenever the user is offline i.e user cleared app from the recent tab, he was unable to get the call. I used Firebase for pushing notification whenever the user is offline, but it is not getting triggered all the time, it is getting triggered sometimes only. can anyone suggest me how to push notification of incoming call when the user cleared the app from recent and will sinch actually run in the background?

public class SinchService extends Service {

    private static final String APP_KEY = "key";
    private static final String APP_SECRET = "secret";
    private static final String ENVIRONMENT = "clientapi.sinch.com";

    public static final String CALL_ID = "CALL_ID";
    static final String TAG = SinchService.class.getSimpleName();

    private SinchServiceInterface mSinchServiceInterface = new SinchServiceInterface();
    private SinchClient mSinchClient;
    private String mUserId;
    static Context context;
    private StartFailedListener mListener;

    @Override
    public void onCreate() {
        super.onCreate();
    }

   /* @Override
    public void onDestroy() {
        if (mSinchClient != null && mSinchClient.isStarted()) {
            mSinchClient.terminate();
        }
        super.onDestroy();
    }*/

    private void start(String userName,String fcm_token) {
        if (mSinchClient == null) {
            mUserId = userName;


            /*LooperThread looperThread = new LooperThread();
            looperThread.start();*/
           /* new Handler(Looper.getMainLooper()).post(new Runnable() {
                @Override
                public void run() {


                }
            });*/

            mSinchClient = Sinch.getSinchClientBuilder().context(getApplicationContext()).userId(mUserId)
                    .applicationKey(APP_KEY)
                    .applicationSecret(APP_SECRET)
                    .environmentHost(ENVIRONMENT)
                    .build();

            //Log.d("OnMsg","coming after getSinchServiceInterface()");



            mSinchClient.setSupportMessaging(true);
            mSinchClient.setSupportCalling(true);
            mSinchClient.setSupportManagedPush(true);


            mSinchClient.setSupportPushNotifications(true);

            mSinchClient.startListeningOnActiveConnection();


           /* mSinchClient.startListeningOnActiveConnection();
            mSinchClient.setSupportActiveConnectionInBackground(true);*/

            // mSinchClient.setSupportActiveConnectionInBackground(true);
            // mSinchClient.startListeningOnActiveConnection();
           /* mSinchClient.setSupportManagedPush(true);
             mSinchClient.setSupportPushNotifications(true);*/

           // Log.d("fcm:","fcm token in bytes "+ fcm_token.getBytes());

            mSinchClient.checkManifest();
            mSinchClient.addSinchClientListener(new MySinchClientListener());
            mSinchClient.getCallClient().addCallClientListener(new SinchCallClientListener());
            mSinchClient.start();

           // mSinchClient.registerPushNotificationData(fcm_token.getBytes());

        }
    }




    class LooperThread extends Thread {
        public Handler mHandler;

        @Override
        public void run() {
            // Initialize the current thread as a Looper
            // (this thread can have a MessageQueue now)
            Looper.prepare();

            mHandler = new Handler() {
                @Override
                public void handleMessage(Message msg) {
                    // process incoming messages here


                   /* mSinchClient.setSupportMessaging(true);
                    mSinchClient.setSupportCalling(true);
                    mSinchClient.setSupportManagedPush(true);


                    mSinchClient.setSupportPushNotifications(true);

                    mSinchClient.startListeningOnActiveConnection();


           *//* mSinchClient.startListeningOnActiveConnection();
            mSinchClient.setSupportActiveConnectionInBackground(true);*//*

                    // mSinchClient.setSupportActiveConnectionInBackground(true);
                    // mSinchClient.startListeningOnActiveConnection();
            *//* mSinchClient.setSupportManagedPush(true);
             mSinchClient.setSupportPushNotifications(true);*//*

                    // Log.d("fcm:","fcm token in bytes "+ fcm_token.getBytes());

                    mSinchClient.checkManifest();
                    mSinchClient.addSinchClientListener(new MySinchClientListener());
                    mSinchClient.getCallClient().addCallClientListener(new SinchCallClientListener());
                    mSinchClient.start();*/
                }
            };

            // Run the message queue in this thread
            Looper.loop();
        }
    }

    private void stop() {
        if (mSinchClient != null) {
            mSinchClient.terminate();
            mSinchClient = null;
        }
    }

    private boolean isStarted() {
        return (mSinchClient != null && mSinchClient.isStarted());
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mSinchServiceInterface;
    }

    public class SinchServiceInterface extends Binder {

        public Call callUserVideo(String userId) {
            return mSinchClient.getCallClient().callUserVideo(userId);
        }

        public String getUserName() {
            return mUserId;
        }

        public boolean isStarted() {
            return SinchService.this.isStarted();
        }

        public void startClient(String userName,String token) {
            start(userName,token);
        }

        public void stopClient() {
            stop();
        }

        public void setStartListener(StartFailedListener listener) {
            mListener = listener;
        }

        public Call getCall(String callId) {
            return mSinchClient.getCallClient().getCall(callId);
        }

        public VideoController getVideoController() {
            if (!isStarted()) {
                return null;
            }
            return mSinchClient.getVideoController();
        }

        public AudioController getAudioController() {
            if (!isStarted()) {
                return null;
            }
            return mSinchClient.getAudioController();
        }
    }

    public interface StartFailedListener {

        void onStartFailed(SinchError error);

        void onStarted();
    }

    private class MySinchClientListener implements SinchClientListener {

        @Override
        public void onClientFailed(SinchClient client, SinchError error) {
            if (mListener != null) {
                mListener.onStartFailed(error);
            }
           /* mSinchClient.terminate();
            mSinchClient = null;*/
        }

        @Override
        public void onClientStarted(SinchClient client) {
            Log.d(TAG, "SinchClient started");
            if (mListener != null) {
                mListener.onStarted();
                mSinchClient.startListeningOnActiveConnection();
            }
        }

        @Override
        public void onClientStopped(SinchClient client) {
            Log.d(TAG, "SinchClient stopped");
        }

        @Override
        public void onLogMessage(int level, String area, String message) {
            switch (level) {
                case Log.DEBUG:
                    Log.d(area, message);
                    break;
                case Log.ERROR:
                    Log.e(area, message);
                    break;
                case Log.INFO:
                    Log.i(area, message);
                    break;
                case Log.VERBOSE:
                    Log.v(area, message);
                    break;
                case Log.WARN:
                    Log.w(area, message);
                    break;
            }
        }

        @Override
        public void onRegistrationCredentialsRequired(SinchClient client,
                                                      ClientRegistration clientRegistration) {
        }
    }

    public class SinchCallClientListener implements CallClientListener {

        @Override
        public void onIncomingCall(CallClient callClient, Call call) {
            Log.d("OnMsg", "Incoming call");
            Intent intent = new Intent(SinchService.this, IncomingCallScreenActivity.class);
            intent.putExtra(CALL_ID, call.getCallId());
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            SinchService.this.startActivity(intent);
        }
    }

}









public class PlaceCallActivity extends BaseActivity implements SinchService.StartFailedListener/*,PushTokenRegistrationCallback*/{

    private Button mCallButton;
    private EditText mCallName;
    Button stopButton;

    String token;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);



        //initializing UI elements
        mCallName = findViewById(R.id.callName);
        mCallButton = findViewById(R.id.callButton);
        mCallButton.setEnabled(false);
        mCallButton.setOnClickListener(buttonClickListener);

        stopButton = findViewById(R.id.stopButton);
        stopButton.setEnabled(false);



        FirebaseInstanceId.getInstance().getInstanceId()
                .addOnCompleteListener(new OnCompleteListener<InstanceIdResult>() {
                    @Override
                    public void onComplete(@NonNull Task<InstanceIdResult> task) {
                        if (!task.isSuccessful()) {
                            Log.w("test", "getInstanceId failed", task.getException());
                            return;
                        }

                        // Get new Instance ID token
                        token = task.getResult().getToken();

                        // Log and toast
                        //String msg = getString(R.string.msg_token_fmt, token);
                        Log.d("test", token);
                        Toast.makeText(PlaceCallActivity.this, token, Toast.LENGTH_SHORT).show();
                    }
                });




        stopButton.setOnClickListener(buttonClickListener);
       /* try {
            @SuppressLint("WrongThread") String regId = FirebaseInstanceId.getInstance().getToken("Your-Sender-ID", "FCM");
        } catch (IOException e) {
            e.printStackTrace();
        }*/

        final Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                getSinchServiceInterface().startClient(new PreferenceUtils(PlaceCallActivity.this).getName(),token);
            }
        }, 4000);
    }


    // invoked when the connection with SinchServer is established
    @Override
    protected void onServiceConnected() {

        TextView userName = (TextView) findViewById(R.id.loggedInName);
        getSinchServiceInterface().setStartListener(this);
        userName.setText(new PreferenceUtils(PlaceCallActivity.this).getName());
        mCallButton.setEnabled(true);
        stopButton.setEnabled(true);
    }

   /* @Override
    public void onDestroy() {
        if (getSinchServiceInterface() != null) {
            getSinchServiceInterface().stopClient();
        }
        super.onDestroy();
    }*/

    /*//to kill the current session of SinchService
    private void stopButtonClicked() {
        if (getSinchServiceInterface() != null) {
            getSinchServiceInterface().stopClient();
        }
        finish();
    }*/

    //to place the call to the entered name
    private void callButtonClicked() {
        String userName = mCallName.getText().toString();
        if (userName.isEmpty()) {
            Toast.makeText(this, "Please enter a user to call", Toast.LENGTH_LONG).show();
            return;
        }

        Call call = getSinchServiceInterface().callUserVideo(userName);
        String callId = call.getCallId();

        Log.d("test","call id is"+callId);

        Intent callScreen = new Intent(this, CallScreenActivity.class);
        callScreen.putExtra(SinchService.CALL_ID, callId);
        callScreen.putExtra("TOKEN", token);
        startActivity(callScreen);
    }


    private OnClickListener buttonClickListener = new OnClickListener() {
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.callButton:
                    callButtonClicked();
                    break;

                case R.id.stopButton:
                   // stopButtonClicked();
                    break;

            }
        }
    };



    @Override
    public void onStartFailed(SinchError error) {
        Toast.makeText(this, error.toString(), Toast.LENGTH_LONG).show();
    }

    @Override
    public void onStarted() {

    }
}