search

QuickBlox / q-municate-android

Qmunicate Android chat application
MIT License
253 stars 198 forks source link

Q-municate CallActivity not opening #254

Closed roma50 closed 1 year ago

roma50 commented 6 years ago

am modifying Q-Municate application powered by QuickBlox but I am facing one problem. When, I receive calling notification; I launch calling activity but it's not getting appear instead application gets open normally but calling activity not appear , below is the code for QbCallChatHelper and CallActivity.

QbCallChatHelper:>>>>

`public class QBCallChatHelper extends BaseHelper {

private static final String TAG = QBCallChatHelper.class.getSimpleName();

private static final int MAX_OPPONENTS_COUNT = 1;
private static final int DISCONNECT_TIME = 30;
private static final int ANSWER_TIME_INTERVAL = 60;

private QBRTCClient qbRtcClient;
private Class<? extends Activity> activityClass;

private QBRTCSession currentQbRtcSession;
private QBRTCClientSessionCallbacks qbRtcClientSessionCallbacks;

private QBChatService chatService;

private boolean isInitialized = false;

public QBCallChatHelper(Context context) {
    super(context);
    chatService = QBChatService.getInstance();
}

public void init(QBChatService qbChatService) {
    if (!isInitialized) {
        superInit();
    }
}

private void superInit() {
    if (isLoggedInToChat()) {
        Log.i(TAG, "already logged in");
        initCallListener();
    } else {
        chatService.login(AppSession.getSession().getUser(), new QBEntityCallback() {
            @Override
            public void onSuccess(Object o, Bundle bundle) {
                Log.i(TAG, "log in successful");
                initCallListener();
            }

            @Override
            public void onError(QBResponseException e) {
                Log.i(TAG, "failed to login: " + e.getMessage());
                initCallListener();
            }
        });
    }
}

private boolean isLoggedInToChat(){
    return chatService != null && chatService.isLoggedIn();
}

private void initCallListener() {
    Log.d(TAG, "init()");

    try {
        qbRtcClient = QBRTCClient.getInstance(context);

        chatService.getVideoChatWebRTCSignalingManager()
                .addSignalingManagerListener(new QBVideoChatSignalingManagerListenerImpl());

        qbRtcClient.addSessionCallbacksListener(new QBRTCClientSessionCallbacksImpl());

        setUpCallClient();
        isInitialized = true;
    } catch (Exception e) {
        Log.i(TAG, e.getMessage());
    }

}

public void initActivityClass(Class<? extends Activity> activityClass) {

    if (!isInitialized) {
        superInit();
    }

    Log.d(TAG, "initActivityClass()");
    this.activityClass = activityClass;
    Log.d("test_crash_1", "initActivityClass(), activityClass = " + activityClass);
}

public QBRTCSession getCurrentRtcSession() {
    return currentQbRtcSession;
}

public void initCurrentSession(QBRTCSession qbRtcSession, QBRTCSignalingCallback qbRtcSignalingCallback,
                               QBRTCSessionConnectionCallbacks qbRtcSessionConnectionCallbacks) {
    this.currentQbRtcSession = qbRtcSession;
    initCurrentSession(qbRtcSignalingCallback, qbRtcSessionConnectionCallbacks);
}

public void initCurrentSession(QBRTCSignalingCallback qbRtcSignalingCallback,
                               QBRTCSessionConnectionCallbacks qbRtcSessionConnectionCallbacks) {
    this.currentQbRtcSession.addSignalingCallback(qbRtcSignalingCallback);
    this.currentQbRtcSession.addSessionCallbacksListener(qbRtcSessionConnectionCallbacks);
}

public void releaseCurrentSession(QBRTCSignalingCallback qbRtcSignalingCallback,
                                  QBRTCSessionConnectionCallbacks qbRtcSessionConnectionCallbacks) {
    if (currentQbRtcSession != null) {
        currentQbRtcSession.removeSignalingCallback(qbRtcSignalingCallback);
        currentQbRtcSession.removeSessionCallbacksListener(qbRtcSessionConnectionCallbacks);
        currentQbRtcSession = null;
    }
}

private void setUpCallClient() {
    Log.d(TAG, "setUpCallClient()");

    qbRtcClient.prepareToProcessCalls();
}

private void startCallActivity(QBRTCSession qbRtcSession) {
    QMUser user = QMUserService.getInstance().getUserCache().get((long)qbRtcSession.getSessionDescription().getCallerID());

    if (user != null) {
        Log.d(TAG, "startCallActivity(), user = " + user);
        Log.d(TAG, "startCallActivity(), qbRtcSession.getConferenceType() = " + qbRtcSession
                .getConferenceType());
        Log.d(TAG, "startCallActivity(), qbRtcSession.getSessionDescription() = " + qbRtcSession
                .getSessionDescription());

        List<QBUser> qbUsersList = new ArrayList<>(1);
        qbUsersList.add(UserFriendUtils.createQbUser(user));
        Intent intent = new Intent(context, activityClass);
        intent.putExtra(QBServiceConsts.EXTRA_OPPONENTS, (Serializable) qbUsersList);
        intent.putExtra(QBServiceConsts.EXTRA_START_CONVERSATION_REASON_TYPE,
                StartConversationReason.INCOME_CALL_FOR_ACCEPTION);
        intent.putExtra(QBServiceConsts.EXTRA_CONFERENCE_TYPE, qbRtcSession.getConferenceType());
        intent.putExtra(QBServiceConsts.EXTRA_SESSION_DESCRIPTION, qbRtcSession.getSessionDescription());
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.getApplicationContext().startActivity(intent);
    } else {
        throw new NullPointerException("user is null!");
    }
}

public void addRTCSessionUserCallback(QBRTCClientSessionCallbacks qbRtcClientSessionCallbacks) {
    this.qbRtcClientSessionCallbacks = qbRtcClientSessionCallbacks;
}

public void removeRTCSessionUserCallback() {
    this.qbRtcClientSessionCallbacks = null;
}

private class QBVideoChatSignalingManagerListenerImpl implements QBVideoChatSignalingManagerListener {

    private final String TAG = QBVideoChatSignalingManagerListenerImpl.class.getSimpleName();

    @Override
    public void signalingCreated(QBSignaling qbSignaling, boolean createdLocally) {
        if (!createdLocally) {
            qbRtcClient.addSignaling((QBWebRTCSignaling) qbSignaling);
        }
    }
}

private class QBRTCClientSessionCallbacksImpl implements QBRTCClientSessionCallbacks {

    private final String TAG = QBRTCClientSessionCallbacksImpl.class.getSimpleName();

    @Override
    public void onReceiveNewSession(QBRTCSession qbRtcSession) {
        Log.d(TAG, "onReceiveNewSession(), qbRtcSession.getSession() = " + qbRtcSession.getSessionID());
        if (currentQbRtcSession != null) {
            Log.d(TAG, "onReceiveNewSession(). Stop new session. Device now is busy");
            if (!qbRtcSession.equals(currentQbRtcSession)) {
                qbRtcSession.rejectCall(null);
            }
        } else {
            Log.d(TAG, "onReceiveNewSession(). init session.");
            if (activityClass != null) {

                startCallActivity(qbRtcSession);
                currentQbRtcSession = qbRtcSession;
            }
        }
    }

    @Override
    public void onUserNotAnswer(QBRTCSession qbRtcSession, Integer integer) {
        Log.d(TAG, "onUserNotAnswer(), qbRtcSession.getSession() = " + qbRtcSession.getSessionID());

        if (qbRtcClientSessionCallbacks != null) {
            qbRtcClientSessionCallbacks.onUserNotAnswer(qbRtcSession, integer);
        }
    }

    @Override
    public void onCallRejectByUser(QBRTCSession qbRtcSession, Integer integer, Map<String, String> map) {
        Log.d(TAG, "onCallRejectByUser(), qbRtcSession.getSession() = " + qbRtcSession.getSessionID());

        if (qbRtcClientSessionCallbacks != null) {
            qbRtcClientSessionCallbacks.onCallRejectByUser(qbRtcSession, integer, map);
        }
    }

    @Override
    public void onCallAcceptByUser(QBRTCSession qbRtcSession, Integer integer, Map<String, String> map) {
        Log.d(TAG, "onCallAcceptByUser(), qbRtcSession.getSession() = " + qbRtcSession.getSessionID());

        if (qbRtcClientSessionCallbacks != null) {
            qbRtcClientSessionCallbacks.onCallAcceptByUser(qbRtcSession, integer, map);
        }
    }

    @Override
    public void onReceiveHangUpFromUser(QBRTCSession qbrtcSession, Integer integer, Map<String, String> map) {
        Log.d(TAG,
                "onReceiveHangUpFromUser(), qbRtcSession.getSession() = " + qbrtcSession.getSessionID());

        if (qbRtcClientSessionCallbacks != null) {
            qbRtcClientSessionCallbacks.onReceiveHangUpFromUser(qbrtcSession, integer, map);
        }
    }

    @Override
    public void onUserNoActions(QBRTCSession qbRtcSession, Integer integer) {
        Log.d(TAG, "onUserNoActions(), qbRtcSession.getSession() = " + qbRtcSession.getSessionID());

        if (qbRtcClientSessionCallbacks != null) {
            qbRtcClientSessionCallbacks.onUserNoActions(qbRtcSession, integer);
        }
    }

    @Override
    public void onSessionClosed(QBRTCSession qbRtcSession) {
        Log.d(TAG, "onSessionClosed(), qbRtcSession.getSession() = " + qbRtcSession.getSessionID());

        if (qbRtcClientSessionCallbacks != null) {
            qbRtcClientSessionCallbacks.onSessionClosed(qbRtcSession);
        }
    }

    @Override
    public void onSessionStartClose(QBRTCSession qbRtcSession) {
        Log.d(TAG, "onSessionStartClose(), qbRtcSession.getSession() = " + qbRtcSession.getSessionID());

        if (qbRtcClientSessionCallbacks != null) {
            qbRtcClientSessionCallbacks.onSessionStartClose(qbRtcSession);
        }
    }
}

class CameraErrorHandler implements CameraVideoCapturer.CameraEventsHandler {

    @Override
    public void onCameraError(String s) {
        Log.e(TAG, "Error on cams, error = " + s);
    }

    @Override
    public void onCameraDisconnected() {

    }

    @Override
    public void onCameraFreezed(String s) {
        Log.e(TAG, "Camera is frozen " + s);
    }

    @Override
    public void onCameraOpening(String i) {
        Log.e(TAG, "Camera opening = " + i);
    }

    @Override
    public void onFirstFrameAvailable() {
        Log.e(TAG, "Camera first frame available");
    }

    @Override
    public void onCameraClosed() # {
        Log.e(TAG, "Camera closed");
    }
}

}`

