/**
* Finds Avaline callers which are not anymore among voice participants and calls mAvalineRemovedCallback.
*
* The problem is when Avaline caller ends a call it is removed from Voice Client session but
* still exists in LLSpeakerMgr. Server does not send such information.
* This method implements a HUCK to notify subscribers that watched Avaline callers by class
* are not anymore in the call.
*
* @see LLParticipantList::onAvalineCallerRemoved()
*/
void checkIfAvalineCallersExist(const uuid_set_t& participant_uuids)
{
uuid_set_t::iterator it = mAvalineCallers.begin();
uuid_set_t::const_iterator participants_it_end = participant_uuids.end();
while (it != mAvalineCallers.end())
{
const LLUUID participant_id = *it;
LL_DEBUGS("Avaline") << "Check avaline caller: " << participant_id << LL_ENDL;
bool not_found = participant_uuids.find(participant_id) == participants_it_end;
if (not_found)
{
LL_DEBUGS("Avaline") << "Watched Avaline caller is not found among voice participants: " << participant_id << LL_ENDL;
// notify Participant List
if (mAvalineRemovedCallback)
{
mAvalineRemovedCallback(participant_id);
}
// remove from the watch list
mAvalineCallers.erase(it++);
}
else
{
++it;
}
}
}
/**
* Performs "give inventory" operations for provided avatars.
*
* Sends one requests to give all selected inventory items for each passed avatar.
* Avatars are represent by two vectors: names and UUIDs which must be sychronized with each other.
*
* @param avatar_names - avatar names request to be sent.
* @param avatar_uuids - avatar names request to be sent.
*/
static void give_inventory(const std::vector<std::string>& avatar_names, const uuid_vec_t& avatar_uuids)
{
llassert(avatar_names.size() == avatar_uuids.size());
LLInventoryPanel* active_panel = LLInventoryPanel::getActiveInventoryPanel(FALSE);
if (!active_panel)
{
active_panel = get_outfit_editor_inventory_panel();
if (!active_panel) return;
}
const uuid_set_t inventory_selected_uuids = active_panel->getRootFolder()->getSelectionList();
if (inventory_selected_uuids.empty())
{
return;
}
std::string residents;
build_residents_string(avatar_names, residents);
std::string items;
build_items_string(inventory_selected_uuids, items);
LLSD substitutions;
substitutions["RESIDENTS"] = residents;
substitutions["ITEMS"] = items;
LLShareInfo::instance().mAvatarNames = avatar_names;
LLShareInfo::instance().mAvatarUuids = avatar_uuids;
LLNotificationsUtil::add("ShareItemsConfirmation", substitutions, LLSD(), &give_inventory_cb);
}
static void build_items_string(const uuid_set_t& inventory_selected_uuids , std::string& items_string)
{
llassert(inventory_selected_uuids.size() > 0);
const std::string& separator = LLTrans::getString("words_separator");
for (uuid_set_t::const_iterator it = inventory_selected_uuids.begin(); ; )
{
LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
if (NULL != inv_cat)
{
items_string = inv_cat->getName();
break;
}
LLViewerInventoryItem* inv_item = gInventory.getItem(*it);
if (NULL != inv_item)
{
items_string.append(inv_item->getName());
}
if(++it == inventory_selected_uuids.end())
{
break;
}
items_string.append(separator);
}
}
/**
* Finds Avaline callers among voice participants and calls mAvalineFoundCallback.
*
* When Avatar is in group call with Avaline caller and then ends call Avaline caller stays
* in Group Chat floater (exists in LLSpeakerMgr). If Avatar starts call with that group again
* Avaline caller is added to voice channel AFTER Avatar is connected to group call.
* But Voice Control Panel (VCP) is filled from session LLSpeakerMgr and there is no information
* if a speaker is Avaline caller.
*
* In this case this speaker is created as avatar and will be recreated when it appears in
* Avatar's Voice session.
*
* @see LLParticipantList::onAvalineCallerFound()
*/
void findAvalineCaller(const uuid_set_t& participant_uuids)
{
uuid_set_t::const_iterator it = participant_uuids.begin(), it_end = participant_uuids.end();
for(; it != it_end; ++it)
{
const LLUUID& participant_id = *it;
if (!LLVoiceClient::getInstance()->isParticipantAvatar(participant_id))
{
LL_DEBUGS("Avaline") << "Avaline caller found among voice participants: " << participant_id << LL_ENDL;
if (mAvalineFoundCallback)
{
mAvalineFoundCallback(participant_id);
}
}
}
}
/**
* Checks My Inventory visibility.
*/
static bool is_give_inventory_acceptable()
{
LLInventoryPanel* active_panel = LLInventoryPanel::getActiveInventoryPanel(FALSE);
if (!active_panel)
{
active_panel = get_outfit_editor_inventory_panel();
if (!active_panel) return false;
}
// check selection in the panel
const uuid_set_t inventory_selected_uuids = active_panel->getRootFolder()->getSelectionList();
if (inventory_selected_uuids.empty()) return false; // nothing selected
bool acceptable = false;
uuid_set_t::const_iterator it = inventory_selected_uuids.begin();
const uuid_set_t::const_iterator it_end = inventory_selected_uuids.end();
for (; it != it_end; ++it)
{
LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
// any category can be offered.
if (inv_cat)
{
acceptable = true;
continue;
}
LLViewerInventoryItem* inv_item = gInventory.getItem(*it);
// check if inventory item can be given
if (LLGiveInventory::isInventoryGiveAcceptable(inv_item))
{
acceptable = true;
continue;
}
// there are neither item nor category in inventory
acceptable = false;
break;
}
return acceptable;
}
static void give_inventory_cb(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
// if Cancel pressed
if (option == 1)
{
return;
}
LLInventoryPanel* active_panel = LLInventoryPanel::getActiveInventoryPanel(FALSE);
if (!active_panel)
{
active_panel = get_outfit_editor_inventory_panel();
if (!active_panel) return;
}
const uuid_set_t inventory_selected_uuids = active_panel->getRootFolder()->getSelectionList();
if (inventory_selected_uuids.empty())
{
return;
}
S32 count = LLShareInfo::instance().mAvatarNames.size();
bool shared = false;
// iterate through avatars
for(S32 i = 0; i < count; ++i)
{
const LLUUID& avatar_uuid = LLShareInfo::instance().mAvatarUuids[i];
// We souldn't open IM session, just calculate session ID for logging purpose. See EXT-6710
const LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, avatar_uuid);
uuid_set_t::const_iterator it = inventory_selected_uuids.begin();
const uuid_set_t::const_iterator it_end = inventory_selected_uuids.end();
const std::string& separator = LLTrans::getString("words_separator");
std::string noncopy_item_names;
LLSD noncopy_items = LLSD::emptyArray();
// iterate through selected inventory objects
for (; it != it_end; ++it)
{
LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
if (inv_cat)
{
LLGiveInventory::doGiveInventoryCategory(avatar_uuid, inv_cat, session_id);
shared = true;
break;
}
LLViewerInventoryItem* inv_item = gInventory.getItem(*it);
if (!inv_item->getPermissions().allowCopyBy(gAgentID))
{
if (!noncopy_item_names.empty())
{
noncopy_item_names.append(separator);
}
noncopy_item_names.append(inv_item->getName());
noncopy_items.append(*it);
}
else
{
LLGiveInventory::doGiveInventoryItem(avatar_uuid, inv_item, session_id);
shared = true;
}
}
if (noncopy_items.beginArray() != noncopy_items.endArray())
{
LLSD substitutions;
substitutions["ITEMS"] = noncopy_item_names;
LLSD payload;
payload["agent_id"] = avatar_uuid;
payload["items"] = noncopy_items;
LLNotificationsUtil::add("CannotCopyWarning", substitutions, payload,
&LLGiveInventory::handleCopyProtectedItem);
break;
}
}
if (shared)
{
LLFloaterReg::hideInstance("avatar_picker");
LLNotificationsUtil::add("ItemsShared");
}
}
