Sinch 无法在后台运行 (Android)

Question

美好的一天。我正在使用 sinch 进行音频通话。我不知道该怎么做，也没有明确的 sinch 文档（这非常令人沮丧），这会让我知道如何让 sinch 客户端在后台运行在应用程序被杀死时在后台监听来电。同时我认为我强迫sinch客户端不被终止但每次应用程序打开时，客户端无论如何都会启动。所以如果有人遇到这样的事情，你能请帮助我并告诉我如何使用 Sinch 在后台监听来电？发布我已经启动并运行的代码。

我的所有活动都继承的基础活动。

import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.support.v7.app.AppCompatActivity;
import android.widget.Toast;

import ink.service.SinchService;

/**
 * Created by USER on 2016-07-24.
 */
public abstract class BaseActivity extends AppCompatActivity implements ServiceConnection {
    private SinchService.SinchServiceInterface mSinchServiceInterface;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getApplicationContext().bindService(new Intent(this, SinchService.class), this,
                BIND_AUTO_CREATE);
    }

    @Override
    public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
        if (SinchService.class.getName().equals(componentName.getClassName())) {
            mSinchServiceInterface = (SinchService.SinchServiceInterface) iBinder;
            onServiceConnected();
        }
    }

    @Override
    public void onServiceDisconnected(ComponentName componentName) {
        Toast.makeText(BaseActivity.this, "Service disconnected", Toast.LENGTH_SHORT).show();
        if (SinchService.class.getName().equals(componentName.getClassName())) {
            mSinchServiceInterface = null;
            onServiceDisconnected();
        }
    }

    protected void onServiceConnected() {
        // for subclasses
    }

    protected void onServiceDisconnected() {
        // for subclasses
    }

    protected SinchService.SinchServiceInterface getSinchServiceInterface() {
        return mSinchServiceInterface;
    }

}

sinch 服务

 * Created by USER on 2016-07-24.
 */
public class SinchService extends Service {

    private static final String APP_KEY = "HIDDEN";
    private static final String APP_SECRET = "HIDDEN";
    private static final String ENVIRONMENT = "HIDDEN";

    public static final String LOCATION = "LOCATION";
    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;

    private StartFailedListener mListener;

    @Override
    public void onCreate() {
        super.onCreate();
        Toast.makeText(SinchService.this, "Service created", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onDestroy() {
//        if (mSinchClient != null && mSinchClient.isStarted()) {
//            mSinchClient.terminate();
//        }
        Toast.makeText(SinchService.this, "Service destroyed", Toast.LENGTH_SHORT).show();
        super.onDestroy();
    }

    private void start(String userName) {
        if (mSinchClient == null) {
            mUserId = userName;
            mSinchClient = Sinch.getSinchClientBuilder().context(getApplicationContext()).userId(userName)
                    .applicationKey(APP_KEY)
                    .applicationSecret(APP_SECRET)
                    .environmentHost(ENVIRONMENT).build();

            mSinchClient.setSupportCalling(true);
            mSinchClient.startListeningOnActiveConnection();
            mSinchClient.setSupportActiveConnectionInBackground(true);

            mSinchClient.addSinchClientListener(new ClientListener());
            mSinchClient.getCallClient().addCallClientListener(new SinchCallClientListener());
            mSinchClient.start();
        }
    }

    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 callPhoneNumber(String phoneNumber) {
            return mSinchClient.getCallClient().callPhoneNumber(phoneNumber);
        }

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

        public Call callUser(String userId, Map<String, String> headers) {
            return mSinchClient.getCallClient().callUser(userId, headers);
        }

        public String getUserName() {
            return mUserId;
        }

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

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

        public void stopClient() {
            stop();
        }

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

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

    public interface StartFailedListener {
        void onStartFailed(SinchError error);

        void onStarted();
    }

    private class ClientListener 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();
            }
        }

        @Override
        public void onClientStopped(SinchClient client) {
            Toast.makeText(SinchService.this, "Sinch client stopped", Toast.LENGTH_SHORT).show();
            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) {
        }
    }

    private class SinchCallClientListener implements CallClientListener {

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

}

这是我在启动器活动中启动 sinch 服务的方式。

   @Override
    protected void onServiceConnected() {
        if (!getSinchServiceInterface().isStarted()) {
            getSinchServiceInterface().startClient(mSharedHelper.getUserId());
        }
        getSinchServiceInterface().setStartListener(this);
    }

Answer 1

1) 添加到您的 sinchClient mSinchClient.setSupportManagedPush(true); 以在您接到电话时接收推送通知消息

2) 在您的应用上设置 Firebase 云消息传递