# And this is CallActivity:>>>>>

public class CallActivity extends BaseLoggableActivity implements QBRTCClientSessionCallbacks, QBRTCSessionConnectionCallbacks, QBRTCSignalingCallback {

public static final int CALL_ACTIVITY_CLOSE = 1000;
public static final int CALL_ACTIVITY_CLOSE_WIFI_DISABLED = 1001;

private static final String TAG = CallActivity.class.getSimpleName();

@Bind(R.id.timer_chronometer)
Chronometer timerChronometer;

private QBRTCTypes.QBConferenceType qbConferenceType;
private List<QBUser> opponentsList;
private Runnable showIncomingCallWindowTask;
private Handler showIncomingCallWindowTaskHandler;
private BroadcastReceiver wifiStateReceiver;
private boolean closeByWifiStateAllow = true;
private String hangUpReason;
private boolean isInComingCall;
private boolean isInFront;
private QBRTCClient qbRtcClient;
private boolean wifiEnabled = true;
private RingtonePlayer ringtonePlayer;
private boolean isStarted = false;

private QBRTCSessionUserCallback qbRtcSessionUserCallback;
private QBCallChatHelper qbCallChatHelper;
private StartConversationReason startConversationReason;
private QBRTCSessionDescription qbRtcSessionDescription;
private ActionBar actionBar;
private AudioStreamReceiver audioStreamReceiver;
private String ACTION_ANSWER_CALL = "action_answer_call";
private SystemPermissionHelper systemPermissionHelper;

//!MODIFY

public static void start(Activity activity, List<QBUser> qbUsersList, QBRTCTypes.QBConferenceType qbConferenceType,
                         QBRTCSessionDescription qbRtcSessionDescription) {
    Intent intent = new Intent(activity, CallActivity.class);
    intent.putExtra(QBServiceConsts.EXTRA_OPPONENTS, (Serializable) qbUsersList);
    intent.putExtra(QBServiceConsts.EXTRA_CONFERENCE_TYPE, qbConferenceType);
    intent.putExtra(QBServiceConsts.EXTRA_START_CONVERSATION_REASON_TYPE, StartConversationReason.OUTCOME_CALL_MADE);
    intent.putExtra(QBServiceConsts.EXTRA_SESSION_DESCRIPTION, qbRtcSessionDescription);
    intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT| Intent.FLAG_ACTIVITY_CLEAR_TASK);
    activity.startActivityForResult(intent, CALL_ACTIVITY_CLOSE);
}

