priyanka Chauhan priyanka Chauhan - 3 months ago 45
Android Question

Quickblox -SDK for android App not receive call when app is in background

I am developing video calling app using Quickblox-SDK for android. App is working fine and perfect if the app is open But if the app is in background I am not able to receive call. I've created app using this link please help.
I have tried following things:

1) Opening CallActivity when the notification arrive, notification using GCM but as its talking time to receive notification this thing is also not working.

Thanks.

Answer

Create a sticky service which will run in background even activity destroy, this service is responsible for QBsession and all other operations so it will detect call in background . Iam successfully implements this and iam successfully receiving calls in background by this.

public class BloxService extends Service implements QBRTCClientSessionCallbacks {
    private QBChatService chatService;
    private volatile boolean resultReceived = true;
    static final String APP_ID = "";
    static final String AUTH_KEY = "";
    static final String AUTH_SECRET = "";
    static final String ACCOUNT_KEY = "";
    private QBRTCClient rtcClient;
    public static BloxService bloxService;
    private static final String TAG = "BloxService";
    public boolean isSessionRunning;
    public boolean isCallRunning;
    private  Date tokenExpirationDate;
    private QBAuth qbAuth;
    private AppPrefs prefs;

    private BroadcastReceiver mConnReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            /*boolean noConnectivity = intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);
            String reason = intent.getStringExtra(ConnectivityManager.EXTRA_REASON);
            boolean isFailover = intent.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER, false);*/
            NetworkInfo currentNetworkInfo = (NetworkInfo) intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
            //NetworkInfo otherNetworkInfo = (NetworkInfo) intent.getParcelableExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO);
            if(currentNetworkInfo!=null && currentNetworkInfo.isConnected()){
                if(!QBChatService.getInstance().isLoggedIn()){
                    if(!isSessionRunning) {
                        initializeQb();
                    }
                }
            }
        }
    };

    @Override
    public void onCreate() {
        super.onCreate();
       // prefs = AppPrefs.getInstance(getApplicationContext()); // for testing we put this line on start
        registerReceiver(this.mConnReceiver,
                new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("bloxservice","onDestroy");
        try{
            unregisterReceiver(mConnReceiver);
        }catch (Exception e){

        }
    }

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

    @Override
    public int onStartCommand(Intent intent, int flags, int startId){
        prefs = AppPrefs.getInstance(getApplicationContext());
        if (prefs.getData(IS_USER_LOGIN, false)) {
            Log.d("bloxservice","start");
            try {
                if (!QBChatService.getInstance().isLoggedIn()) {
                    initializeQb();
                }
            }catch (Exception e)
            {
                initializeQb();
            }
            bloxService=this;
        }
        else {
            stopSelf();
        }

        return START_STICKY;
    }

    public static BloxService getBloxService() {
        return bloxService;
    }

    public void initializeQb(){
        QBSettings.getInstance().init(getApplicationContext(), APP_ID, AUTH_KEY, AUTH_SECRET);
        QBSettings.getInstance().setAccountKey(ACCOUNT_KEY);
        QBChatService.setDebugEnabled(true);
// added on 20 july
        QBChatService.setDefaultAutoSendPresenceInterval(60);
        QBChatService.ConfigurationBuilder chatServiceConfigurationBuilder = new QBChatService.ConfigurationBuilder();
        chatServiceConfigurationBuilder.setSocketTimeout(60); //Sets chat socket's read timeout in seconds
        chatServiceConfigurationBuilder.setKeepAlive(true); //Sets connection socket's keepAlive option.
        QBChatService.setConfigurationBuilder(chatServiceConfigurationBuilder);
    //    QBChatService.getInstance().startAutoSendPresence(10);// added on 20 july
        chatService = QBChatService.getInstance();

       /* tokenExpirationDate = qbAuth.getTokenExpirationDate();
        try {
          String Token=  QBAuth.getSession().toString();
            QBAuth.createFromExistentToken()
        } catch (QBResponseException e) {
            e.printStackTrace();
        }
*/
        if(AppPrefs.getInstance(this).getData(Constants.PrefsConstatnt.IS_USER_LOGIN,false)){
            Log.e("Login Process", "Started");
            isSessionRunning=true;
            String userId=AppPrefs.getInstance(this).getData(Constants.PrefsConstatnt.USER_ID,"");
            String name=AppPrefs.getInstance(this).getData(Constants.PrefsConstatnt.USER_NAME,"");
            String picUrl=AppPrefs.getInstance(this).getData(Constants.PrefsConstatnt.USER_IMAGE,"");
            String phone=prefs.getData(Constants.PrefsConstatnt.USER_PHONE, "");
            if(name.isEmpty()){
                name=userId;
            }
            createAppSession(Integer.parseInt(userId)<10?"0"+userId:userId,name,userId,picUrl,phone);
        }
    }

    private void createAppSession(final String userId, final String name,final String exId,final String picUrl,final String phone) {
        QBAuth.createSession(new QBEntityCallback<QBSession>() {
            @Override
            public void onSuccess(QBSession qbSession, Bundle bundle) {
                loadUsers(userId, name, exId,picUrl,phone);
                final SharedPreferences prefs = getGCMPreferences(getApplicationContext());
                String registrationId = prefs.getString(PROPERTY_REG_ID, "");
                if (registrationId.isEmpty()) {
                }

                // Subscribe to Push Notifications
                //subscribeToPushNotifications(registrationId);


            }
            @Override
            public void onError(QBResponseException exc) {
                exc.printStackTrace();
                isSessionRunning=false;
            }
        });
    }
    //QBUser users;
    public void loadUsers(String userId,String name,String exId,String picUrl,String phone) {
        final QBUser userr = new QBUser(userId, DataHolder.PASSWORD);
        userr.setFullName(name);
        userr.setExternalId(exId);
        userr.setCustomData(picUrl);
        userr.setPhone(phone);
        QBUsers.signUp(userr, new QBEntityCallback<QBUser>() {
            @Override
            public void onSuccess(QBUser user, Bundle args) {
                createSession(userr.getLogin(), userr.getPassword());

            }

            @Override
            public void onError(QBResponseException error) {
                error.printStackTrace();
                QBUsers.signIn(userr, new QBEntityCallback<QBUser>() {
                    @Override
                    public void onSuccess(QBUser user, Bundle args) {
                        createSession(userr.getLogin(), userr.getPassword());
                    }

                    @Override
                    public void onError(QBResponseException error) {
                        error.printStackTrace();
                        isSessionRunning = false;
                    }
                });
            }
        });
    }
    private void createSession(final String login, final String password) {
        final QBUser user = new QBUser(login, password);
        QBAuth.createSession(login, password, new QBEntityCallback<QBSession>() {
            @Override
            public void onSuccess(QBSession session, Bundle bundle) {
                user.setId(session.getUserId());
                Log.e("User" + session.getUserId(), "Login");
                QBSettings.getInstance().fastConfigInit(APP_ID, AUTH_KEY, AUTH_SECRET);
                sendRegistrationToServer(AppPrefs.getInstance(BloxService.this).getData(Constants.PrefsConstatnt.DEVICE_TOKEN, ""));
                DataHolder.setLoggedUser(user);
                if (chatService.isLoggedIn()) {
                    resultReceived = true;
                    initQBRTCClient();
                    isSessionRunning = false;
                } else {
                    chatService.login(user, new QBEntityCallback<Void>() {
                        @Override
                        public void onSuccess(Void result, Bundle bundle) {
                            initQBRTCClient();
                            resultReceived = true;
                            isSessionRunning = false;
                        }
                        @Override
                        public void onError(QBResponseException exc) {
                            resultReceived = true;
                            isSessionRunning = false;
                        }
                    });
                }

/*                QBRosterListener rosterListener = new QBRosterListener() {
                    @Override
                    public void entriesDeleted(Collection<Integer> userIds) {
                        Log.d("mayanks","changed");
                    }

                    @Override
                    public void entriesAdded(Collection<Integer> userIds) {
                        Log.d("mayanks","changed");
                    }

                    @Override
                    public void entriesUpdated(Collection<Integer> userIds) {
                        Log.d("mayanks","changed");
                    }

                    @Override
                    public void presenceChanged(QBPresence presence) {
                        Log.d("mayanks","changed");
                    }
                };

                QBSubscriptionListener subscriptionListener = new QBSubscriptionListener() {
                    @Override
                    public void subscriptionRequested(int userId) {

                    }
                };

                QBRoster chatRoster = QBChatService.getInstance().getRoster(QBRoster.SubscriptionMode.mutual, subscriptionListener);
                chatRoster.addRosterListener(rosterListener);
                Collection<QBRosterEntry> entries = chatRoster.getEntries();
                QBPresence presence = chatRoster.getPresence(9);
                if (presence!=null) {

                    if (presence.getType() == QBPresence.Type.online) {
                        Log.d("mayanks","online");
                        // User is online
                    }else{
                        Log.d("mayanks","offline");
                        // User is offline
                    }
                }*/

            }

            @Override
            public void onError(QBResponseException exc) {
                resultReceived = true;
                isSessionRunning = false;
            }
        });
    }

    private void sendRegistrationToServer(final String token) {
        new Handler(Looper.getMainLooper()).post(new Runnable() {
            @Override
            public void run() {
                final SharedPreferences prefs = getGCMPreferences(getApplicationContext());
                String deviceID = prefs.getString(PROPERTY_DEVICE_ID, null);
                if(deviceID==null)
                {
                    deviceID=DeviceUtils.getDeviceUid();
                    storeDeviceId(getApplicationContext(),deviceID);
                }
                QBSubscription qbSubscription = new QBSubscription();
                qbSubscription.setNotificationChannel(QBNotificationChannel.GCM);
                qbSubscription.setDeviceUdid(deviceID);
                qbSubscription.setRegistrationID(token);
                qbSubscription.setEnvironment(QBEnvironment.DEVELOPMENT); // Don't forget to change QBEnvironment to PRODUCTION when releasing application
                QBPushNotifications.createSubscription(qbSubscription,
                        new QBEntityCallback<ArrayList<QBSubscription>>() {
                            @Override
                            public void onSuccess(ArrayList<QBSubscription> qbSubscriptions, Bundle bundle) {
                                Log.e(TAG, "Successfully subscribed for QB push messages");
                                //saveGcmRegIdToPreferences(gcmRegId);
                                isSessionRunning=false;
                            }

                            @Override
                            public void onError(QBResponseException error) {
                                Log.e(TAG, "Unable to subscribe for QB push messages; " + error.toString());
                                isSessionRunning=false;
                            }
                        });
            }
        });

    }

    @Override
    public void onReceiveNewSession(final QBRTCSession qbrtcSession) {
        Log.d("bloxservice","CallRecive");
        new Handler().post(new Runnable() {
            @Override
            public void run() {
                if(!isCallRunning) {
                    DataHolder.incomingSession = qbrtcSession;
                   /* Map<String,String> userInfo = qbrtcSession.getUserInfo();
                    String s=userInfo.get("mayank");*/
                    Intent intent = new Intent(BloxService.this, CallActivity.class);
                    intent.putExtra("incoming", true);
                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    startActivity(intent);
                }
                else{
                    Log.e("User","Busy");
                }
            }
        });
    }

    @Override
    public void onUserNotAnswer(QBRTCSession qbrtcSession, Integer integer) {
       // ToastUtil.showShortToast(this, "no answer");
    }

    @Override
    public void onCallRejectByUser(QBRTCSession qbrtcSession, Integer integer, Map<String, String> map) {
      //  ToastUtil.showShortToast(this,"rejected");
    }

    @Override
    public void onCallAcceptByUser(QBRTCSession qbrtcSession, Integer integer, Map<String, String> map) {
        //ToastUtil.showShortToast(this,"accepted");
    }

    @Override
    public void onReceiveHangUpFromUser(QBRTCSession qbrtcSession, Integer integer, Map<String, String> map) {

    }

    @Override
    public void onUserNoActions(QBRTCSession qbrtcSession, Integer integer) {
       // ToastUtil.showShortToast(this,"no Action");
    }

    @Override
    public void onSessionClosed(QBRTCSession qbrtcSession) {
       // ToastUtil.showShortToast(this,"onSessionClosed");
    }

    @Override
    public void onSessionStartClose(QBRTCSession qbrtcSession) {
       // ToastUtil.showShortToast(this,"onSessionStartClose");
    }

    private void initQBRTCClient() {
        rtcClient = QBRTCClient.getInstance(this);
        QBVideoChatWebRTCSignalingManager qbChatService = QBChatService.getInstance().getVideoChatWebRTCSignalingManager();
        if (qbChatService != null) {
            qbChatService.addSignalingManagerListener(new QBVideoChatSignalingManagerListener() {
                @Override
                public void signalingCreated(QBSignaling qbSignaling, boolean createdLocally) {
                    if (!createdLocally) {
                        rtcClient.addSignaling((QBWebRTCSignaling) qbSignaling);
                    }
                }
            });
            QBRTCConfig.setMaxOpponentsCount(2);
            QBRTCConfig.setDisconnectTime(40);
            QBRTCConfig.setAnswerTimeInterval(30l);
            QBRTCConfig.setDebugEnabled(true);

            rtcClient.addSessionCallbacksListener(this);
            rtcClient.prepareToProcessCalls();
            QBChatService.getInstance().addConnectionListener(new AbstractConnectionListener() {
                @Override
                public void connectionClosedOnError(Exception e) {

                }
                @Override
                public void reconnectionSuccessful() {

                }
                @Override
                public void reconnectingIn(int seconds) {
                }
            });
        }
    }

    public void logout(){
        chatService.logout(new QBEntityCallback<Void>() {
            @Override
            public void onSuccess(Void result, Bundle bundle) {
            }
            @Override
            public void onError(QBResponseException list) {
            }
        });
    }

/*    public void subscribeToPushNotifications(String registrationID) {
        QBSubscription subscription = new QBSubscription(QBNotificationChannel.GCM);
        subscription.setEnvironment(QBEnvironment.DEVELOPMENT);
        //
        String deviceId;
        final TelephonyManager mTelephony = (TelephonyManager) getSystemService(
                Context.TELEPHONY_SERVICE);
        if (mTelephony.getDeviceId() != null) {
            deviceId = mTelephony.getDeviceId(); /*//*** use for mobiles
        } else {
            deviceId = Settings.Secure.getString(getContentResolver(),
                    Settings.Secure.ANDROID_ID); /*//*** use for tablets
        }
        subscription.setDeviceUdid(deviceId);
        //
        subscription.setRegistrationID(registrationID);
        //
        QBPushNotifications.createSubscription(subscription, new QBEntityCallback<ArrayList<QBSubscription>>() {

            @Override
            public void onSuccess(ArrayList<QBSubscription> subscriptions, Bundle args) {
                Log.d("push_send","sucess");
            }

            @Override
            public void onError(QBResponseException error) {
                Log.d("push_send","sucess");
            }
        });
    }*/
    private SharedPreferences getGCMPreferences(Context context) {
        // This sample app persists the registration ID in shared preferences,
        // but
        // how you store the regID in your app is up to you.
        Log.e("getGCMPreferences", "package= " + context.getPackageName());
        return getSharedPreferences(context.getPackageName(), Context.MODE_PRIVATE);
    }

    private void storeDeviceId(Context context, String deviceId) {
        final SharedPreferences prefs = getGCMPreferences(context);
        SharedPreferences.Editor editor = prefs.edit();
        editor.putString(PROPERTY_DEVICE_ID, deviceId);
        editor.commit();
    }

}
Comments