softphonemanager.java

开源项目openfire的完整源程序

        sipManager.transfer(callID, callee);

    }

    /**
     * Handle a Mute request
     *
     * @param iui the InterlocutorUI
     * @param mic true to place on mute.
     */
    public void handleMute(InterlocutorUI iui, boolean mic) {
        try {
            AudioMediaSession audioMediaSession = iui.getCall().getAudioMediaSession();
            if (audioMediaSession != null) audioMediaSession.setTrasmit(mic);
        }
        catch (Exception e) {
            Log.error("handleHold", e);
        }
    }

    /**
     * Handle when users press a dtmf button
     *
     * @param iui the InterlocutorUI
     */
    public void handleDTMF(InterlocutorUI iui, String digit) {
        try {
            sendDTMFDigit(iui.getID(), digit);
        }
        catch (Exception e) {
            Log.error("sendDTMFDigit", e);
        }
    }

    /**
     * Send the dtmf digit to the sip server.
     *
     * @param callID the caller id
     * @param digit  the digit typed.
     */
    void sendDTMFDigit(int callID, String digit) {
        try {
            sipManager.sendDTMF(callID, digit);
        }
        catch (CommunicationsException exc) {
            Log.error("sendDTMFDigit", exc);
        }
    }

    /**
     * Handle a answer request
     */
    public boolean handleAnswerRequest(Interlocutor interlocutor) {

        // cancel call request if no Media Locator
        if (PhoneManager.isUseStaticLocator() && PhoneManager.isUsingMediaLocator()) {
            return false;
        }

        PhoneManager.setUsingMediaLocator(true);

        SessionDescription sdpData = null;
        try {
            sdpData = mediaManager.generateSdpDescription();
            interlocutor.getCall().setLocalSdpDescription(sdpData);
        }
        catch (MediaException ex) {
            try {
                sipManager.sendServerInternalError(interlocutor.getID());
            }
            catch (CommunicationsException ex1) {
                Log.error("handleAnswerRequest", ex1);
            }
            return false;
        }
        try {
            sipManager.answerCall(interlocutor.getID(), sdpData.toString());
        }
        catch (CommunicationsException exc) {
            Log.error("handleAnswerRequest", exc);
            return false;
        }
        return true;
    }

    /**
     * Handle a dial request
     */
    public void handleDialRequest(String phoneNumber) {
        try {

            System.err.println("Wesde " + PhoneManager.isUseStaticLocator() + " " + PhoneManager.isUsingMediaLocator());

            // cancel call request if no Media Locator
            if (PhoneManager.isUseStaticLocator() && PhoneManager.isUsingMediaLocator()) {
                return;
            }

            PhoneManager.setUsingMediaLocator(true);

            SessionDescription sdpData = mediaManager.generateSdpDescription();

            Call call = sipManager.establishCall(phoneNumber, sdpData.toString());

            if (call == null) return;

            call.setLocalSdpDescription(sdpData);

            call.addStateChangeListener(this);

            Interlocutor interlocutor = new Interlocutor();
            interlocutor.setCall(call);

            guiManager.addInterlocutor(interlocutor);
        }
        catch (Exception e) {
            Log.error("handleDialRequest", e);
        }
    }

    /**
     * Handle a hangup request
     */
    public boolean handleHangupRequest(Interlocutor interlocutor) {
        boolean hangupOk = true;
        try {
            sipManager.endCall(interlocutor.getID());
        }
        catch (CommunicationsException exc) {
            guiManager.remove(interlocutor);
            hangupOk = false;
            Log.error("handleHangupRequest", exc);
        }
        return hangupOk;
    }

    /**
     * Register the softPhone with the Spark preferrence settings
     */
    public void register() {
        Thread registerThread = new Thread(new Runnable() {
            public void run() {
                if (preferences != null) {
                    String user = preferences.getUserName();
                    String authUser = preferences.getAuthUserName();
                    String server = preferences.getServer();
                    String pass = preferences.getPassword();

                    try {
                        createSoftPhone(server);
                    }
                    catch (MediaException e) {
                        Log.error("Media Exception", e);

                    }

                    handleRegisterRequest(user, authUser, pass);
                }
            }
        });

        registerThread.start();
    }

    /**
     * Loads Preferences, either from server or locally.
     */
    private void loadPreferences() {
        boolean serverPluginInstalled = SipAccountPacket.isSoftPhonePluginInstalled(SparkManager.getConnection());
        if (serverPluginInstalled) {
            setupRemotePreferences(SparkManager.getConnection());
        }
    }

    /**
     * Returns the LogManager associated with this SoftPhone.
     *
     * @return the LogManager.
     */
    public LogManager getLogManager() {
        return logManager;
    }

    /**
     * Setup the Preferences according to remote server
     *
     * @param con XMPPConnection connection
     */
    private void setupRemotePreferences(XMPPConnection con) {

        try {
            ProviderManager.getInstance().addIQProvider(SipAccountPacket.ELEMENT_NAME, SipAccountPacket.NAMESPACE, new SipAccountPacket.Provider());

            ProviderManager.getInstance().addIQProvider(LogPacket.ELEMENT_NAME, LogPacket.NAMESPACE, new LogPacket.Provider());

            SipAccountPacket sp = SipAccountPacket.getSipSettings(con);

            if (sp != null) {

                SipAccount sipAccount = sp.getSipAccount();

                if (sipAccount != null) {
                    this.saccount = sipAccount;
                    preference = new SipPreference();
                    preference.setShowGUI(false);
                    preference.setCommitSettings(false);

                    preferences = new SipPreferences();

                    preferences.setUserName(sipAccount.getSipUsername());
                    preferences.setAuthUserName(sipAccount.getAuthUsername());
                    preferences.setServer(sipAccount.getServer());
                    preferences.setPassword(sipAccount.getPassword());
                    preferences.setRegisterAtStart(true);

                    preferences.setStunServer(sipAccount.getStunServer());
                    preferences.setStunPort(sipAccount.getStunPort());
                    preferences.setUseStun(sipAccount.isUseStun());
                    preferences.setVoicemail(sipAccount.getVoiceMailNumber());
                    preferences.setOutboundproxy(sipAccount.getOutboundproxy());
                    preferences.setPromptCredentials(sipAccount.isPromptCredentials());

                    SIPConfig.setUseStun(preferences.isUseStun());
                    SIPConfig.setStunServer(preferences.getStunServer());
                    SIPConfig.setStunPort(preferences.getStunPort());
                    SIPConfig.setOutboundProxy(preferences.getOutboundproxy());

                    preference.setData(preferences);
                    SIPConfig.setPreferredNetworkAddress(NetworkAddressManager.getLocalHost(false).getHostAddress());

                    if (preferences.isRegisterAtStart()) {
                        register();
                    }

                    if (preferences.isPromptCredentials()) {
                        loadLocalPreferences();
                    }

                } else {

                }
            }

        }
        catch (Exception e) {
            Log.error("setupRemotePreferences", e);
        }

    }

    private void loadLocalPreferences() {
        preference = new SipPreference();

        PreferenceManager pm = SparkManager.getPreferenceManager();
        pm.addPreference(preference);

        preferences = (SipPreferences) preference.getData();

        SIPConfig.setUseStun(preferences.isUseStun());
        SIPConfig.setStunServer(preferences.getStunServer());
        SIPConfig.setStunPort(preferences.getStunPort());
        SIPConfig.setPreferredNetworkAddress(preferences.getPreferredAddress());

        preference.setCommitSettings(true);

        if (preferences.isRegisterAtStart()) {
            register();
        }
    }


    /**
     * Calls an individual user by their VCard information.
     *
     * @param jid the users JID.
     */
    public void callByJID(String jid) {
        if (getStatus() == SipRegisterStatus.Registered) {
            final VCard vcard = SparkManager.getVCardManager().getVCard(StringUtils.parseBareAddress(jid));

            if (vcard != null) {
                String number = vcard.getPhoneWork("VOICE");
                if (!ModelUtil.hasLength(number)) {
                    number = vcard.getPhoneHome("VOICE");
                }

                if (ModelUtil.hasLength(number)) {
                    getDefaultGuiManager().dial(number);
                }
            }
        }
    }

    /**
     * Returns the SoundManager for Dial Tones.
     *
     * @return the SoundManager.
     */
    public DialSoundManager getDTMFSounds() {
        if (dtmfSounds == null) {
            dtmfSounds = new DialSoundManager();
        }
        return dtmfSounds;
    }


    public SipPreference getPreference() {
        return preference;
    }

    public MissedCalls getMissedCalls() {
        return missedCalls;
    }

    public static String getNumbersFromPhone(String number) {
        if (number == null) {
            return null;
        }

        number = number.replace("-", "");
        number = number.replace("(", "");
        number = number.replace(")", "");
        number = number.replace(" ", "");
        if (number.startsWith("1")) {
            number = number.substring(1);
        }

        return number;
    }

    public SipAccount getSipAccount() {
        return saccount;
    }

    /**
     * Adds a new CallRoomState.
     *
     * @param component the component where the call is taking place.
     * @param state     the state of the call.
     */
    public void addCallSession(Component component, CallRoomState state) {
        callRooms.put(component, state);
    }

    /**
     * Removes a CallRoomState.
     *
     * @param component the component where the call is taking place.
     */
    public void removeCallSession(Component component) {
        callRooms.remove(component);
    }

    /**
     * Returns the state of a <code>Component</code>. If no call is taking place,
     * this method will return null.
     *
     * @param component the <code>Component</code>.
     * @return the CallRoomState.
     */
    public CallRoomState getCallRoomState(Component component) {
        return callRooms.get(component);
    }

    /**
     * Returns true if the user is connected.
     *
     * @return true if the user is connected.
     */
    public boolean isPhoneEnabled() {
        return getPreference() != null;
    }
}