@Override
protected int getContentResId() {
    return R.layout.activity_call;
}

public void initActionBar() {
    toolbar = (Toolbar) findViewById(R.id.toolbar_call);
    if (toolbar != null) {
        toolbar.setVisibility(View.VISIBLE);
        setSupportActionBar(toolbar);
    }

    actionBar = getSupportActionBar();

}

public void setCallActionBarTitle(String title){
    if (actionBar != null) {
        actionBar.setTitle(title);
    }
}

public void hideCallActionBar(){
    if (actionBar != null) {
        actionBar.hide();
    }
}

public void showCallActionBar(){
    if (actionBar != null) {
        actionBar.show();
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    App.setFragmentManager(getSupportFragmentManager());
    super.onCreate(savedInstanceState);
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON|
            WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD|
            WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED|
            WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);

    canPerformLogout.set(false);
    initFields();
    audioStreamReceiver = new AudioStreamReceiver();
    initWiFiManagerListener();
    if (ACTION_ANSWER_CALL.equals(getIntent().getAction())){
        checkPermissionsAndStartCall(StartConversationReason.INCOME_CALL_FOR_ACCEPTION);
    }
}

private void initCallFragment() {
    switch (startConversationReason) {
        case INCOME_CALL_FOR_ACCEPTION:
            if (qbRtcSessionDescription != null) {
                addIncomingCallFragment(qbRtcSessionDescription);
                isInComingCall = true;
                initIncomingCallTask();
            }
            break;
        case OUTCOME_CALL_MADE:
            checkPermissionsAndStartCall(StartConversationReason.OUTCOME_CALL_MADE);
            break;
    }
}