3) onMessageReceived 将数据传输到您的 IncomingTransparentCallActivity

    public class FirebaseMsgService extends FirebaseMessagingService {
            @Override
            public void onMessageReceived(RemoteMessage remoteMessage) {
                super.onMessageReceived(remoteMessage);

        Map<String, String> map = remoteMessage.getData();
                    HashMap dataHashMap =
                            (map instanceof HashMap)
                                    ? (HashMap) map
                                    : new HashMap<>(map);
                    if (SinchHelpers.isSinchPushPayload(map)) {
        ///Check if the application is in foreground if in foreground the SinchService already run //// 
          if (foregrounded()){
                        return;
                    }
                        Intent intent = new Intent(this, IncomingCallActivity.class);
                        NotificationCallVo callVo = new  NotificationCallVo();
                        callVo.setData(dataHashMap);
                        intent.putExtra(Constants.PARCELABLE, callVo);
                        startActivity(intent);

                    }

  ///To check if the app is in foreground ///
    public static boolean foregrounded() {
        ActivityManager.RunningAppProcessInfo appProcessInfo =
                new ActivityManager.RunningAppProcessInfo();
        ActivityManager.getMyMemoryState(appProcessInfo);
        return (appProcessInfo.importance == IMPORTANCE_FOREGROUND
                || appProcessInfo.importance == IMPORTANCE_VISIBLE);
    }

        }

NotificationCallVo

  public class NotificationCallVo implements Parcelable {

        private HashMap data;

        public NotificationCallVo() {
        }

        private NotificationCallVo(Parcel in) {
            data = (HashMap) in.readValue(HashMap.class.getClassLoader());
        }

        @Override
        public int describeContents() {
            return 0;
        }

        @Override
        public void writeToParcel(Parcel dest, int flags) {
            dest.writeValue(data);
        }

        @SuppressWarnings("unused")
        public static final Parcelable.Creator<NotificationCallVo> CREATOR = new Parcelable.Creator<NotificationCallVo>() {
            @Override
            public NotificationCallVo createFromParcel(Parcel in) {
                return new NotificationCallVo(in);
            }

            @Override
            public NotificationCallVo[] newArray(int size) {
                return new NotificationCallVo[size];
            }
        };

        public HashMap getData() {
            return data;
        }

        public void setData(HashMap<String, String> data) {
            this.data = data;
        }
    }

4) 在您的 SinchServiceInterface 上添加方法

public NotificationResult relayRemotePushNotificationPayload(final Map payload) {
            if (mSinchClient == null && !mSettings.getUsername().isEmpty()) {
                startClient(mSettings.getUsername());
            } else if (mSinchClient == null && mSettings.getUsername().isEmpty()) {
                Log.e(TAG, "Can't start a SinchClient as no username is available, unable to relay push.");
                return null;
            }
            return mSinchClient.relayRemotePushNotificationPayload(payload);
        } 

5) 在 IncomingTransparentCallActivity 上连接到 SinchService 和 onServiceConnected 传输数据到 sinchServiceInterface

public class IncomingTransparentCallActivity extends BaseCallActivity {
    private NotificationCallVo mCallVo;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (getIntent().getParcelableExtra(Constants.PARCELABLE) != null &&
                getIntent().getParcelableExtra(Constants.PARCELABLE) instanceof NotificationCallVo) {
            mCallVo = getIntent().getParcelableExtra(Constants.PARCELABLE);
        }
    }

    @Override
    protected void onServiceConnected(IBinder iBinder) {
        SinchService.SinchServiceInterface sinchServiceInterface = getSinchServiceInterface();
        if (mCallVo != null) {
            NotificationResult result = sinchServiceInterface.relayRemotePushNotificationPayload(mCallVo.getData());
            setContentView(R.layout.activity_incoming_call);
        }
    }
}

6) BaseCallActivity

public abstract class BaseCallActivity extends AppCompatActivity implements ServiceConnection {
    private SinchService.SinchServiceInterface mSinchServiceInterface;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        bindService(new Intent(this, SinchService.class), this,
                Context.BIND_AUTO_CREATE);
    }

    @Override
    public void onServiceConnected(ComponentName name, IBinder iBinder) {
        if (SinchService.class.getName().equals(name.getClassName())) {
            mSinchServiceInterface = (SinchService.SinchServiceInterface) iBinder;
            onServiceConnected(iBinder);
        }
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        if (SinchService.class.getName().equals(name.getClassName())) {
            mSinchServiceInterface = null;
            onServiceDisconnected();
        }
    }

    @Override
    public void onBindingDied(ComponentName name) {

    }

    protected void onServiceConnected(IBinder iBinder) {
        // for subclasses
    }

    protected void onServiceDisconnected() {
        // for subclasses
    }

    protected SinchService.SinchServiceInterface getSinchServiceInterface() {
        return mSinchServiceInterface;
    }

    public void setmSinchServiceInterface(SinchService.SinchServiceInterface mSinchServiceInterface) {
        this.mSinchServiceInterface = mSinchServiceInterface;
    }



    @Override
    protected void onDestroy() {
        unbindService(this);
        super.onDestroy();
    }
}

7) SinchCallClientListener 将监听您的来电并打开您的活动

查看以下链接 [https://www.sinch.com/learn/sinch-managed-push-calling-android/][1]

Answer 2

您似乎没有在清单文件中声明您的服务。按照以下方式进行：

<service
        android:name=".SinchService"   
        android:exported="false" />

如果有，请与我们分享您的清单文件。