path: root/indra/newview/llfloaterimsession.cpp

/**
 * @file llfloaterimsession.cpp
 * @brief LLFloaterIMSession class definition
 *
 * $LicenseInfo:firstyear=2009&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "llviewerprecompiledheaders.h"

#include "llfloaterimsession.h"

#include "lldraghandle.h"
#include "llnotificationsutil.h"

#include "llagent.h"
#include "llappviewer.h"
#include "llavataractions.h"
#include "llavatarnamecache.h"
#include "llbutton.h"
#include "llchannelmanager.h"
#include "llchiclet.h"
#include "llchicletbar.h"
#include "lldonotdisturbnotificationstorage.h"
#include "llfloaterreg.h"
#include "llfloateravatarpicker.h"
#include "llfloaterimcontainer.h" // to replace separate IM Floaters with multifloater container
#include "llinventoryfunctions.h"
//#include "lllayoutstack.h"
#include "llchatentry.h"
#include "lllogchat.h"
#include "llscreenchannel.h"
#include "llsyswellwindow.h"
#include "lltrans.h"
#include "llchathistory.h"
#include "llnotifications.h"
#include "llviewerregion.h"
#include "llviewerwindow.h"
#include "lltransientfloatermgr.h"
#include "llinventorymodel.h"
#include "llrootview.h"
#include "llspeakers.h"
#include "llviewerchat.h"
#include "llnotificationmanager.h"
#include "llautoreplace.h"
#include "llcorehttputil.h"

const F32 ME_TYPING_TIMEOUT = 4.0f;
const F32 OTHER_TYPING_TIMEOUT = 9.0f;

floater_showed_signal_t LLFloaterIMSession::sIMFloaterShowedSignal;

LLFloaterIMSession::LLFloaterIMSession(const LLUUID& session_id)
  : LLFloaterIMSessionTab(session_id),
    mLastMessageIndex(-1),
    mDialog(IM_NOTHING_SPECIAL),
    mTypingStart(),
    mShouldSendTypingState(false),
    mMeTyping(false),
    mOtherTyping(false),
    mSessionNameUpdatedForTyping(false),
    mTypingTimer(),
    mTypingTimeoutTimer(),
    mPositioned(false),
    mSessionInitialized(false),
    mMeTypingTimer(),
    mOtherTypingTimer()
{
    mIsNearbyChat = false;

    initIMSession(session_id);

    setOverlapsScreenChannel(true);

    LLTransientFloaterMgr::getInstance()->addControlView(LLTransientFloaterMgr::IM, this);
    mEnableCallbackRegistrar.add("Avatar.EnableGearItem", boost::bind(&LLFloaterIMSession::enableGearMenuItem, this, _2));
    mCommitCallbackRegistrar.add("Avatar.GearDoToSelected", boost::bind(&LLFloaterIMSession::GearDoToSelected, this, _2));
    mEnableCallbackRegistrar.add("Avatar.CheckGearItem", boost::bind(&LLFloaterIMSession::checkGearMenuItem, this, _2));
    mVoiceChannelChanged = LLVoiceChannel::setCurrentVoiceChannelChangedCallback(boost::bind(&LLFloaterIMSession::onVoiceChannelChanged, this, _1));

    setDocked(true);
}


// virtual
void LLFloaterIMSession::refresh()
{
    if (mMeTyping)
{
        // Send an additional Start Typing packet every ME_TYPING_TIMEOUT seconds
        if (mMeTypingTimer.getElapsedTimeF32() > ME_TYPING_TIMEOUT && false == mShouldSendTypingState)
        {
            LL_DEBUGS("TypingMsgs") << "Send additional Start Typing packet" << LL_ENDL;
            LLIMModel::instance().sendTypingState(mSessionID, mOtherParticipantUUID, true);
            mMeTypingTimer.reset();
        }

        // Time out if user hasn't typed for a while.
        if (mTypingTimeoutTimer.getElapsedTimeF32() > LLAgent::TYPING_TIMEOUT_SECS)
        {
    setTyping(false);
            LL_DEBUGS("TypingMsgs") << "Send stop typing due to timeout" << LL_ENDL;
        }
    }

    // Clear <name is typing> message if no data received for OTHER_TYPING_TIMEOUT seconds
    if (mOtherTyping && mOtherTypingTimer.getElapsedTimeF32() > OTHER_TYPING_TIMEOUT)
    {
        LL_DEBUGS("TypingMsgs") << "Received: is typing cleared due to timeout" << LL_ENDL;
        removeTypingIndicator(mImFromId);
        mOtherTyping = false;
    }

}

// virtual
void LLFloaterIMSession::onTearOffClicked()
{
    LLFloaterIMSessionTab::onTearOffClicked();
}

// virtual
void LLFloaterIMSession::onClickCloseBtn(bool app_qutting)
{
    if (app_qutting)
    {
        LLFloaterIMSessionTab::onClickCloseBtn();
        return;
    }

    LLIMModel::LLIMSession* session = LLIMModel::instance().findIMSession(mSessionID);

    if (session != NULL)
    {
        bool is_call_with_chat = session->isGroupSessionType()
                || session->isAdHocSessionType() || session->isP2PSessionType();

        LLVoiceChannel* voice_channel = LLIMModel::getInstance()->getVoiceChannel(mSessionID);

        if (is_call_with_chat && voice_channel != NULL
                && voice_channel->isActive())
        {
            LLSD payload;
            payload["session_id"] = mSessionID;
            LLNotificationsUtil::add("ConfirmLeaveCall", LLSD(), payload, confirmLeaveCallCallback);
            return;
        }
    }
    else
    {
        LL_WARNS() << "Empty session with id: " << (mSessionID.asString()) << LL_ENDL;
    }

    LLFloaterIMSessionTab::onClickCloseBtn();
}

/* static */
void LLFloaterIMSession::newIMCallback(const LLSD& data)
{
    if (data["num_unread"].asInteger() > 0 || data["from_id"].asUUID().isNull())
    {
        LLUUID session_id = data["session_id"].asUUID();

        LLFloaterIMSession* floater = LLFloaterReg::findTypedInstance<LLFloaterIMSession>("impanel", session_id);

        // update if visible, otherwise will be updated when opened
        if (floater && floater->isInVisibleChain())
        {
            floater->updateMessages();
        }
    }
}