@Override
protected void onStop() {
    super.onStop();
    unregisterReceiver(wifiStateReceiver);
    unregisterReceiver(audioStreamReceiver);
}

@Override
protected void onPause() {
    isInFront = false;
    super.onPause();
}

@Override
protected void onResume() {
    isInFront = true;
    super.onResume();
}

@Override
protected void onStart() {
    super.onStart();

    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
    intentFilter.addAction(AudioManager.ACTION_HEADSET_PLUG);
    intentFilter.addAction(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED);
    registerReceiver(wifiStateReceiver, intentFilter);
    registerReceiver(audioStreamReceiver, intentFilter);
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.call_menu, menu);
    return true;
}

@Override
protected void onDestroy() {
    super.onDestroy();
    opponentsList = null;
    if (qbCallChatHelper != null) {
        qbCallChatHelper.removeRTCSessionUserCallback();
        qbCallChatHelper.releaseCurrentSession(CallActivity.this, CallActivity.this);
    }
}

@Override
public void onSuccessSendingPacket(QBSignalingSpec.QBSignalCMD qbSignalCMD, Integer integer) {
}

@Override
public void onErrorSendingPacket(QBSignalingSpec.QBSignalCMD qbSignalCMD, Integer userId,
                                 QBRTCSignalException e) {
    ToastUtils.longToast(R.string.dlg_signal_error);
}

@Override
public void onReceiveNewSession(final QBRTCSession session) {
    Log.d(TAG, "Session " + session.getSessionID() + " are income");
}

