sinch - 从最近清除应用程序时，Sinch Video clling APi 不起作用

Question

我正在为我的 android 应用程序使用 sinch 视频调用 API。但是当应用程序在后台时，只要用户离线，即用户从最近的标签中清除应用程序，他就无法接听电话。每当用户离线时，我都会使用 Firebase 推送通知，但它不会一直被触发，它只是有时会被触发。当用户从最近清除应用程序并且sinch实际上会在后台运行时，谁能建议我如何推送来电通知？

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() {

    }
}

标签： sinchvideochatandroid-sinch-api