public DeckNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_SlideRemovedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideRemoved));
this.m_SlideAddedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideAdded));
this.m_SlideContentAddedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideContentAdded));
this.m_DeckBackgroundColorChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleDeckBackgroundColorChanged));
this.m_SlideNetworkServices = new Hashtable();
this.m_TableOfContentsNetworkService = new TableOfContentsNetworkService(this.m_Sender, this.m_Presentation, this.m_Deck);
// Lock the deck so no content can be added between registering the event listeners and calling SendAllSlidesAndContent().
using( Synchronizer.Lock(this.m_Presentation.SyncRoot) ) {
using(Synchronizer.Lock(deck.SyncRoot)) {
this.m_Deck.SlideRemoved += this.m_SlideRemovedDispatcher.Dispatcher;
this.m_Deck.SlideAdded += this.m_SlideAddedDispatcher.Dispatcher;
this.m_Deck.SlideContentAdded += this.m_SlideContentAddedDispatcher.Dispatcher;
this.m_Deck.Changed["DeckBackgroundColor"].Add(this.m_DeckBackgroundColorChangedDispatcher.Dispatcher);
this.SendAllSlidesAndContent(Group.AllParticipant);
}
}
}
public SSDeckTraversalNetworkService(SendingQueue sender, PresentationModel presentation, DeckTraversalModel traversal)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_DeckTraversal = traversal;
this.m_SSDeckNetworkService = new SSDeckNetworkService(this.m_Sender, this.m_Presentation, this.m_DeckTraversal.Deck);
}
public TableOfContentsNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_EntriesCollectionHelper = new EntriesCollectionHelper(this);
}
public SSSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Selector = selector;
}
public TextSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, TextSheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
this.sheet_ = sheet;
this.sheet_.Changed["Text"].Add(new PropertyEventHandler(this.SendText));
this.sheet_.Changed["Color"].Add(new PropertyEventHandler(this.SendText));
this.sheet_.Changed["IsPublic"].Add(new PropertyEventHandler(this.SendPublic));
}
/// <summary>
/// Construct a StudentPresentationNetworkService
/// </summary>
/// <param name="sender">The event queue to use</param>
/// <param name="presentation">The PresentationModel to listen for changes to</param>
public StudentPresentationNetworkService( SendingQueue sender, PresentationModel presentation )
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_StudentQuickPollNetworkService = new StudentQuickPollNetworkService( this.m_Sender, this.m_Presentation );
this.m_StudentQuickPollChangedDispatcher = new EventQueue.PropertyEventDispatcher( this.m_Sender, new PropertyEventHandler( this.HandleStudentQuickPollChanged ) );
this.m_Presentation.Changed["QuickPoll"].Add( this.m_StudentQuickPollChangedDispatcher.Dispatcher );
}
public SSInkSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, InkSheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
this.m_Sheet = sheet;
this.m_Sheet.InkAdded += new StrokesEventHandler(this.HandleInkAdded);
this.m_Sheet.InkDeleting += new StrokesEventHandler(this.HandleInkDeleting);
this.SendExistingInk();
}
public DeckTraversalNetworkService(SendingQueue sender, PresentationModel presentation, DeckTraversalModel traversal)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_DeckTraversal = traversal;
this.m_DeckNetworkService = new DeckNetworkService(this.m_Sender, this.m_Presentation, this.m_DeckTraversal.Deck);
this.m_CurrentChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleCurrentChanged));
this.m_DeckTraversal.Changed["Current"].Add(this.m_CurrentChangedDispatcher.Dispatcher);
}
private void Send(SendingQueue queue)
{
if (SyncSend)
{
SendSync(queue);
}
else
{
SendAsync(queue);
}
}
/*
* protected virtual void HandleBoundsChanged(object sender, PropertyEventArgs args) {
* // Send a generic update with information about the sheet (including the new bounds).
* Message message, deck, slide, sheet;
* message = new PresentationInformationMessage(this.Presentation);
* message.InsertChild(deck = new DeckInformationMessage(this.Deck));
* deck.InsertChild(slide = new SlideInformationMessage(this.Slide));
* slide.InsertChild( sheet = SheetMessage.RemoteForSheet( this.Sheet, this.SheetCollectionSelector ) );
* using (Synchronizer.Lock(this.m_Slide.SyncRoot)) {
* message.Tags = new MessageTags();
* message.Tags.SlideID = this.m_Slide.Id;
* }
* this.Sender.Send(message);
* }
*/
#endregion
#region SheetWebService Factory
/// <summary>
/// Construct the appropriate sheet web service
/// </summary>
/// <param name="sender">The queue</param>
/// <param name="presentation">The presentation</param>
/// <param name="deck">The deck</param>
/// <param name="slide">The slide</param>
/// <param name="sheet">The sheet</param>
/// <param name="selector">The sheet collection type</param>
/// <returns>A sheet web service appropriate for the sheet model</returns>
public static SheetWebService ForSheet(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
if (sheet is InkSheetModel)
{
return(new InkSheetWebService(sender, presentation, deck, slide, sheet, selector));
}
else
{
return(new SheetWebService(sender, presentation, deck, slide, sheet, selector));
}
}
/// <summary>
/// Constructs a new QuickPollResultNetworkService
/// </summary>
/// <param name="sender">The message queue to use</param>
/// <param name="presentation">The PresentationModel to associate this service with</param>
/// <param name="poll">The QuickPollModel to associate this service with</param>
/// <param name="result">The QuickPollResultModel to associate this service with</param>
public QuickPollResultNetworkService( SendingQueue sender, PresentationModel presentation, QuickPollModel poll, QuickPollResultModel result )
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_QuickPoll = poll;
this.m_Result = result;
// Listen to changes tot he ResultString
this.m_ResultChangedDispatcher = new EventQueue.PropertyEventDispatcher( this.m_Sender, new PropertyEventHandler( this.HandleResultChanged ) );
this.m_Result.Changed["ResultString"].Add( this.m_ResultChangedDispatcher.Dispatcher );
}
public PresentationNetworkService(SendingQueue sender, PresentationModel presentation)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_DeckTraversalsCollectionHelper = new DeckTraversalsCollectionHelper(this);
this.m_QuickPollNetworkService = new QuickPollNetworkService( this.m_Sender, this.m_Presentation );
this.m_QuickPollChangedDispatcher = new EventQueue.PropertyEventDispatcher( this.m_Sender, new PropertyEventHandler( this.HandleQuickPollChanged ) );
this.m_Presentation.Changed["QuickPoll"].Add( this.m_QuickPollChangedDispatcher.Dispatcher );
}
private void RaiseSended(SendingQueue packet, bool result)
{
try
{
this.OnSended(packet, result);
//this.monitor.RaiseOnSendedEvent(this, packet, result);
}
catch (Exception exception)
{
Trace.Error(exception.Message, exception);
}
}
public PresentationNetworkService(SendingQueue sender, PresentationModel presentation)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_DeckTraversalsCollectionHelper = new DeckTraversalsCollectionHelper(this);
this.m_QuickPollNetworkService = new QuickPollNetworkService(this.m_Sender, this.m_Presentation);
this.m_QuickPollChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleQuickPollChanged));
this.m_Presentation.Changed["QuickPoll"].Add(this.m_QuickPollChangedDispatcher.Dispatcher);
}
public ParticipantNetworkService(SendingQueue sender, PresenterModel model, ParticipantModel participant)
{
this.m_Sender = sender;
this.m_Model = model;
this.m_Participant = participant;
this.m_RoleChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleRoleChanged));
this.m_Participant.Changed["Role"].Add(this.m_RoleChangedDispatcher.Dispatcher);
this.m_RoleChangedDispatcher.Dispatcher(this, null);
this.m_GroupCollectionHelper = new GroupCollectionHelper(this);
}
public SheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Selector = selector;
this.m_BoundsChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.Sender, new PropertyEventHandler(this.HandleBoundsChanged));
this.m_Sheet.Changed["Bounds"].Add(this.m_BoundsChangedDispatcher.Dispatcher);
}
public SSSlideNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_SubmissionStyleChangeDispatcher = new EventQueue.PropertyEventDispatcher( this.m_Sender, new PropertyEventHandler( this.HandleChange ) );
this.m_Slide.Changed["SubmissionStyle"].Add( this.m_SubmissionStyleChangeDispatcher.Dispatcher );
this.m_AnnotationSheetsCollectionHelper = new SSSheetsCollectionHelper(this, "AnnotationSheets", SheetMessage.SheetCollection.AnnotationSheets);
}
protected override void SendAsync(SendingQueue queue)
{
var e = m_SocketEventArgSend;
e.RemoteEndPoint = RemoteEndPoint;
e.UserToken = queue;
var item = queue[queue.Position];
e.SetBuffer(item.Array, item.Offset, item.Count);
if (!m_ServerSocket.SendToAsync(e))
OnSendingCompleted(this, e);
}
public SheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Selector = selector;
this.m_BoundsChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.Sender, new PropertyEventHandler(this.HandleBoundsChanged));
this.m_Sheet.Changed["Bounds"].Add(this.m_BoundsChangedDispatcher.Dispatcher);
}
protected override void SendAsync(SendingQueue queue)
{
var e = new SocketAsyncEventArgs();
e.Completed += new EventHandler<SocketAsyncEventArgs>(SendingCompleted);
e.RemoteEndPoint = RemoteEndPoint;
e.UserToken = queue;
var item = queue[queue.Position];
e.SetBuffer(item.Array, item.Offset, item.Count);
m_ServerSocket.SendToAsync(e);
}
public SSSlideNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_SubmissionStyleChangeDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleChange));
this.m_Slide.Changed["SubmissionStyle"].Add(this.m_SubmissionStyleChangeDispatcher.Dispatcher);
this.m_AnnotationSheetsCollectionHelper = new SSSheetsCollectionHelper(this, "AnnotationSheets", SheetMessage.SheetCollection.AnnotationSheets);
}
public ParticipantNetworkService(SendingQueue sender, PresenterModel model, ParticipantModel participant)
{
this.m_Sender = sender;
this.m_Model = model;
this.m_Participant = participant;
this.m_RoleChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleRoleChanged));
this.m_Participant.Changed["Role"].Add(this.m_RoleChangedDispatcher.Dispatcher);
this.m_RoleChangedDispatcher.Dispatcher(this, null);
this.m_GroupCollectionHelper = new GroupCollectionHelper(this);
}
/// <summary>
/// Constructs a new StudentQuickPollNetworkService
/// </summary>
/// <param name="sender">The message queue to post messages to</param>
/// <param name="presentation">The PresentationModel to create this class from</param>
/// <param name="poll">The QuickPollModel to create this class from</param>
public StudentQuickPollNetworkService( SendingQueue sender, PresentationModel presentation )
{
this.m_Sender = sender;
this.m_Presentation = presentation;
using( Synchronizer.Lock( this.m_Presentation.SyncRoot ) ) {
this.m_QuickPoll = this.m_Presentation.QuickPoll;
}
if( this.m_QuickPoll != null ) {
this.m_QuickPollResultCollectionHelper = new QuickPollResultCollectionHelper( this );
}
}
public QuickPollNetworkService(SendingQueue sender, PresentationModel presentation)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
using (Synchronizer.Lock(this.m_Presentation.SyncRoot)) {
this.m_QuickPoll = this.m_Presentation.QuickPoll;
}
if (this.m_QuickPoll != null)
{
this.m_QuickPollResultCollectionHelper = new QuickPollResultCollectionHelper(this);
}
}
protected override void SendAsync(SendingQueue queue)
{
try
{
var item = queue[queue.Position];
m_Stream.BeginWrite(item.Array, item.Offset, item.Count, OnEndWrite, queue);
}
catch (Exception e)
{
LogError(e);
OnSendError(queue, CloseReason.SocketError);
}
}
public SubmissionStatusNetworkService(SendingQueue sender, RoleModel role)
{
submission_status_model_ = SubmissionStatusModel.GetInstance();
if (role is StudentModel) {
submission_status_model_.Role = "student";
submission_status_model_.Changed["SubmissionStatus"].Add(new PropertyEventHandler(this.StudentSendStatus));
} else if(role is InstructorModel){
submission_status_model_.Role = "instructor";
submission_status_model_.Changed["Id"].Add(new PropertyEventHandler(this.InstructorSendStatus));
}
sender_ = sender;
}
protected override void SendAsync(SendingQueue queue)
{
var e = new SocketAsyncEventArgs();
e.Completed += new EventHandler <SocketAsyncEventArgs>(SendingCompleted);
e.RemoteEndPoint = RemoteEndPoint;
e.UserToken = queue;
var item = queue[queue.Position];
e.SetBuffer(item.Array, item.Offset, item.Count);
m_ServerSocket.SendToAsync(e);
}
public DefaultBeaconService(SendingQueue sender, PresenterModel model) : base(sender)
{
this.m_Sender = sender;
this.m_Model = model;
this.m_RoleChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender,
new PropertyEventHandler(this.HandleRoleChanged));
this.m_Model.Participant.Changed["Role"].Add(this.m_RoleChangedDispatcher.Dispatcher);
this.m_RoleChangedDispatcher.Dispatcher(this, null);
this.m_BeaconIntervalChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender,
new PropertyEventHandler(this.HandleBeaconIntervalChanged));
this.m_Model.ViewerState.Changed["BeaconInterval"].Add(this.m_BeaconIntervalChangedDispatcher.Dispatcher);
this.m_BeaconIntervalChangedDispatcher.Dispatcher(this, null);
}
public virtual void Initialize(IAppSession appSession)
{
AppSession = appSession;
DataProcessor = appSession.CreatePipelineProcessor();
Config = appSession.Config;
SyncSend = Config.SyncSend;
m_SendingQueuePool = ((SocketServerBase)((ISocketServerAccessor)appSession.AppServer).SocketServer).SendingQueuePool;
SendingQueue queue = m_SendingQueuePool.Get();
m_SendingQueue = queue;
queue.StartEnqueue();
}
/// <summary>
/// Construct the InkSheetWebService, this class listens for strokes to finish
/// and sends them across the network
/// </summary>
/// <param name="sender">The queue to use</param>
/// <param name="presentation">The presentation model</param>
/// <param name="deck">The deck model</param>
/// <param name="slide">The slide model</param>
/// <param name="sheet">The sheet model</param>
/// <param name="selector">The sheet collection we are part of</param>
public InkSheetWebService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
// Keep track of our sheet
this.m_Sheet = (InkSheetModel)sheet;
// Get the slide ID
using (Synchronizer.Lock(slide.SyncRoot)) {
m_SlideID = slide.Id;
}
// Set Events
this.m_Sheet.InkAdded += new StrokesEventHandler(this.HandleInkAdded);
// this.m_Sheet.InkDeleting += new StrokesEventHandler(this.HandleInkDeleting);
}
protected override void OnSendingCompleted(SendingQueue queue)
{
try
{
m_Stream.Flush();
}
catch (Exception e)
{
LogError(e);
OnSendError(queue, CloseReason.SocketError);
return;
}
base.OnSendingCompleted(queue);
}
private bool TrySend(IList <ArraySegment <byte> > datas, out bool reTry)
{
reTry = false;
SendingQueue mSendingQueue = this._readlySendingQueue;
if (mSendingQueue == null)
{
return(false);
}
if (!mSendingQueue.Enqueue(datas))
{
reTry = true;
return(false);
}
return(this.PreSend());
}
/// <summary>
/// Construct the service
/// </summary>
/// <param name="sender">The event queue</param>
/// <param name="presentation">The presentation</param>
/// <param name="deck">The deck</param>
/// <param name="slide">The slide</param>
public SlideWebService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_ChangeDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleChange));
this.m_Slide.Changed["Bounds"].Add(this.m_ChangeDispatcher.Dispatcher);
this.m_Slide.Changed["Zoom"].Add(this.m_ChangeDispatcher.Dispatcher);
this.m_Slide.Changed["BackgroundColor"].Add(this.m_ChangeDispatcher.Dispatcher);
this.m_Slide.Changed["BackgroundTemplate"].Add(this.m_ChangeDispatcher.Dispatcher);
this.m_ContentSheetsCollectionHelper = new SheetsCollectionHelper(this, "ContentSheets", SheetMessage.SheetCollection.ContentSheets);
this.m_AnnotationSheetsCollectionHelper = new SheetsCollectionHelper(this, "AnnotationSheets", SheetMessage.SheetCollection.AnnotationSheets);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sender">The sending queue to post messages to</param>
/// <param name="role">The InstructorModel to create this class for</param>
public InstructorWebService(SendingQueue sender, InstructorModel role)
{
this.m_Sender = sender;
this.m_Instructor = role;
// Handle basic changes
this.m_GenericChangeDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleGenericChange));
this.m_Instructor.Changed["ForcingStudentNavigationLock"].Add(this.m_GenericChangeDispatcher.Dispatcher);
this.m_Instructor.Changed["AcceptingStudentSubmissions"].Add(this.m_GenericChangeDispatcher.Dispatcher);
this.m_Instructor.Changed["AcceptingQuickPollSubmissions"].Add(this.m_GenericChangeDispatcher.Dispatcher);
// Handle changes to the current deck traversal
this.m_CurrentDeckTraversalChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleCurrentDeckTraversalChanged));
this.m_Instructor.Changed["CurrentDeckTraversal"].Add(this.m_CurrentDeckTraversalChangedDispatcher.Dispatcher);
this.m_CurrentDeckTraversalChangedDispatcher.Dispatcher(this, null);
}
/// <summary>
/// Constructor for the synchronization network service
/// </summary>
/// <param name="sender"></param>
/// <param name="model"></param>
/// <param name="diag"></param>
public SynchronizationNetworkService(SendingQueue sender, PresenterModel model)
{
this.Sender = sender;
this.m_Model = model;
this.m_Diagnostic = model.ViewerState.Diagnostic;
// Set up the change listeners
this.m_ServerChangeDispatcher = new EventQueue.PropertyEventDispatcher(this.Sender, new PropertyEventHandler(this.HandleServerStateChange));
this.m_Diagnostic.Changed["ServerState"].Add(this.m_ServerChangeDispatcher.Dispatcher);
this.m_ClientChangeDispatcher = new EventQueue.PropertyEventDispatcher(this.Sender, new PropertyEventHandler(this.HandleClientStateChange));
this.m_Diagnostic.Changed["ClientState"].Add(this.m_ClientChangeDispatcher.Dispatcher);
this.m_Timer = new System.Windows.Forms.Timer();
this.m_Timer.Interval = 5000;
this.m_Timer.Tick += new EventHandler(this.OnTimerTick);
}
protected override void SendAsync(SendingQueue queue)
{
var e = m_SocketEventArgSend;
e.RemoteEndPoint = RemoteEndPoint;
e.UserToken = queue;
var item = queue[queue.Position];
e.SetBuffer(item.Array, item.Offset, item.Count);
if (!m_ServerSocket.SendToAsync(e))
{
OnSendingCompleted(this, e);
}
}
/// <summary>
/// Build the network service
/// </summary>
/// <param name="sender">The message queue to use for these messages</param>
/// <param name="presentation">The presentation to listen to changes to</param>
public PresentationWebService(SendingQueue sender, PresentationModel presentation)
{
handler = new WebService.SSEventHandler(HandleStudentSubmission);
WebService.Instance.SubmissionReceived += handler;
qpHandler = new WebService.QPEventHandler(HandleQuickPollReceived);
WebService.Instance.QuickPollReceived += qpHandler;
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_DeckTraversalsCollectionHelper = new DeckTraversalsCollectionHelper(this);
// this.m_QuickPollWebService = new QuickPollWebService(this.m_Sender, this.m_Presentation);
this.m_QuickPollChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleQuickPollChanged));
this.m_Presentation.Changed["QuickPoll"].Add(this.m_QuickPollChangedDispatcher.Dispatcher);
}
public RealTimeInkSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, RealTimeInkSheetModel sheet, SheetMessage.SheetCollection selector) : base(sender, presentation, deck, slide, sheet, selector)
{
this.m_Sheet = sheet;
using (Synchronizer.Lock(slide.SyncRoot)) {
m_SlideID = slide.Id;
}
this.PacketBuffers = new Dictionary <int, List <int> >();
this.PacketFlushTimes = new Dictionary <int, long>();
this.m_CurrentDrawingAttributesChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.Sender, new PropertyEventHandler(this.HandleCurrentDrawingAttributesChanged));
this.m_Sheet.Changed["CurrentDrawingAttributes"].Add(this.m_CurrentDrawingAttributesChangedDispatcher.Dispatcher);
this.m_Sheet.StylusUp += new RealTimeInkSheetModel.StylusUpEventHandler(this.HandleStylusUp);
this.m_Sheet.Packets += new RealTimeInkSheetModel.PacketsEventHandler(this.HandlePackets);
this.m_Sheet.StylusDown += new RealTimeInkSheetModel.StylusDownEventHandler(this.HandleStylusDown);
}
public SubmissionStatusNetworkService(SendingQueue sender, RoleModel role)
{
submission_status_model_ = SubmissionStatusModel.GetInstance();
if (role is StudentModel)
{
submission_status_model_.Role = "student";
submission_status_model_.Changed["SubmissionStatus"].Add(new PropertyEventHandler(this.StudentSendStatus));
}
else if (role is InstructorModel)
{
submission_status_model_.Role = "instructor";
submission_status_model_.Changed["Id"].Add(new PropertyEventHandler(this.InstructorSendStatus));
}
sender_ = sender;
}
public static RoleNetworkService ForRole(SendingQueue sender, PresenterModel model, RoleModel role)
{
if (role is InstructorModel)
{
return(new InstructorNetworkService(sender, ((InstructorModel)role)));
}
else if (role is StudentModel)
{
return(new StudentNetworkService(sender, model, ((StudentModel)role)));
}
else
{
// Either the role type is unsupported, or it is a PublicModel
// which currently have no published properties which need to be broadcast.
return(null);
}
}
protected override void SendAsync(SendingQueue queue)
{
try
{
var item = queue[queue.Position];
m_Stream.BeginWrite(item.Array, item.Offset, item.Count, OnEndWrite, queue);
}
catch (Exception e)
{
if (!IsIgnorableException(e))
{
AppSession.Logger.Error(AppSession, e);
}
OnSendError(queue, CloseReason.SocketError);
}
}
public RealTimeInkSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, RealTimeInkSheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
this.m_Sheet = sheet;
using (Synchronizer.Lock(slide.SyncRoot)) {
m_SlideID = slide.Id;
}
this.PacketBuffers = new Dictionary<int, List<int>>();
this.PacketFlushTimes = new Dictionary<int, long>();
this.m_CurrentDrawingAttributesChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.Sender, new PropertyEventHandler(this.HandleCurrentDrawingAttributesChanged));
this.m_Sheet.Changed["CurrentDrawingAttributes"].Add(this.m_CurrentDrawingAttributesChangedDispatcher.Dispatcher);
this.m_Sheet.StylusUp += new RealTimeInkSheetModel.StylusUpEventHandler(this.HandleStylusUp);
this.m_Sheet.Packets += new RealTimeInkSheetModel.PacketsEventHandler(this.HandlePackets);
this.m_Sheet.StylusDown += new RealTimeInkSheetModel.StylusDownEventHandler(this.HandleStylusDown);
}
public InkSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, InkSheetModel sheet, SheetMessage.SheetCollection selector)
: base(sender, presentation, deck, slide, sheet, selector)
{
this.m_Sheet = sheet;
using (Synchronizer.Lock(slide.SyncRoot)) {
m_SlideID = slide.Id;
}
this.m_Sheet.InkAdded += new StrokesEventHandler(this.HandleInkAdded);
this.m_Sheet.InkDeleting += new StrokesEventHandler(this.HandleInkDeleting);
Group receivers = Group.AllParticipant;
if( (deck.Disposition & (DeckDisposition.StudentSubmission | DeckDisposition.QuickPoll)) != 0 ) {
receivers = Group.Submissions;
}
this.SendExistingInk(receivers);
}
protected override void SendSync(SendingQueue queue)
{
try
{
for (var i = 0; i < queue.Count; i++)
{
var item = queue[i];
m_Stream.Write(item.Array, item.Offset, item.Count);
}
OnSendingCompleted(queue);
}
catch (Exception e)
{
LogError(e);
OnSendError(queue, CloseReason.SocketError);
return;
}
}
/// <summary>
/// 异步发送消息
/// </summary>
/// <param name="sendQuere">发送消息体</param>
private void Send(SendingQueue sendQuere)
{
mutex.WaitOne();
if (m_sendPool.Count == 0)
{
SocketAsyncEventArgs saea_send = new SocketAsyncEventArgs();
saea_send.Completed += new EventHandler <SocketAsyncEventArgs>(IO_Completed);
m_sendPool.Push(saea_send);
}
SocketAsyncEventArgs socketArgs = m_sendPool.Pop();
mutex.ReleaseMutex();
socketArgs.RemoteEndPoint = sendQuere.remoteEndPoint;
socketArgs.SetBuffer(sendQuere.data, sendQuere.offset, sendQuere.length);
if (!listenSocket.SendToAsync(socketArgs))
{
ProcessSend(socketArgs);
}
}
protected override void OnSendingCompleted(SendingQueue queue)
{
try
{
m_Stream.Flush();
}
catch (Exception e)
{
if (!IsIgnorableException(e))
{
AppSession.Logger.Error(AppSession, e);
}
OnSendError(queue, CloseReason.SocketError);
return;
}
base.OnSendingCompleted(queue);
}
public InkSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, InkSheetModel sheet, SheetMessage.SheetCollection selector) : base(sender, presentation, deck, slide, sheet, selector)
{
this.m_Sheet = sheet;
using (Synchronizer.Lock(slide.SyncRoot)) {
m_SlideID = slide.Id;
}
this.m_Sheet.InkAdded += new StrokesEventHandler(this.HandleInkAdded);
this.m_Sheet.InkDeleting += new StrokesEventHandler(this.HandleInkDeleting);
Group receivers = Group.AllParticipant;
if ((deck.Disposition & (DeckDisposition.StudentSubmission | DeckDisposition.QuickPoll)) != 0)
{
receivers = Group.Submissions;
}
this.SendExistingInk(receivers);
}
public SSDeckNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_SlideRemovedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideRemoved));
this.m_SlideAddedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideAdded));
this.m_SlideNetworkServices = new Hashtable();
// Lock the deck so no content can be added between registering the event listeners and calling SendAllSlidesAndContent().
using( Synchronizer.Lock(this.m_Presentation.SyncRoot) ) {
using(Synchronizer.Lock(deck.SyncRoot)) {
this.m_Deck.SlideRemoved += this.m_SlideRemovedDispatcher.Dispatcher;
this.m_Deck.SlideAdded += this.m_SlideAddedDispatcher.Dispatcher;
this.AttachAllSlides();
}
}
}
public SSDeckNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_SlideRemovedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideRemoved));
this.m_SlideAddedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleSlideAdded));
this.m_SlideNetworkServices = new Hashtable();
// Lock the deck so no content can be added between registering the event listeners and calling SendAllSlidesAndContent().
using (Synchronizer.Lock(this.m_Presentation.SyncRoot)) {
using (Synchronizer.Lock(deck.SyncRoot)) {
this.m_Deck.SlideRemoved += this.m_SlideRemovedDispatcher.Dispatcher;
this.m_Deck.SlideAdded += this.m_SlideAddedDispatcher.Dispatcher;
this.AttachAllSlides();
}
}
}
protected override void SendAsync(SendingQueue queue)
{
try
{
m_SocketEventArgSend.UserToken = queue;
if (queue.Count > 1)
{
m_SocketEventArgSend.BufferList = queue;
}
else
{
var item = queue[0];
m_SocketEventArgSend.SetBuffer(item.Array, item.Offset, item.Count);
}
var client = Client;
if (client == null)
{
OnSendError(queue, CloseReason.SocketError);
return;
}
if (!client.SendAsync(m_SocketEventArgSend))
{
OnSendingCompleted(client, m_SocketEventArgSend);
}
}
catch (Exception e)
{
if (!IsIgnorableException(e))
{
AppSession.Logger.Error(AppSession, e);
}
ClearPrevSendState(m_SocketEventArgSend);
OnSendError(queue, CloseReason.SocketError);
}
}
protected override void SendSync(SendingQueue queue)
{
try
{
for (var i = 0; i < queue.Count; i++)
{
var item = queue[i];
m_Stream.Write(item.Array, item.Offset, item.Count);
}
}
catch (Exception e)
{
if (!IsIgnorableException(e))
AppSession.Logger.Error(AppSession, e);
Close(CloseReason.SocketError);
return;
}
OnSendingCompleted(queue);
}
protected override void SendAsync(SendingQueue queue)
{
try
{
var item = queue[queue.Position];
m_Stream.BeginWrite(item.Array, item.Offset, item.Count, OnEndWrite, queue);
}
catch (Exception e)
{
if (!IsIgnorableException(e))
AppSession.Logger.Error(AppSession, e);
Close(CloseReason.SocketError);
}
}
protected override void OnSendingCompleted(SendingQueue queue)
{
try
{
m_Stream.Flush();
}
catch (Exception e)
{
if (!IsIgnorableException(e))
AppSession.Logger.Error(AppSession, e);
Close(CloseReason.SocketError);
return;
}
base.OnSendingCompleted(queue);
}
protected override void SendSync(SendingQueue queue)
{
try
{
for (var i = 0; i < queue.Count; i++)
{
var item = queue[i];
m_Stream.Write(item.Array, item.Offset, item.Count);
}
OnSendingCompleted(queue);
}
catch (Exception e)
{
LogError(e);
OnSendError(queue, CloseReason.SocketError);
return;
}
}
protected override void SendAsync(SendingQueue queue)
{
try
{
var item = queue[queue.Position];
m_Stream.BeginWrite(item.Array, item.Offset, item.Count, OnEndWrite, queue);
}
catch (Exception e)
{
LogError(e);
OnSendError(queue, CloseReason.SocketError);
}
}
protected override void OnSendingCompleted(SendingQueue queue)
{
try
{
m_Stream.Flush();
}
catch (Exception e)
{
LogError(e);
OnSendError(queue, CloseReason.SocketError);
return;
}
base.OnSendingCompleted(queue);
}
public VersionExchangeNetworkService(SendingQueue sender)
{
m_Sender = sender;
m_VersionExchangeModel = PresenterModel.TheInstance.VersionExchange;
m_VersionExchangeCollectionHelper = new VersionExchangeCollectionHelper(this, PresenterModel.TheInstance.VersionExchange);
}
private void Send(SendingQueue queue)
{
if (SyncSend)
{
SendSync(queue);
}
else
{
SendAsync(queue);
}
}
private void StartSend(SendingQueue queue, int sendingTrackID, bool initial)
{
if (initial)
{
if (!TryAddStateFlag(SocketState.InSending))
{
return;
}
var currentQueue = m_SendingQueue;
if (currentQueue != queue || sendingTrackID != currentQueue.TrackID)
{
//Has been sent
OnSendEnd();
return;
}
}
Socket client;
if (IsInClosingOrClosed && TryValidateClosedBySocket(out client))
{
OnSendEnd(true);
return;
}
SendingQueue newQueue = m_SendingQueuePool.Get();
var oldQueue = Interlocked.CompareExchange(ref m_SendingQueue, newQueue, queue);
if (!ReferenceEquals(oldQueue, queue))
{
if (newQueue != null)
m_SendingQueuePool.Return(newQueue);
if (IsInClosingOrClosed)
{
OnSendEnd(true);
}
else
{
OnSendEnd(false);
AppSession.Logger.Error("Failed to switch the sending queue.");
this.Close(CloseReason.InternalError);
}
return;
}
//Start to allow enqueue
newQueue.StartEnqueue();
queue.StopEnqueue();
if (queue.Count == 0)
{
AppSession.Logger.Error("There is no data to be sent in the queue.");
m_SendingQueuePool.Return(queue);
OnSendEnd(false);
this.Close(CloseReason.InternalError);
return;
}
Send(queue);
}
public RTPSendConnection(IPEndPoint ipe)
{
this.m_Participant = new RtpParticipant(Guid.NewGuid().ToString(), "Classroom Playback");
this.m_Session = new RtpSession(ipe, this.m_Participant, true, false);
this.m_Sender = this.m_Session.CreateRtpSenderFec("Classroom Presenter", PayloadType.dynamicPresentation, null, 0, 100);
this.m_Queue = new SendingQueue(this);
}