@Override
public void onUserNotAnswer(QBRTCSession session, Integer userID) {
    if (!session.equals(getCurrentSession())) {
        return;
    }

    if (qbRtcSessionUserCallback != null) {
        qbRtcSessionUserCallback.onUserNotAnswer(session, userID);
    }

    ringtonePlayer.stop();
}

@Override
public void onCallRejectByUser(QBRTCSession session, Integer userID, Map<String, String> userInfo) {
    if (!session.equals(getCurrentSession())) {
        return;
    }

    if (qbRtcSessionUserCallback != null) {
        qbRtcSessionUserCallback.onCallRejectByUser(session, userID, userInfo);
    }

    ringtonePlayer.stop();
}

@Override
public void onCallAcceptByUser(QBRTCSession session, Integer userId, Map<String, String> userInfo) {
    if (!session.equals(getCurrentSession())) {
        return;
    }

    if (qbRtcSessionUserCallback != null) {
        qbRtcSessionUserCallback.onCallAcceptByUser(session, userId, userInfo);
    }

    ringtonePlayer.stop();
}

@Override
public void onReceiveHangUpFromUser(final QBRTCSession session, final Integer userID, Map<String, String> map) {
    if (session.equals(getCurrentSession())) {

        if (qbRtcSessionUserCallback != null) {
            qbRtcSessionUserCallback.onReceiveHangUpFromUser(session, userID);
        }

        final String participantName = UserFriendUtils.getUserNameByID(userID, opponentsList);

        ToastUtils.longToast("User " + participantName + " " + getString(
                R.string.call_hung_up) + " conversation");
        finish();
    }
}

@Override
public void onUserNoActions(QBRTCSession qbrtcSession, Integer integer) {
    startIncomeCallTimer(0);
}

@Override
public void onSessionClosed(final QBRTCSession session) {
    Log.d(TAG, "Session " + session.getSessionID() + " start stop session");

    if (session.equals(getCurrentSession())) {

        Fragment currentFragment = getCurrentFragment();
        if (isInComingCall) {
            stopIncomeCallTimer();
            if (currentFragment instanceof IncomingCallFragment) {
                removeFragment();
                finish();
            }
        }

        Log.d(TAG, "Stop session");

        if (qbCallChatHelper != null) {
            qbCallChatHelper.releaseCurrentSession(CallActivity.this, CallActivity.this);
        }

        stopTimer();
        closeByWifiStateAllow = true;
        finish();
    }
}

@Override
public void onSessionStartClose(final QBRTCSession session) {
    session.removeSessionCallbacksListener(CallActivity.this);
    if (currentFragment instanceof ConversationCallFragment && session.equals(getCurrentSession())) {
        ((ConversationCallFragment) currentFragment).actionButtonsEnabled(false);
    }
}

@Override
public void onStartConnectToUser(QBRTCSession session, Integer userID) {

}

@Override
public void onStateChanged(QBRTCSession qbrtcSession, BaseSession.QBRTCSessionState qbrtcSessionState) {

}

@Override
public void onConnectedToUser(QBRTCSession session, final Integer userID) {
    forbiddenCloseByWifiState();
    if (isInComingCall) {
        stopIncomeCallTimer();
    }
    Log.d(TAG, "onConnectedToUser() is started");
}

@Override
public void onConnectionClosedForUser(QBRTCSession session, Integer userID) {
    // Close app after session close of network was disabled
    if (hangUpReason != null && hangUpReason.equals(QBServiceConsts.EXTRA_WIFI_DISABLED)) {
        Intent returnIntent = new Intent();
        setResult(CALL_ACTIVITY_CLOSE_WIFI_DISABLED, returnIntent);
    }
    finish();
}

@Override
public void onDisconnectedFromUser(QBRTCSession session, Integer userID) {

}

@Override
public void onDisconnectedTimeoutFromUser(QBRTCSession session, Integer userID) {

}

@Override
public void onConnectionFailedWithUser(QBRTCSession session, Integer userID) {

}

