public EventHandler(IEventManager eventManager, ISourceManager sourceManager, ITextManager textManager,
ICallManager callManager, IVoiceService voiceService, IBlobManager blobManager, ITelephonyHandler telephonyHandler)
{
_eventManager = eventManager;
_sourceManager = sourceManager;
_textManager = textManager;
_callManager = callManager;
_voiceService = voiceService;
_blobManager = blobManager;
_telephonyHandler = telephonyHandler;
_textConverter = new TemplateToTextConverter();
_audioConverter = new AudioFileConverter();
}
public VoiceController(
IStoreContext storeContext,
ISettingService settingService,
INotificationService notificationService,
ILocalizationService localizationService,
ICustomerService customerService,
IVoiceService voiceService
) : base(
storeContext,
settingService,
notificationService,
localizationService,
customerService,
voiceService,
"Voice")
{
}
/// <summary>
/// Initializes a new instance of the <see cref="MainViewModel"/> class.
/// </summary>
/// <param name="analyticsService">The app's analytics service.</param>
/// <param name="cacheService">The app's cache service.</param>
/// <param name="settingsService">The app's settings service.</param>
/// <param name="channelsService">The app's channel service.</param>
/// <param name="discordService">The app's discord service.</param>
/// <param name="currentUserService">The app's current user service.</param>
/// <param name="gatewayService">The app's gateway service.</param>
/// <param name="presenceService">The app's presence service.</param>
/// <param name="guildsService">The app's guilds service.</param>
/// <param name="subFrameNavigationService">The app's subframe navigation service.</param>
/// <param name="friendsService">The app's friends service.</param>
/// <param name="dispatcherHelper">The app's dispatcher helper.</param>
/// <param name="voiceService">The app's voice service.</param>
/// <param name="clipboardService">The app's clipboard service.</param>
/// <remarks>Takes all service parameters from ViewModel Locator.</remarks>
public MainViewModel(
IAnalyticsService analyticsService,
ICacheService cacheService,
ISettingsService settingsService,
IChannelsService channelsService,
IDiscordService discordService,
ICurrentUserService currentUserService,
IGatewayService gatewayService,
IPresenceService presenceService,
IGuildsService guildsService,
ISubFrameNavigationService subFrameNavigationService,
IFriendsService friendsService,
IDispatcherHelper dispatcherHelper,
IVoiceService voiceService,
IClipboardService clipboardService)
{
_analyticsService = analyticsService;
_cacheService = cacheService;
_settingsService = settingsService;
_discordService = discordService;
_currentUserService = currentUserService;
_channelsService = channelsService;
_friendsService = friendsService;
_presenceService = presenceService;
_gatewayService = gatewayService;
_guildsService = guildsService;
_subFrameNavigationService = subFrameNavigationService;
_dispatcherHelper = dispatcherHelper;
_voiceService = voiceService;
_clipboardService = clipboardService;
RegisterGenericMessages();
RegisterChannelsMessages();
RegisterGuildsMessages();
RegisterMembersMessages();
RegisterMessagesMessages();
}
public VoiceController(IVoiceService voiceService)
{
_voiceService = voiceService;
}
public string ChatSessionRequest(IRegionClientCapsService caps, OSDMap req)
{
string method = req ["method"].AsString();
UUID sessionID = UUID.Parse(req ["session-id"].AsString());
switch (method)
{
case "start conference": {
if (SessionExists(sessionID))
{
return(""); // No duplicate sessions
}
// Create the session.
CreateSession(new ChatSession {
Members = new List <ChatSessionMember> (),
SessionID = sessionID,
Name = caps.ClientCaps.AccountInfo.Name + " Conference"
});
OSDArray parameters = (OSDArray)req ["params"];
// Add other invited members.
foreach (OSD param in parameters)
{
AddDefaultPermsMemberToSession(param.AsUUID(), sessionID);
}
// Add us to the session!
AddMemberToGroup(new ChatSessionMember {
AvatarKey = caps.AgentID,
CanVoiceChat = true,
IsModerator = true,
MuteText = false,
MuteVoice = false,
HasBeenAdded = true,
RequestedRemoval = false
}, sessionID);
//Inform us about our room
ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block =
new ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock {
AgentID = caps.AgentID,
CanVoiceChat = true,
IsModerator = true,
MuteText = false,
MuteVoice = false,
Transition = "ENTER"
};
m_eventQueueService.ChatterBoxSessionAgentListUpdates(sessionID, new [] { block }, caps.AgentID,
"ENTER", caps.RegionID);
ChatterBoxSessionStartReplyMessage cs = new ChatterBoxSessionStartReplyMessage {
VoiceEnabled = true,
TempSessionID = sessionID,
Type = 1,
Success = true,
SessionID = sessionID,
SessionName = caps.ClientCaps.AccountInfo.Name + " Conference",
ModeratedVoice = true
};
return(OSDParser.SerializeLLSDXmlString(cs.Serialize()));
}
case "accept invitation": {
// They would like added to the group conversation
var usAgents = new List <ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock> ();
var notUsAgents = new List <ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock> ();
ChatSession session = GetSession(sessionID);
if (session != null)
{
ChatSessionMember thismember = FindMember(caps.AgentID, sessionID);
if (thismember != null)
{
// Tell all the other members about the incoming member
foreach (ChatSessionMember sessionMember in session.Members)
{
ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block =
new ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock {
AgentID = sessionMember.AvatarKey,
CanVoiceChat = sessionMember.CanVoiceChat,
IsModerator = sessionMember.IsModerator,
MuteText = sessionMember.MuteText,
MuteVoice = sessionMember.MuteVoice,
Transition = "ENTER"
};
if (sessionMember.AvatarKey == thismember.AvatarKey)
{
usAgents.Add(block);
notUsAgents.Add(block);
}
else
{
if (sessionMember.HasBeenAdded)
{
// Don't add not joined yet agents. They don't want to be here.
notUsAgents.Add(block);
}
}
}
thismember.HasBeenAdded = true;
foreach (ChatSessionMember member in session.Members)
{
if (member.HasBeenAdded) //Only send to those in the group
{
UUID regionID = findRegionID(member.AvatarKey);
if (regionID != UUID.Zero)
{
m_eventQueueService.ChatterBoxSessionAgentListUpdates(
session.SessionID,
member.AvatarKey == thismember.AvatarKey ? notUsAgents.ToArray() : usAgents.ToArray(),
member.AvatarKey, "ENTER",
regionID);
}
}
}
return("Accepted");
}
}
return(""); // no session exists? ... or cannot find member
}
case "mute update": {
// Check if the user is a moderator
if (!CheckModeratorPermission(caps.AgentID, sessionID))
{
return("");
}
OSDMap parameters = (OSDMap)req ["params"];
UUID agentID = parameters ["agent_id"].AsUUID();
OSDMap muteInfoMap = (OSDMap)parameters ["mute_info"];
ChatSessionMember thismember = FindMember(agentID, sessionID);
if (thismember == null)
{
return("");
}
if (muteInfoMap.ContainsKey("text"))
{
thismember.MuteText = muteInfoMap ["text"].AsBoolean();
}
if (muteInfoMap.ContainsKey("voice"))
{
thismember.MuteVoice = muteInfoMap ["voice"].AsBoolean();
}
ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock block =
new ChatterBoxSessionAgentListUpdatesMessage.AgentUpdatesBlock {
AgentID = thismember.AvatarKey,
CanVoiceChat = thismember.CanVoiceChat,
IsModerator = thismember.IsModerator,
MuteText = thismember.MuteText,
MuteVoice = thismember.MuteVoice,
Transition = "ENTER"
};
ChatSession session = GetSession(sessionID);
// Send an update to all users so that they show the correct permissions
foreach (ChatSessionMember member in session.Members)
{
if (member.HasBeenAdded) //Only send to those in the group
{
UUID regionID = findRegionID(member.AvatarKey);
if (regionID != UUID.Zero)
{
m_eventQueueService.ChatterBoxSessionAgentListUpdates(
sessionID, new [] { block }, member.AvatarKey, "", regionID);
}
}
}
return("Accepted");
}
case "call": {
// Implement voice chat for conferences...
IVoiceService voiceService = m_registry.RequestModuleInterface <IVoiceService> ();
if (voiceService == null)
{
return("");
}
OSDMap resp = voiceService.GroupConferenceCallRequest(caps, sessionID);
return(OSDParser.SerializeLLSDXmlString(resp));
}
default:
MainConsole.Instance.Warn("ChatSessionRequest : " + method);
return("");
}
}
public void RegisterCaps(IRegionClientCapsService service)
{
m_service = service;
m_voiceModule = service.Registry.RequestModuleInterface<IVoiceService>();
if (m_voiceModule != null)
{
service.AddStreamHandler("ProvisionVoiceAccountRequest",
new GenericStreamHandler("POST",
service.CreateCAPS("ProvisionVoiceAccountRequest", ""),
ProvisionVoiceAccountRequest));
service.AddStreamHandler("ParcelVoiceInfoRequest",
new GenericStreamHandler("POST",
service.CreateCAPS("ParcelVoiceInfoRequest", ""),
ParcelVoiceInfoRequest));
}
}
public void CallDoSomeThingElse(IVoiceService t, int a, float b)
{
t.DoSomeThingElse(a, b);
}
public VoiceController(IHostingEnvironment env,
IVoiceService voiceService)
{
_voiceService = voiceService;
_env = env;
}