void LLFloaterIMSession::onVisibilityChanged(const LLSD& new_visibility)
{
    bool visible = new_visibility.asBoolean();

    LLVoiceChannel* voice_channel = LLIMModel::getInstance()->getVoiceChannel(mSessionID);

    if (visible && voice_channel &&
        voice_channel->getState() == LLVoiceChannel::STATE_CONNECTED)
    {
        LLFloaterReg::showInstance("voice_call", mSessionID);
    }
    else
    {
        LLFloaterReg::hideInstance("voice_call", mSessionID);
    }
}

void LLFloaterIMSession::onSendMsg( LLUICtrl* ctrl, void* userdata )
{
    LLFloaterIMSession* self = (LLFloaterIMSession*) userdata;
    self->sendMsgFromInputEditor();
    self->setTyping(false);
}

bool LLFloaterIMSession::enableGearMenuItem(const LLSD& userdata)
{
    std::string command = userdata.asString();
    uuid_vec_t selected_uuids;
    selected_uuids.push_back(mOtherParticipantUUID);

    LLFloaterIMContainer* floater_container = LLFloaterIMContainer::getInstance();
    return floater_container->enableContextMenuItem(command, selected_uuids);
}

void LLFloaterIMSession::GearDoToSelected(const LLSD& userdata)
{
    std::string command = userdata.asString();
    uuid_vec_t selected_uuids;
    selected_uuids.push_back(mOtherParticipantUUID);

    LLFloaterIMContainer* floater_container = LLFloaterIMContainer::getInstance();
    floater_container->doToParticipants(command, selected_uuids);
}

bool LLFloaterIMSession::checkGearMenuItem(const LLSD& userdata)
{
    std::string command = userdata.asString();
    uuid_vec_t selected_uuids;
    selected_uuids.push_back(mOtherParticipantUUID);

    LLFloaterIMContainer* floater_container = LLFloaterIMContainer::getInstance();
    return floater_container->checkContextMenuItem(command, selected_uuids);
}

void LLFloaterIMSession::sendMsgFromInputEditor()
{
    if (gAgent.isGodlike()
        || (mDialog != IM_NOTHING_SPECIAL)
        || !mOtherParticipantUUID.isNull())
    {
        if (mInputEditor)
        {
            LLWString text = mInputEditor->getWText();
            LLWStringUtil::trim(text);
            LLWStringUtil::replaceChar(text,182,'\n'); // Convert paragraph symbols back into newlines.
            if(!text.empty())
            {
                updateUsedEmojis(text);

                // Truncate and convert to UTF8 for transport
                std::string utf8_text = wstring_to_utf8str(text);

                sendMsg(utf8_text);

                mInputEditor->setText(LLStringUtil::null);
            }
        }
    }
    else
    {
        LL_INFOS() << "Cannot send IM to everyone unless you're a god." << LL_ENDL;
    }
}

void LLFloaterIMSession::sendMsg(const std::string& msg)
{
    const std::string utf8_text = utf8str_truncate(msg, MAX_MSG_BUF_SIZE - 1);

    if (mSessionInitialized)
    {
        LLIMModel::sendMessage(utf8_text, mSessionID, mOtherParticipantUUID, mDialog);
    }
    else
    {
        //queue up the message to send once the session is initialized
        mQueuedMsgsForInit.append(utf8_text);
    }

    updateMessages();
}

LLFloaterIMSession::~LLFloaterIMSession()
{
    mVoiceChannelStateChangeConnection.disconnect();

    LLVoiceClient::removeObserver(this);

    LLTransientFloaterMgr::getInstance()->removeControlView(LLTransientFloaterMgr::IM, this);

    mVoiceChannelChanged.disconnect();
}


void LLFloaterIMSession::initIMSession(const LLUUID& session_id)
{
    // Change the floater key to bind it to a new session.
    setKey(session_id);

    mSessionID = session_id;
    mSession = LLIMModel::getInstance()->findIMSession(mSessionID);

    if (mSession)
    {
        mIsP2PChat = mSession->isP2PSessionType();
        mSessionInitialized = mSession->mSessionInitialized;
        mDialog = mSession->mType;
    }
}