@Override
public void onConnectedToService(QBService service) {
    super.onConnectedToService(service);
    if (qbCallChatHelper == null) {
        qbCallChatHelper = (QBCallChatHelper) service.getHelper(QBService.CALL_CHAT_HELPER);
        systemPermissionHelper = new SystemPermissionHelper(CallActivity.this);
        qbCallChatHelper.addRTCSessionUserCallback(CallActivity.this);
        initCallFragment();
    }
}

private void initFields() {
    opponentsList = (List<QBUser>) getIntent().getExtras().getSerializable(QBServiceConsts.EXTRA_OPPONENTS);
    qbConferenceType = (QBRTCTypes.QBConferenceType) getIntent().getExtras().getSerializable(QBServiceConsts.EXTRA_CONFERENCE_TYPE);
    startConversationReason = (StartConversationReason) getIntent().getExtras().getSerializable(QBServiceConsts.EXTRA_START_CONVERSATION_REASON_TYPE);
    qbRtcSessionDescription = (QBRTCSessionDescription) getIntent().getExtras().getSerializable(QBServiceConsts.EXTRA_SESSION_DESCRIPTION);

    ringtonePlayer = new RingtonePlayer(this, R.raw.beep);
    // Add activity as callback to RTCClient
    qbRtcClient = QBRTCClient.getInstance(this);

}

private void initWiFiManagerListener() {
    wifiStateReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.d(TAG, "WIFI was changed");
            processCurrentWifiState(context);
        }
    };
}

public QMUser getOpponentAsUserFromDB(final int opponentId){
    /*DataManager dataManager = DataManager.getInstance();
    Friend friend = dataManager.getFriendDataManager().getByUserId(opponentId);*/

    //!MODIFY
    Log.i(TAG, "getting friend");
    FriendsHelper friendsHelper = new FriendsHelper(CallActivity.this);
    final QMUser[] qmUser = {friendsHelper.getFriend(Integer.toString(opponentId))};
    return qmUser[0];
}

private void processCurrentWifiState(Context context) {
    WifiManager wifi = (WifiManager) context.getSystemService(WIFI_SERVICE);
    if (wifiEnabled != wifi.isWifiEnabled()) {
        wifiEnabled = wifi.isWifiEnabled();
        ToastUtils.longToast("Wifi " + (wifiEnabled ? "enabled" : "disabled"));
    }
}

private void disableConversationFragmentButtons() {
    if (currentFragment instanceof ConversationCallFragment) {
        ((ConversationCallFragment) currentFragment).actionButtonsEnabled(false);
    }
}

private void initIncomingCallTask() {
    showIncomingCallWindowTaskHandler = new Handler(Looper.myLooper());
    showIncomingCallWindowTask = new Runnable() {
        @Override
        public void run() {
            if (currentFragment instanceof ConversationCallFragment) {
                disableConversationFragmentButtons();
                ringtonePlayer.stop();
                hangUpCurrentSession();
            } else {
                rejectCurrentSession();
            }

            ToastUtils.longToast("Call was stopped by timer");
        }
    };
}

public void rejectCurrentSession() {
    if (qbCallChatHelper != null && qbCallChatHelper.getCurrentRtcSession() != null) {
        qbCallChatHelper.getCurrentRtcSession().rejectCall(new HashMap<String, String>());
    }
    finish();
}

public void hangUpCurrentSession() {
    ringtonePlayer.stop();
    if (qbCallChatHelper != null && qbCallChatHelper.getCurrentRtcSession() != null) {
        qbCallChatHelper.getCurrentRtcSession().hangUp(new HashMap<String, String>());
    }
    finish();
}

private void startIncomeCallTimer(long time) {
    showIncomingCallWindowTaskHandler
            .postAtTime(showIncomingCallWindowTask, SystemClock.uptimeMillis() + time);
}

private void stopIncomeCallTimer() {
    Log.d(TAG, "stopIncomeCallTimer");
    showIncomingCallWindowTaskHandler.removeCallbacks(showIncomingCallWindowTask);
}

private void forbiddenCloseByWifiState() {
    closeByWifiStateAllow = false;
}

private Fragment getCurrentFragment() {
    return getSupportFragmentManager().findFragmentById(R.id.container_fragment);
}

