title: Sinch Not Running in background no way (Android)
body: <p>Good day.I am using sinch for audio calling.I dont know what to do and there are no clear docs of sinch (which is very frastruating) which would give me any idea on how to keep the sinch client running in background to listen for incoming calls in the background while the app is killed.Meanwhile i reckon that i forced sinch client not to be terminated but every time the app is openning,the client is being started anyway.So if anyone encounter such thing,could you please help me and tell me how can i listen for incoming calls in the background with Sinch?Posting the codes i have already up and running.</p>
  
  <p>The base activity which being inherited by all of my activities.</p>
  
  <pre><code>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;
      }
  
  }
  </code></pre>
  
  <p>The sinch service</p>
  
  <pre><code> * 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 &amp;&amp; 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 &amp;&amp; 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&lt;String, String&gt; 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);
          }
      }
  
  }
  </code></pre>
  
  <p>And here is how i start the sinch service inside my launcher activity.</p>
  
  <pre><code>   @Override
      protected void onServiceConnected() {
          if (!getSinchServiceInterface().isStarted()) {
              getSinchServiceInterface().startClient(mSharedHelper.getUserId());
          }
          getSinchServiceInterface().setStartListener(this);
      }
  </code></pre>