void LLFloaterIMSession::initIMFloater()
{
    const LLUUID& other_party_id =
            LLIMModel::getInstance()->getOtherParticipantID(mSessionID);
    if (other_party_id.notNull())
    {
        mOtherParticipantUUID = other_party_id;
    }

    boundVoiceChannel();

    mTypingStart = LLTrans::getString("IM_typing_start_string");

    // Show control panel in torn off floaters only.
    mParticipantListPanel->setVisible(!getHost() && gSavedSettings.getBOOL("IMShowControlPanel"));

    // Disable input editor if session cannot accept text
    if ( mSession && !mSession->mTextIMPossible )
    {
        mInputEditor->setEnabled(false);
        mInputEditor->setLabel(LLTrans::getString("IM_unavailable_text_label"));
    }

    if (!mIsP2PChat)
    {
        std::string session_name(LLIMModel::instance().getName(mSessionID));
        updateSessionName(session_name);
    }
}

//virtual
bool LLFloaterIMSession::postBuild()
{
    bool result = LLFloaterIMSessionTab::postBuild();

    mInputEditor->setMaxTextLength(1023);
    mInputEditor->setAutoreplaceCallback(boost::bind(&LLAutoReplace::autoreplaceCallback, LLAutoReplace::getInstance(), _1, _2, _3, _4, _5));
    mInputEditor->setFocusReceivedCallback( boost::bind(onInputEditorFocusReceived, _1, this) );
    mInputEditor->setFocusLostCallback( boost::bind(onInputEditorFocusLost, _1, this) );
    mInputEditor->setKeystrokeCallback( boost::bind(onInputEditorKeystroke, _1, this) );
    mInputEditor->setCommitCallback(boost::bind(onSendMsg, _1, this));

    setDocked(true);

    LLButton* add_btn = getChild<LLButton>("add_btn");

    // Allow to add chat participants depending on the session type
    add_btn->setEnabled(isInviteAllowed());
    add_btn->setClickedCallback(boost::bind(&LLFloaterIMSession::onAddButtonClicked, this));

    LLVoiceClient::addObserver(this);

    //*TODO if session is not initialized yet, add some sort of a warning message like "starting session...blablabla"
    //see LLFloaterIMPanel for how it is done (IB)

    initIMFloater();

    return result;
}

void LLFloaterIMSession::onAddButtonClicked()
{
    LLView * button = findChild<LLView>("toolbar_panel")->findChild<LLButton>("add_btn");
    LLFloater* root_floater = gFloaterView->getParentFloater(this);
    LLFloaterAvatarPicker* picker = LLFloaterAvatarPicker::show(boost::bind(&LLFloaterIMSession::addSessionParticipants, this, _1), true, true, false, root_floater->getName(), button);
    if (!picker)
    {
        return;
    }

    // Need to disable 'ok' button when selected users are already in conversation.
    picker->setOkBtnEnableCb(boost::bind(&LLFloaterIMSession::canAddSelectedToChat, this, _1));

    if (root_floater)
    {
        root_floater->addDependentFloater(picker);
    }
}

bool LLFloaterIMSession::canAddSelectedToChat(const uuid_vec_t& uuids)
{
    if (!mSession
        || mDialog == IM_SESSION_GROUP_START
        || (mDialog == IM_SESSION_INVITE && gAgent.isInGroup(mSessionID)))
    {
        return false;
    }

    if (mIsP2PChat)
    {
        // For a P2P session just check if we are not adding the other participant.

        for (uuid_vec_t::const_iterator id = uuids.begin();
                id != uuids.end(); ++id)
        {
            if (*id == mOtherParticipantUUID)
            {
                return false;
            }
        }
    }
    else
    {
        // For a conference session we need to check against the list from LLSpeakerMgr,
        // because this list may change when participants join or leave the session.

        LLSpeakerMgr::speaker_list_t speaker_list;
        LLIMSpeakerMgr* speaker_mgr = LLIMModel::getInstance()->getSpeakerManager(mSessionID);
        if (speaker_mgr)
        {
            speaker_mgr->getSpeakerList(&speaker_list, true);
        }

        for (uuid_vec_t::const_iterator id = uuids.begin();
                id != uuids.end(); ++id)
        {
            for (LLSpeakerMgr::speaker_list_t::const_iterator it = speaker_list.begin();
                    it != speaker_list.end(); ++it)
            {
                const LLPointer<LLSpeaker>& speaker = *it;
                if (*id == speaker->mID)
                {
                    return false;
                }
            }
        }
    }

    return true;
}

void LLFloaterIMSession::addSessionParticipants(const uuid_vec_t& uuids)
{
    if (mIsP2PChat)
    {
        LLSD payload;
        LLSD args;

        LLNotificationsUtil::add("ConfirmAddingChatParticipants", args, payload,
                boost::bind(&LLFloaterIMSession::addP2PSessionParticipants, this, _1, _2, uuids));
    }
    else
    {
        if(findInstance(mSessionID))
        {
            // remember whom we have invited, to notify others later, when the invited ones actually join
            mInvitedParticipants.insert(mInvitedParticipants.end(), uuids.begin(), uuids.end());
        }

        inviteToSession(uuids);
    }
}

void LLFloaterIMSession::addP2PSessionParticipants(const LLSD& notification, const LLSD& response, const uuid_vec_t& uuids)
{
    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
    if (option != 0)
    {
        return;
    }

    LLVoiceChannel* voice_channel = LLIMModel::getInstance()->getVoiceChannel(mSessionID);

    // first check whether this is a voice session
    bool is_voice_call = voice_channel != NULL && voice_channel->isActive();

    uuid_vec_t temp_ids;

    // Add the initial participant of a P2P session
    temp_ids.push_back(mOtherParticipantUUID);
    temp_ids.insert(temp_ids.end(), uuids.begin(), uuids.end());

    // then we can close the current session
    if(findInstance(mSessionID))
    {
        onClose(false);

        // remember whom we have invited, to notify others later, when the invited ones actually join
        mInvitedParticipants.insert(mInvitedParticipants.end(), uuids.begin(), uuids.end());
    }

    // we start a new session so reset the initialization flag
    mSessionInitialized = false;



    // Start a new ad hoc voice call if we invite new participants to a P2P call,
    // or start a text chat otherwise.
    if (is_voice_call)
    {
        LLAvatarActions::startAdhocCall(temp_ids, mSessionID);
    }
    else
    {
        LLAvatarActions::startConference(temp_ids, mSessionID);
    }
}