private void addIncomingCallFragment(QBRTCSessionDescription qbRtcSessionDescription) {
    Log.d(TAG, "QBRTCSession in addIncomingCallFragment is " + qbRtcSessionDescription);
    /*if (isInFront) {
        Fragment fragment = new IncomingCallFragment();
        Bundle bundle = new Bundle();
        bundle.putSerializable(QBServiceConsts.EXTRA_SESSION_DESCRIPTION, qbRtcSessionDescription);
        bundle.putIntegerArrayList(QBServiceConsts.EXTRA_OPPONENTS, new ArrayList<>(qbRtcSessionDescription.getOpponents()));
        bundle.putSerializable(QBServiceConsts.EXTRA_CONFERENCE_TYPE,
                qbRtcSessionDescription.getConferenceType());
        fragment.setArguments(bundle);
        setCurrentFragment(fragment);
    } else {
        Log.d(TAG, "SKIP addIncomingCallFragment method");
    }*/
    Fragment fragment = new IncomingCallFragment();
    Bundle bundle = new Bundle();
    bundle.putSerializable(QBServiceConsts.EXTRA_SESSION_DESCRIPTION, qbRtcSessionDescription);
    bundle.putIntegerArrayList(QBServiceConsts.EXTRA_OPPONENTS, new ArrayList<>(qbRtcSessionDescription.getOpponents()));
    bundle.putSerializable(QBServiceConsts.EXTRA_CONFERENCE_TYPE,
            qbRtcSessionDescription.getConferenceType());
    fragment.setArguments(bundle);
    setCurrentFragment(fragment);
}

public void checkPermissionsAndStartCall(StartConversationReason startConversationReason) {
    if (systemPermissionHelper.isAllPermissionsGrantedForCallByType(qbConferenceType)) {
        startConversationFragment(startConversationReason);
    } else {
        systemPermissionHelper.requestPermissionsForCallByType(qbConferenceType);
    }
}

public void addConversationCallFragment() {
    Log.d(TAG, "addConversationCallFragment()");

    QBRTCSession newSessionWithOpponents = qbRtcClient.createNewSessionWithOpponents(
            UserFriendUtils.getFriendIdsList(opponentsList), qbConferenceType);
    SettingsUtil.setSettingsStrategy(this, opponentsList);

    if (qbCallChatHelper != null) {
        qbCallChatHelper.initCurrentSession(newSessionWithOpponents, this, this);

        ConversationCallFragment fragment = ConversationCallFragment
                .newInstance(opponentsList, opponentsList.get(0).getFullName(), qbConferenceType,
                        StartConversationReason.OUTCOME_CALL_MADE,
                        qbCallChatHelper.getCurrentRtcSession().getSessionID());

        setCurrentFragment(fragment);
        ringtonePlayer.play(true);
    } else {
        throw new NullPointerException("qbCallChatHelper is not initialized");
    }
}

public List<QBUser> getOpponentsList() {
    return opponentsList;
}

public void setOpponentsList(List<QBUser> qbUsers) {
    this.opponentsList = qbUsers;
}

public void addConversationFragmentReceiveCall() {
    if (qbCallChatHelper != null) {
        QBRTCSession session = qbCallChatHelper.getCurrentRtcSession();

        if (session != null) {
            Integer myId = QBChatService.getInstance().getUser().getId();
            ArrayList<Integer> opponentsWithoutMe = new ArrayList<>(session.getOpponents());
            opponentsWithoutMe.remove(new Integer(myId));
            opponentsWithoutMe.add(session.getCallerID());

            ArrayList<QBUser> newOpponents = (ArrayList<QBUser>) UserFriendUtils
                    .getUsersByIDs(opponentsWithoutMe.toArray(new Integer[opponentsWithoutMe.size()]),
                            opponentsList);
            SettingsUtil.setSettingsStrategy(this, newOpponents);
            ConversationCallFragment fragment = ConversationCallFragment.newInstance(newOpponents,
                    UserFriendUtils.getUserNameByID(session.getCallerID(), newOpponents),
                    session.getConferenceType(), StartConversationReason.INCOME_CALL_FOR_ACCEPTION,
                    session.getSessionID());
            // Start conversation fragment
            setCurrentFragment(fragment);
        }
    }
}

public void startTimer() {
    Log.d(TAG, "startTimer() from CallActivity, timerChronometer = " + timerChronometer);
    if (!isStarted) {
        timerChronometer.setVisibility(View.VISIBLE);
        timerChronometer.setBase(SystemClock.elapsedRealtime());
        timerChronometer.start();
        isStarted = true;
    }
}

private void stopTimer(){
    if (timerChronometer != null) {
        timerChronometer.stop();
        isStarted = false;
    }
}

public QBRTCSession getCurrentSession() {
    if (qbCallChatHelper != null) {
        return qbCallChatHelper.getCurrentRtcSession();
    } else {
        return null;
    }
}

public void addVideoTrackCallbacksListener(QBRTCClientVideoTracksCallbacks videoTracksCallbacks) {
    if (getCurrentSession() != null) {
        getCurrentSession().addVideoTrackCallbacksListener(videoTracksCallbacks);
    }
}

@Override
public void onBackPressed() {
    //blocked back button
}

@Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
    switch (requestCode) {
        case SystemPermissionHelper.PERMISSIONS_FOR_CALL_REQUEST: {
            if (grantResults.length > 0) {
                if (!systemPermissionHelper.isAllPermissionsGrantedForCallByType(qbConferenceType)){
                    showToastDeniedPermissions(permissions, grantResults);
                }
            }

            //postDelayed() is temp fix before fixing this bug https://code.google.com/p/android/issues/detail?id=190966
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    startConversationFragment(startConversationReason);
                }
            }, 500);
        }
    }
}

private void startConversationFragment(StartConversationReason startConversationReason) {
    if(StartConversationReason.OUTCOME_CALL_MADE.equals(startConversationReason)){
        addConversationCallFragment();
    } else {
        addConversationFragmentReceiveCall();
    }
}

private void showToastDeniedPermissions(String[] permissions, int[] grantResults) {
    ArrayList<String> deniedPermissions = systemPermissionHelper
            .collectDeniedPermissionsFomResult(permissions, grantResults);

    ToastUtils.longToast(
            getString(R.string.denied_permission_message, StringUtils.createCompositeString(deniedPermissions)));
}

public void addTCClientConnectionCallback(QBRTCSessionConnectionCallbacks clientConnectionCallbacks) {
    if (getCurrentSession() != null) {
        getCurrentSession().addSessionCallbacksListener(clientConnectionCallbacks);
    }
}

public void removeRTCClientConnectionCallback(QBRTCSessionConnectionCallbacks clientConnectionCallbacks) {
    if (getCurrentSession() != null) {
        getCurrentSession().removeSessionCallbacksListener(clientConnectionCallbacks);
    }
}

public void addRTCSessionUserCallback(QBRTCSessionUserCallback qbRtcSessionUserCallback) {
    this.qbRtcSessionUserCallback = qbRtcSessionUserCallback;
}

public void removeRTCSessionUserCallback() {
    this.qbRtcSessionUserCallback = null;
}

private class AudioStreamReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {

        if (intent.getAction().equals(AudioManager.ACTION_HEADSET_PLUG)) {
            Log.d(TAG, "ACTION_HEADSET_PLUG " + intent.getIntExtra("state", -1));
        } else if (intent.getAction().equals(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED)) {
            Log.d(TAG, "ACTION_SCO_AUDIO_STATE_UPDATED " + intent.getIntExtra("EXTRA_SCO_AUDIO_STATE", -2));
        }

        invalidateOptionsMenu();
    }
}

public interface QBRTCSessionUserCallback {

    void onUserNotAnswer(QBRTCSession session, Integer userId);

    void onCallRejectByUser(QBRTCSession session, Integer userId, Map<String, String> userInfo);

    void onCallAcceptByUser(QBRTCSession session, Integer userId, Map<String, String> userInfo);

    void onReceiveHangUpFromUser(QBRTCSession session, Integer userId);
}
tatanka987 commented 6 years ago

If I correct understand, this issue related with #252 . We can't provide fast solution for implementation this feature.