void LLFloaterIMSession::sendParticipantsAddedNotification(const uuid_vec_t& uuids)
{
    std::string names_string;
    LLAvatarActions::buildResidentsString(uuids, names_string);
    LLStringUtil::format_map_t args;
    args["[NAME]"] = names_string;

    sendMsg(getString(uuids.size() > 1 ? "multiple_participants_added" : "participant_added", args));
}

void LLFloaterIMSession::onVoiceChannelChanged(const LLUUID &session_id)
{
    if (session_id == mSessionID)
    {
        boundVoiceChannel();
    }
}

void LLFloaterIMSession::boundVoiceChannel()
{
    LLVoiceChannel* voice_channel = LLIMModel::getInstance()->getVoiceChannel(mSessionID);
    if(voice_channel)
    {
        mVoiceChannelStateChangeConnection.disconnect();
        mVoiceChannelStateChangeConnection = voice_channel->setStateChangedCallback(
                boost::bind(&LLFloaterIMSession::onVoiceChannelStateChanged, this, _1, _2));

        //call (either p2p, group or ad-hoc) can be already in started state
        bool callIsActive = voice_channel->getState() >= LLVoiceChannel::STATE_CALL_STARTED;
        updateCallBtnState(callIsActive);
    }
}

void LLFloaterIMSession::onChange(EStatusType status, const LLSD& channelInfo, bool proximal)
{
    if(status != STATUS_JOINING && status != STATUS_LEFT_CHANNEL)
    {
        enableDisableCallBtn();
    }
}

void LLFloaterIMSession::onVoiceChannelStateChanged(
        const LLVoiceChannel::EState& old_state, const LLVoiceChannel::EState& new_state)
{
    bool callIsActive = new_state >= LLVoiceChannel::STATE_CALL_STARTED;
    updateCallBtnState(callIsActive);
}

void LLFloaterIMSession::updateSessionName(const std::string& name)
{
    if (!name.empty())
    {
        LLFloaterIMSessionTab::updateSessionName(name);
        mTypingStart.setArg("[NAME]", name);
        setTitle (mOtherTyping ? mTypingStart.getString() : name);
        mSessionNameUpdatedForTyping = mOtherTyping;
    }
}

//static
LLFloaterIMSession* LLFloaterIMSession::show(const LLUUID& session_id)
{
    closeHiddenIMToasts();

    if (!gIMMgr->hasSession(session_id))
        return NULL;

    // Test the existence of the floater before we try to create it
    bool exist = findInstance(session_id);

    // Get the floater: this will create the instance if it didn't exist
    LLFloaterIMSession* floater = getInstance(session_id);
    if (!floater)
        return NULL;

    LLFloaterIMContainer* floater_container = LLFloaterIMContainer::getInstance();

    // Do not add again existing floaters
    if (!exist)
    {
        //      LLTabContainer::eInsertionPoint i_pt = user_initiated ? LLTabContainer::RIGHT_OF_CURRENT : LLTabContainer::END;
        // TODO: mantipov: use LLTabContainer::RIGHT_OF_CURRENT if it exists
        LLTabContainer::eInsertionPoint i_pt = LLTabContainer::END;
        if (floater_container)
        {
            floater_container->addFloater(floater, true, i_pt);
        }
    }

    floater->openFloater(floater->getKey());

    floater->setVisible(true);

    return floater;
}
//static
LLFloaterIMSession* LLFloaterIMSession::findInstance(const LLUUID& session_id)
{
    LLFloaterIMSession* conversation =
            LLFloaterReg::findTypedInstance<LLFloaterIMSession>("impanel", session_id);

    return conversation;
}

LLFloaterIMSession* LLFloaterIMSession::getInstance(const LLUUID& session_id)
{
    LLFloaterIMSession* conversation =
                LLFloaterReg::getTypedInstance<LLFloaterIMSession>("impanel", session_id);

    return conversation;
}

void LLFloaterIMSession::onClose(bool app_quitting)
{
    setTyping(false);

    // The source of much argument and design thrashing
    // Should the window hide or the session close when the X is clicked?
    //
    // Last change:
    // EXT-3516 X Button should end IM session, _ button should hide
    gIMMgr->leaveSession(mSessionID);
    mSession = nullptr; // leaveSession should have deleted it.
    // *TODO: Study why we need to restore the floater before we close it.
    // Might be because we want to save some state data in some clean open state.
    LLFloaterIMSessionTab::restoreFloater();
    // Clean up the conversation *after* the session has been ended
    LLFloaterIMSessionTab::onClose(app_quitting);
}

void LLFloaterIMSession::setDocked(bool docked, bool pop_on_undock)
{
    // update notification channel state
    LLNotificationsUI::LLScreenChannel* channel = static_cast<LLNotificationsUI::LLScreenChannel*>
        (LLNotificationsUI::LLChannelManager::getInstance()->
                                            findChannelByID(LLNotificationsUI::NOTIFICATION_CHANNEL_UUID));

    if(!isChatMultiTab())
    {
        LLTransientDockableFloater::setDocked(docked, pop_on_undock);
    }

    // update notification channel state
    if(channel)
    {
        channel->updateShowToastsState();
        channel->redrawToasts();
    }
}

void LLFloaterIMSession::setMinimized(bool b)
{
    bool wasMinimized = isMinimized();
    LLFloaterIMSessionTab::setMinimized(b);

    //Switching from minimized state to un-minimized state
    if(wasMinimized && !b)
    {
        //When in DND mode, remove stored IM notifications
        //Nearby chat (Null) IMs are not stored while in DND mode, so can ignore removal
        if(gAgent.isDoNotDisturb())
        {
            LLDoNotDisturbNotificationStorage::getInstance()->removeNotification(LLDoNotDisturbNotificationStorage::toastName, mSessionID);
        }
    }
}

void LLFloaterIMSession::setVisible(bool visible)
{
    LLNotificationsUI::LLScreenChannel* channel = static_cast<LLNotificationsUI::LLScreenChannel*>
        (LLNotificationsUI::LLChannelManager::getInstance()->
                                            findChannelByID(LLNotificationsUI::NOTIFICATION_CHANNEL_UUID));

    LLFloaterIMSessionTab::setVisible(visible);

    // update notification channel state
    if(channel)
    {
        channel->updateShowToastsState();
        channel->redrawToasts();
    }

    if(!visible)
    {
        LLChicletPanel * chiclet_panelp = LLChicletBar::getInstance()->getChicletPanel();
        if (NULL != chiclet_panelp)
        {
            LLIMChiclet * chicletp = chiclet_panelp->findChiclet<LLIMChiclet>(mSessionID);
            if(NULL != chicletp)
            {
                chicletp->setToggleState(false);
            }
        }
    }

    if (visible && isInVisibleChain())
    {
        sIMFloaterShowedSignal(mSessionID);
        updateMessages();
    }

}

bool LLFloaterIMSession::getVisible()
{
    bool visible;

    if(isChatMultiTab())
    {
        LLFloaterIMContainer* im_container =
                LLFloaterIMContainer::getInstance();

        // Treat inactive floater as invisible.
        bool is_active = im_container->getActiveFloater() == this;

        //torn off floater is always inactive
        if (!is_active && getHost() != im_container)
        {
            visible = LLTransientDockableFloater::getVisible();
        }
        else
        {
        // getVisible() returns true when Tabbed IM window is minimized.
            visible = is_active && !im_container->isMinimized()
                        && im_container->getVisible();
        }
    }
    else
    {
        visible = LLTransientDockableFloater::getVisible();
    }

    return visible;
}

void LLFloaterIMSession::setFocus(bool focus)
{
    LLFloaterIMSessionTab::setFocus(focus);

    //When in DND mode, remove stored IM notifications
    //Nearby chat (Null) IMs are not stored while in DND mode, so can ignore removal
    if(focus && gAgent.isDoNotDisturb())
    {
        LLDoNotDisturbNotificationStorage::getInstance()->removeNotification(LLDoNotDisturbNotificationStorage::toastName, mSessionID);
    }
}

//static
bool LLFloaterIMSession::toggle(const LLUUID& session_id)
{
    if(!isChatMultiTab())
    {
        LLFloaterIMSession* floater = LLFloaterReg::findTypedInstance<LLFloaterIMSession>(
                "impanel", session_id);
        if (floater && floater->getVisible() && floater->hasFocus())
        {
            // clicking on chiclet to close floater just hides it to maintain existing
            // scroll/text entry state
            floater->setVisible(false);
            return false;
        }
        else if(floater && ((!floater->isDocked() || floater->getVisible()) && !floater->hasFocus()))
        {
            floater->setVisible(true);
            floater->setFocus(true);
            return true;
        }
    }

    // ensure the list of messages is updated when floater is made visible
    show(session_id);
    return true;
}

void LLFloaterIMSession::sessionInitReplyReceived(const LLUUID& im_session_id)
{
    mSessionInitialized = true;

    //will be different only for an ad-hoc im session
    if (mSessionID != im_session_id)
    {
        initIMSession(im_session_id);
        buildConversationViewParticipant();
    }

    initIMFloater();
    LLFloaterIMSessionTab::updateGearBtn();
    //*TODO here we should remove "starting session..." warning message if we added it in postBuild() (IB)

    //need to send delayed messages collected while waiting for session initialization
    if (mQueuedMsgsForInit.size())
    {
        LLSD::array_iterator iter;
        for ( iter = mQueuedMsgsForInit.beginArray();
                    iter != mQueuedMsgsForInit.endArray(); ++iter)
        {
            LLIMModel::sendMessage(iter->asString(), mSessionID,
                mOtherParticipantUUID, mDialog);
        }

        mQueuedMsgsForInit.clear();
    }
}

void LLFloaterIMSession::updateMessages()
{
    std::list<LLSD> messages;

    // we shouldn't reset unread message counters if IM floater doesn't have focus
    LLIMModel::instance().getMessages(
            mSessionID, messages, mLastMessageIndex + 1, hasFocus());

    if (messages.size())
    {
        std::ostringstream message;
        std::list<LLSD>::const_reverse_iterator iter = messages.rbegin();
        std::list<LLSD>::const_reverse_iterator iter_end = messages.rend();
        for (; iter != iter_end; ++iter)
        {
            LLSD msg = *iter;

            std::string time = msg["time"].asString();
            LLUUID from_id = msg["from_id"].asUUID();
            std::string from = msg["from"].asString();
            std::string message = msg["message"].asString();
            bool is_history = msg["is_history"].asBoolean();
            bool is_region_msg = msg["is_region_msg"].asBoolean();

            LLChat chat;
            chat.mFromID = from_id;
            chat.mSessionID = mSessionID;
            chat.mFromName = from;
            chat.mTimeStr = time;
            chat.mChatStyle = is_history ? CHAT_STYLE_HISTORY : chat.mChatStyle;
            if (is_region_msg)
            {
                chat.mSourceType = CHAT_SOURCE_REGION;
            }

            // process offer notification
            if (msg.has("notification_id"))
            {
                chat.mNotifId = msg["notification_id"].asUUID();
                // if notification exists - embed it
                if (LLNotificationsUtil::find(chat.mNotifId) != NULL)
                {
                    // remove embedded notification from channel
                    LLNotificationsUI::LLScreenChannel* channel = static_cast<LLNotificationsUI::LLScreenChannel*>
                            (LLNotificationsUI::LLChannelManager::getInstance()->
                                                                findChannelByID(LLNotificationsUI::NOTIFICATION_CHANNEL_UUID));
                    if (getVisible())
                    {
                        // toast will be automatically closed since it is not storable toast
                        channel->hideToast(chat.mNotifId);
                    }
                }
                // if notification doesn't exist - try to use next message which should be log entry
                else
                {
                    continue;
                }
            }
            //process text message
            else
            {
                chat.mText = message;
            }

            // Add the message to the chat log
            appendMessage(chat);
            mLastMessageIndex = msg["index"].asInteger();

            // if it is a notification - next message is a notification history log, so skip it
            if (chat.mNotifId.notNull() && LLNotificationsUtil::find(chat.mNotifId) != NULL)
            {
                if (++iter == iter_end)
                {
                    break;
                }
                else
                {
                    mLastMessageIndex++;
                }
            }
        }
    }
}

void LLFloaterIMSession::reloadMessages(bool clean_messages/* = false*/)
{
    if (clean_messages)
    {
        LLIMModel::LLIMSession * sessionp = LLIMModel::instance().findIMSession(mSessionID);

        if (NULL != sessionp)
        {
            sessionp->loadHistory();
        }
    }

    mChatHistory->clear();
    mLastMessageIndex = -1;
    updateMessages();
    mInputEditor->setFont(LLViewerChat::getChatFont());
}

// static
void LLFloaterIMSession::onInputEditorFocusReceived( LLFocusableElement* caller, void* userdata )
{
    LLFloaterIMSession* self= (LLFloaterIMSession*) userdata;

    // Allow enabling the LLFloaterIMSession input editor only if session can accept text
    LLIMModel::LLIMSession* im_session =
        LLIMModel::instance().findIMSession(self->mSessionID);
    if( im_session && im_session->mTextIMPossible && !self->mInputEditor->getReadOnly())
    {
        //in disconnected state IM input editor should be disabled
        self->mInputEditor->setEnabled(!gDisconnected);
    }
}

// static
void LLFloaterIMSession::onInputEditorFocusLost(LLFocusableElement* caller, void* userdata)
{
    LLFloaterIMSession* self = (LLFloaterIMSession*) userdata;
    self->setTyping(false);
}

// static
void LLFloaterIMSession::onInputEditorKeystroke(LLTextEditor* caller, void* userdata)
{
    LLFloaterIMSession* self = (LLFloaterIMSession*)userdata;
    LLFloaterIMContainer* im_box = LLFloaterIMContainer::findInstance();
    if (im_box)
    {
        im_box->flashConversationItemWidget(self->mSessionID,false);
    }
    std::string text = self->mInputEditor->getText();

        // Deleting all text counts as stopping typing.
    self->setTyping(!text.empty());
}

void LLFloaterIMSession::setTyping(bool typing)
{
    if ( typing )
    {
        // Started or proceeded typing, reset the typing timeout timer
        mTypingTimeoutTimer.reset();
    }

    if ( mMeTyping != typing )
    {
        // Typing state is changed
        mMeTyping = typing;
        // So, should send current state
        mShouldSendTypingState = true;
        // In case typing is started, send state after some delay
        mTypingTimer.reset();
    }

    // Don't want to send typing indicators to multiple people, potentially too
    // much network traffic. Only send in person-to-person IMs.
    if ( mShouldSendTypingState && mDialog == IM_NOTHING_SPECIAL )
    {
        if ( mMeTyping )
        {
            if ( mTypingTimer.getElapsedTimeF32() > 1.f )
        {
                // Still typing, send 'start typing' notification
                LLIMModel::instance().sendTypingState(mSessionID, mOtherParticipantUUID, true);
                mShouldSendTypingState = false;
                mMeTypingTimer.reset();
            }
        }
        else
        {
            // Send 'stop typing' notification immediately
            LLIMModel::instance().sendTypingState(mSessionID, mOtherParticipantUUID, false);
                    mShouldSendTypingState = false;
        }
    }

    if (!mIsNearbyChat)
    {
        LLIMSpeakerMgr* speaker_mgr = LLIMModel::getInstance()->getSpeakerManager(mSessionID);
        if (speaker_mgr)
        {
            speaker_mgr->setSpeakerTyping(gAgent.getID(), false);
        }
    }
}

void LLFloaterIMSession::processIMTyping(const LLUUID& from_id, bool typing)
{
    LL_DEBUGS("TypingMsgs") << "typing=" << typing << LL_ENDL;
    if ( typing )
    {
        // other user started typing
        addTypingIndicator(from_id);
        mOtherTypingTimer.reset();
    }
    else
    {
        // other user stopped typing
        removeTypingIndicator(from_id);
    }
}

void LLFloaterIMSession::processAgentListUpdates(const LLSD& body)
{
    uuid_vec_t joined_uuids;

    if (body.isMap() && body.has("agent_updates") && body["agent_updates"].isMap())
    {
        LLSD::map_const_iterator update_it;
        for(update_it = body["agent_updates"].beginMap();
            update_it != body["agent_updates"].endMap();
            ++update_it)
        {
            LLUUID agent_id(update_it->first);
            LLSD agent_data = update_it->second;

            if (agent_data.isMap())
            {
                // store the new participants in joined_uuids
                if (agent_data.has("transition") && agent_data["transition"].asString() == "ENTER")
                {
                    joined_uuids.push_back(agent_id);
                }

                // process the moderator mutes
                if (agent_id == gAgentID && agent_data.has("info") && agent_data["info"].has("mutes"))
                {
                    bool moderator_muted_text = agent_data["info"]["mutes"]["text"].asBoolean();
                    mInputEditor->setEnabled(!moderator_muted_text);
                    std::string label;
                    if (moderator_muted_text)
                        label = LLTrans::getString("IM_muted_text_label");
                    else
                        label = LLTrans::getString("IM_to_label") + " " + LLIMModel::instance().getName(mSessionID);
                    mInputEditor->setLabel(label);

                    if (moderator_muted_text)
                        LLNotificationsUtil::add("TextChatIsMutedByModerator");
                }
            }
        }
    }

    // the vectors need to be sorted for computing the intersection and difference
    std::sort(mInvitedParticipants.begin(), mInvitedParticipants.end());
    std::sort(joined_uuids.begin(), joined_uuids.end());

    uuid_vec_t intersection; // uuids of invited residents who have joined the conversation
    std::set_intersection(mInvitedParticipants.begin(), mInvitedParticipants.end(),
                          joined_uuids.begin(), joined_uuids.end(),
                          std::back_inserter(intersection));

    if (intersection.size() > 0)
    {
        sendParticipantsAddedNotification(intersection);
    }

    // Remove all joined participants from invited array.
    // The difference between the two vectors (the elements in mInvitedParticipants which are not in joined_uuids)
    // is placed at the beginning of mInvitedParticipants, then all other elements are erased.
    mInvitedParticipants.erase(std::set_difference(mInvitedParticipants.begin(), mInvitedParticipants.end(),
                                                   joined_uuids.begin(), joined_uuids.end(),
                                                   mInvitedParticipants.begin()),
                               mInvitedParticipants.end());
}

void LLFloaterIMSession::processSessionUpdate(const LLSD& session_update)
{
    // *TODO : verify following code when moderated mode will be implemented
    if ( false && session_update.has("moderated_mode") &&
         session_update["moderated_mode"].has("voice") )
    {
        bool voice_moderated = session_update["moderated_mode"]["voice"];
        const std::string session_label = LLIMModel::instance().getName(mSessionID);

        if (voice_moderated)
        {
            setTitle(session_label + std::string(" ")
                            + LLTrans::getString("IM_moderated_chat_label"));
        }
        else
        {
            setTitle(session_label);
        }

        // *TODO : uncomment this when/if LLPanelActiveSpeakers panel will be added
        //update the speakers dropdown too
        //mSpeakerPanel->setVoiceModerationCtrlMode(voice_moderated);
    }
}

// virtual
void LLFloaterIMSession::draw()
{
    // add people who were added via dropPerson()
    if (!mPendingParticipants.empty())
    {
        addSessionParticipants(mPendingParticipants);
        mPendingParticipants.clear();
    }

    LLFloaterIMSessionTab::draw();
}

// virtual
bool LLFloaterIMSession::handleDragAndDrop(S32 x, S32 y, MASK mask, bool drop,
                                    EDragAndDropType cargo_type,
                                    void* cargo_data,
                                    EAcceptance* accept,
                           std::string& tooltip_msg)
{
    if (cargo_type == DAD_PERSON)
    {
        if (dropPerson(static_cast<LLUUID*>(cargo_data), drop))
        {
            *accept = ACCEPT_YES_MULTI;
        }
        else
        {
            *accept = ACCEPT_NO;
        }
    }
    else if (mDialog == IM_NOTHING_SPECIAL)
    {
        LLToolDragAndDrop::handleGiveDragAndDrop(mOtherParticipantUUID, mSessionID, drop,
                cargo_type, cargo_data, accept);
    }

    return true;
}

bool LLFloaterIMSession::dropPerson(LLUUID* person_id, bool drop)
{
    bool res = person_id && person_id->notNull();
    if(res)
    {
        uuid_vec_t ids;
        ids.push_back(*person_id);

        res = canAddSelectedToChat(ids);
        if(res && drop)
        {
            // these people will be added during the next draw() call
            // (so they can be added all at once)
            mPendingParticipants.push_back(*person_id);
        }
    }

    return res;
}

bool LLFloaterIMSession::isInviteAllowed() const
{
    return ( (IM_SESSION_CONFERENCE_START == mDialog)
             || (IM_SESSION_INVITE == mDialog && !gAgent.isInGroup(mSessionID))
             || mIsP2PChat);
}

bool LLFloaterIMSession::inviteToSession(const uuid_vec_t& ids)
{
    LLViewerRegion* region = gAgent.getRegion();
    bool is_region_exist = region != NULL;

    if (is_region_exist)
    {
        auto count = ids.size();

        if( isInviteAllowed() && (count > 0) )
        {
            LL_INFOS() << "LLFloaterIMSession::inviteToSession() - inviting participants" << LL_ENDL;

            std::string url = region->getCapability("ChatSessionRequest");

            LLSD data;
            data["params"] = LLSD::emptyArray();
            for (size_t i = 0; i < count; i++)
            {
                data["params"].append(ids[i]);
            }
            data["method"] = "invite";
            data["session-id"] = mSessionID;

            LLCoreHttpUtil::HttpCoroutineAdapter::messageHttpPost(url, data,
                "Session invite sent", "Session invite failed");
        }
        else
        {
            LL_INFOS() << "LLFloaterIMSession::inviteToSession -"
                    << " no need to invite agents for "
                    << mDialog << LL_ENDL;
            // successful add, because everyone that needed to get added
            // was added.
        }
    }

    return is_region_exist;
}

void LLFloaterIMSession::addTypingIndicator(const LLUUID& from_id)
{
/* Operation of "<name> is typing" state machine:
Not Typing state:

    User types in P2P IM chat ... Send Start Typing, save Started time,
    start Idle Timer (N seconds) go to Typing state

Typing State:

    User enters a non-return character: if Now - Started > ME_TYPING_TIMEOUT, send
    Start Typing, restart Idle Timer
    User enters a return character: stop Idle Timer, send IM and Stop
    Typing, go to Not Typing state
    Idle Timer expires: send Stop Typing, go to Not Typing state

The recipient has a complementary state machine in which a Start Typing
that is not followed by either an IM or another Start Typing within OTHER_TYPING_TIMEOUT
seconds switches the sender out of typing state.

This has the nice quality of being self-healing for lost start/stop
messages while adding messages only for the (relatively rare) case of a
user who types a very long message (one that takes more than ME_TYPING_TIMEOUT seconds
to type).

Note: OTHER_TYPING_TIMEOUT must be > ME_TYPING_TIMEOUT for proper operation of the state machine

*/

    // We may have lost a "stop-typing" packet, don't add it twice
    if (from_id.notNull() && !mOtherTyping)
    {
        mOtherTyping = true;
        mOtherTypingTimer.reset();
        // Save im_info so that removeTypingIndicator can be properly called because a timeout has occurred
        mImFromId = from_id;

        // Update speaker
        LLIMSpeakerMgr* speaker_mgr = LLIMModel::getInstance()->getSpeakerManager(mSessionID);
        if ( speaker_mgr )
        {
            speaker_mgr->setSpeakerTyping(from_id, true);
        }
    }
}

void LLFloaterIMSession::removeTypingIndicator(const LLUUID& from_id)
{
    if (mOtherTyping)
    {
        mOtherTyping = false;

        if (from_id.notNull())
        {
            // Update speaker
            LLIMSpeakerMgr* speaker_mgr = LLIMModel::getInstance()->getSpeakerManager(mSessionID);
            if (speaker_mgr)
            {
                speaker_mgr->setSpeakerTyping(from_id, false);
            }
        }
    }
}

// static
void LLFloaterIMSession::closeHiddenIMToasts()
{
    class IMToastMatcher: public LLNotificationsUI::LLScreenChannel::Matcher
    {
    public:
        bool matches(const LLNotificationPtr notification) const
        {
            // "notifytoast" type of notifications is reserved for IM notifications
            return "notifytoast" == notification->getType();
        }
    };

    LLNotificationsUI::LLScreenChannel* channel =
            LLNotificationsUI::LLChannelManager::getNotificationScreenChannel();
    if (channel != NULL)
    {
        channel->closeHiddenToasts(IMToastMatcher());
    }
}
// static
void LLFloaterIMSession::confirmLeaveCallCallback(const LLSD& notification, const LLSD& response)
{
    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
    const LLSD& payload = notification["payload"];
    LLUUID session_id = payload["session_id"];

    LLFloater* im_floater = findInstance(session_id);
    if (option == 0 && im_floater != NULL)
    {
        im_floater->closeFloater();
    }

    return;
}

// static
void LLFloaterIMSession::sRemoveTypingIndicator(const LLSD& data)
{
    LLUUID session_id = data["session_id"];
    if (session_id.isNull())
        return;

    LLUUID from_id = data["from_id"];
    if (gAgentID == from_id || LLUUID::null == from_id)
        return;

    LLFloaterIMSession* floater = LLFloaterIMSession::findInstance(session_id);
    if (!floater)
        return;

    if (IM_NOTHING_SPECIAL != floater->mDialog)
        return;

    floater->removeTypingIndicator();
}

// static
void LLFloaterIMSession::onIMChicletCreated( const LLUUID& session_id )
{
    LLFloaterIMSession::addToHost(session_id);
}

boost::signals2::connection LLFloaterIMSession::setIMFloaterShowedCallback(const floater_showed_signal_t::slot_type& cb)
{
    return LLFloaterIMSession::sIMFloaterShowedSignal.connect(cb);
}