private static void VideoChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
if (e.NewState != ChannelState.Receive)
{
return;
}
var vc = (VideoChannel)sender;
if (vc.CanInvoke(ChannelAction.Start))
{
vc.StartAsync().ContinueWith(t =>
{
// Go looking around for the IM Window (there had better just be the one we just started)
// and force it to the foreground
IntPtr childHandle = UnsafeNativeMethods.FindWindowEx(IntPtr.Zero, IntPtr.Zero, "IMWindowClass", null);
UnsafeNativeMethods.SetForegroundWindow(childHandle);
// Try to get the video to go full screen by pressing F5
WindowsInput.InputSimulator.SimulateKeyPress(WindowsInput.VirtualKeyCode.F5);
});
}
else
{
Debug.WriteLine("CanInvoke said NO!");
}
}
//*****************************************************************************************
// AudioChannel event handling
//*****************************************************************************************
/// <summary>
/// Updates the status bar when the new Audio Channel state.
/// </summary>
void audioChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
//posts the execution into the UI thread
this.BeginInvoke(new MethodInvoker(delegate()
{
//updates the status bar with the video channel state
toolStripStatusLabelAudioChannel.Text = e.NewState.ToString();
}));
}
private void OnAudioChannelStateChanged(object sender, ChannelStateChangedEventArgs e)
{
_log.Debug("OnAudioChannelStateChanged NewState:{0}", e.NewState.ToString());
////posts the execution into the UI thread
//this.BeginInvoke(new MethodInvoker(delegate ()
//{
// //updates the status bar with the video channel state
// toolStripStatusLabelAudioChannel.Text = e.NewState.ToString();
//}));
if (e.NewState == ChannelState.Inactive)
{
}
}
private void OnVideoChannelStateChanged(object sender, ChannelStateChangedEventArgs e)
{
//posts the execution into the UI thread
RunAtUI(() =>
{
//*****************************************************************************************
// Video Content
//
// The video content is only available when the Lync client is running in UISuppressionMode.
//
// The video content is not directly accessible as a stream. It's rather available through
// a video window that can de drawn in any panel or window.
//
// The outgoing video is accessible from videoChannel.CaptureVideoWindow
// The window will be available when the video channel state is either Send or SendReceive.
//
// The incoming video is accessible from videoChannel.RenderVideoWindow
// The window will be available when the video channel state is either Receive or SendReceive.
//
//*****************************************************************************************
_log.Debug("OnVideoChannelStateChanged OldState:{0} NewState:{1} channel:{2} channelCode:{3}"
, e.OldState.ToString()
, e.NewState.ToString()
, sender.ToString()
, sender.GetHashCode()
);
//if the outgoing video is now active, show the video (which is only available in UI Suppression Mode)
if ((e.NewState == ChannelState.Send ||
e.NewState == ChannelState.SendReceive) && _videoChannel.CaptureVideoWindow != null)
{
LocalParticipantVideoModel.View = _videoChannel.CaptureVideoWindow;
ShowVideoPartView?.Invoke();
//presents the video in the panel
// ShowVideo(panelOutgoingVideo, _videoChannel.CaptureVideoWindow);
}
//if the incoming video is now active, show the video (which is only available in UI Suppression Mode)
if ((e.NewState == ChannelState.Receive ||
e.NewState == ChannelState.SendReceive) && _videoChannel.RenderVideoWindow != null)
{
//presents the video in the panel
// SetParticipantVideoWindow(_videoChannel, _videoChannel.RenderVideoWindow);
}
});
}
private void OnParticipantVideoChannelStateChanged(object sender, ChannelStateChangedEventArgs e)
{
//posts the execution into the UI thread
RunAtUI(() =>
{
_log.Debug("OnParticipantVideoChannelStateChanged OldState:{0} NewState:{1} Channel:{2} ChannelCode:{3}"
, e.OldState.ToString()
, e.NewState.ToString()
, sender.ToString()
, sender.GetHashCode()
);
var channel = sender as VideoChannel;
//if the outgoing video is now active, show the video (which is only available in UI Suppression Mode)
if ((e.NewState == ChannelState.Send ||
e.NewState == ChannelState.SendReceive) && _videoChannel.CaptureVideoWindow != null)
{
ParticipantCollection.UpdateVideoWindow(channel, _videoChannel.CaptureVideoWindow, true);
//SetParticipantVideoWindow(channel, _videoChannel.CaptureVideoWindow);
}
if (e.NewState == ChannelState.Receive && _videoChannel.RenderVideoWindow != null)
{
if (RemoteConnectParticipantVideoModel != null)
{
RemoteConnectParticipantVideoModel.View = null;
}
RemoteConnectParticipantVideoModel = null;
}
//if the incoming video is now active, show the video (which is only available in UI Suppression Mode)
if (
e.NewState == ChannelState.SendReceive && _videoChannel.RenderVideoWindow != null)
{
ParticipantCollection.UpdateVideoWindow(channel, _videoChannel.RenderVideoWindow, false);
ShowVideoPartView?.Invoke();
SetParticipantVideoWindow(channel, _videoChannel.RenderVideoWindow);
}
});
}
/// <summary>
/// Called when the video state changes.
///
/// Will show Incoming/Outgoing video based on the channel state.
/// </summary>
void videoChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
//posts the execution into the UI thread
this.BeginInvoke(new MethodInvoker(delegate()
{
//updates the status bar with the video channel state
toolStripStatusLabelVideoChannel.Text = e.NewState.ToString();
//*****************************************************************************************
// Video Content
//
// The video content is only available when the Lync client is running in UISuppressionMode.
//
// The video content is not directly accessible as a stream. It's rather available through
// a video window that can de drawn in any panel or window.
//
// The outgoing video is accessible from videoChannel.CaptureVideoWindow
// The window will be available when the video channel state is either Send or SendReceive.
//
// The incoming video is accessible from videoChannel.RenderVideoWindow
// The window will be available when the video channel state is either Receive or SendReceive.
//
//*****************************************************************************************
//if the outgoing video is now active, show the video (which is only available in UI Suppression Mode)
if ((e.NewState == ChannelState.Send ||
e.NewState == ChannelState.SendReceive) && videoChannel.CaptureVideoWindow != null)
{
//presents the video in the panel
ShowVideo(panelOutgoingVideo, videoChannel.CaptureVideoWindow);
}
//if the incoming video is now active, show the video (which is only available in UI Suppression Mode)
if ((e.NewState == ChannelState.Receive ||
e.NewState == ChannelState.SendReceive) && videoChannel.RenderVideoWindow != null)
{
//presents the video in the panel
ShowVideo(panelIncomingVideo, videoChannel.RenderVideoWindow);
}
}));
}
/// <summary>
/// Called when the video state changes.
///
/// Will show Incoming/Outgoing video based on the channel state.
/// </summary>
void videoChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
//posts the execution into the UI thread
CommunicationManager.UiThreadControl.BeginInvoke(new MethodInvoker(delegate()
{
//*****************************************************************************************
// Video Content
//
// The video content is only available when the Lync client is running in UISuppressionMode.
//
// The video content is not directly accessible as a stream. It's rather available through
// a video window that can de drawn in any panel or window.
//
// The incoming video is accessible from videoChannel.RenderVideoWindow
// The window will be available when the video channel state is either Receive or SendReceive.
//
//*****************************************************************************************
//TODO: Temprary to see my own window
//if the outgoing video is now active, show the video (which is only available in UI Suppression Mode)
if ((e.NewState == ChannelState.Send ||
e.NewState == ChannelState.SendReceive) && videoChannel.CaptureVideoWindow != null)
{
if (this.VideoCallStarted != null)
{
this.VideoCallStarted(null);
}
//presents the video in the panel
ShowVideo(parentHandle, bounds, videoChannel.CaptureVideoWindow);
}
// switch to see incoming
////if the incoming video is now active, show the video (which is only available in UI Suppression Mode)
//if ((e.NewState == ChannelState.Receive
// || e.NewState == ChannelState.SendReceive) && videoChannel.RenderVideoWindow != null)
//{
// //presents the video in the panel
// ShowVideo(parentHandle, bounds, videoChannel.CaptureVideoWindow);
//}
}));
}
private static void VideoChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
System.Diagnostics.Debug.WriteLine(string.Format("Video Channel state change from {0} to {1}", e.OldState, e.NewState));
var videoChannel = (VideoChannel)sender;
if (_incomingChannelStates.Contains(e.NewState) && !_incomingChannelStates.Contains(e.OldState)) // Incoming newly available
{
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
else if (!_incomingChannelStates.Contains(e.NewState) && _incomingChannelStates.Contains(e.OldState)) // Incoming newly unavailable
{
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
if (e.NewState == ChannelState.Send)
{
// If outgoing is newly available, then raise the Available event
if (!_outgoingChannelStates.Contains(e.OldState))
{
RaiseVideoAvailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
}
// If incoming was previously available, then raise the Unavailable event
if (_incomingVideoStreamStarted && _incomingChannelStates.Contains(e.OldState))
{
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
}
else if (e.NewState == ChannelState.Receive)
{
// If outgoing was previously available, then raise the Unavailable event
if (_outgoingChannelStates.Contains(e.OldState))
{
RaiseVideoUnavailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
}
// If incoming is newly available, then raise the Available event
if (_incomingVideoStreamStarted && !_incomingChannelStates.Contains(e.OldState))
{
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
}
else if (e.NewState == ChannelState.SendReceive)
{
// If outgoing is newly available, then raise the Available event
if (!_outgoingChannelStates.Contains(e.OldState))
{
RaiseVideoAvailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
}
// If incoming is newly available, then raise the Available event
if (_incomingVideoStreamStarted && !_incomingChannelStates.Contains(e.OldState))
{
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
}
else
{
// If outgoing was previously available, then raise the Unavailable event
if (_outgoingChannelStates.Contains(e.OldState))
{
RaiseVideoUnavailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
}
// If incoming was previously available, then raise the Unavailable event
if (_incomingVideoStreamStarted && _incomingChannelStates.Contains(e.OldState))
{
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
}
}
static void VideoChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
var videoChannel = (VideoChannel)sender;
if (_incomingChannelStates.Contains(e.NewState) && !_incomingChannelStates.Contains(e.OldState)) // Incoming newly available
{
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
else if (!_incomingChannelStates.Contains(e.NewState) && _incomingChannelStates.Contains(e.OldState)) // Incoming newly unavailable
{
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
if (e.NewState == ChannelState.Send)
{
// If outgoing is newly available, then raise the Available event
if (!_outgoingChannelStates.Contains(e.OldState))
{
RaiseVideoAvailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
}
// If incoming was previously available, then raise the Unavailable event
if (_incomingVideoStreamStarted && _incomingChannelStates.Contains(e.OldState))
{
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
}
else if (e.NewState == ChannelState.Receive)
{
// If outgoing was previously available, then raise the Unavailable event
if (_outgoingChannelStates.Contains(e.OldState))
{
RaiseVideoUnavailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
}
// If incoming is newly available, then raise the Available event
if (_incomingVideoStreamStarted && !_incomingChannelStates.Contains(e.OldState))
{
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
}
else if (e.NewState == ChannelState.SendReceive)
{
// If outgoing is newly available, then raise the Available event
if (!_outgoingChannelStates.Contains(e.OldState))
{
RaiseVideoAvailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
}
// If incoming is newly available, then raise the Available event
if (_incomingVideoStreamStarted && !_incomingChannelStates.Contains(e.OldState))
{
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
}
else
{
// If outgoing was previously available, then raise the Unavailable event
if (_outgoingChannelStates.Contains(e.OldState))
{
RaiseVideoUnavailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
}
// If incoming was previously available, then raise the Unavailable event
if (_incomingVideoStreamStarted && _incomingChannelStates.Contains(e.OldState))
{
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
}
}
private void VideoChannelStateChanged(object sender, ChannelStateChangedEventArgs e)
{
this.SetVideoStatus(e.NewState.ToString());
//*****************************************************************************************
// Video Content
//
// The video content is only available when the Lync client is running in UISuppressionMode.
//
// The video content is not directly accessible as a stream. It's rather available through
// a video window that can de drawn in any panel or window.
//
// The outgoing video is accessible from videoChannel.CaptureVideoWindow
// The window will be available when the video channel state is either Send or SendReceive.
//
// The incoming video is accessible from videoChannel.RenderVideoWindow
// The window will be available when the video channel state is either Receive or SendReceive.
//
//*****************************************************************************************
// TODO: this one is working only if the app is located somewhere in user's directory due to some Windows user permissions.
////if the outgoing video is now active, show the video (which is only available in UI Suppression Mode)
//if ((e.NewState == ChannelState.Send || e.NewState == ChannelState.SendReceive) &&
// videoChannel.CaptureVideoWindow != null)
//{
// //presents the video in the panel
// //ShowVideo(this.outVideo, videoChannel.CaptureVideoWindow);
// ShowVideo(this.outVideo, videoChannel.CaptureVideoWindow);
//}
//if the incoming video is now active, show the video (which is only available in UI Suppression Mode)
if ((e.NewState == ChannelState.Receive || e.NewState == ChannelState.SendReceive) &&
videoChannel.RenderVideoWindow != null)
{
//presents the video in the panel
//ShowVideo(this.inVideo, videoChannel.RenderVideoWindow);
ShowVideo(this.inVideo, videoChannel.RenderVideoWindow);
}
}
private void AudioChannelStateChanged(object sender, ChannelStateChangedEventArgs e)
{
this.SetAudioStatus(e.NewState.ToString());
}
private static void VideoChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
if (e.NewState != ChannelState.Receive)
{
return;
}
var vc = (VideoChannel)sender;
if (vc.CanInvoke(ChannelAction.Start))
{
vc.StartAsync().ContinueWith(t =>
{
// Go looking around for the IM Window (there had better just be the one we just started)
// and force it to the foreground
IntPtr childHandle = UnsafeNativeMethods.FindWindowEx(IntPtr.Zero, IntPtr.Zero, "IMWindowClass", null);
UnsafeNativeMethods.SetForegroundWindow(childHandle);
// Try to get the video to go full screen by pressing F5
WindowsInput.InputSimulator.SimulateKeyPress(WindowsInput.VirtualKeyCode.F5);
});
}
else
{
Debug.WriteLine("CanInvoke said NO!");
}
}
static void VideoChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
var videoChannel = (VideoChannel)sender;
if (_incomingChannelStates.Contains(e.NewState) && !_incomingChannelStates.Contains(e.OldState)) // Incoming newly available
{
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
else if (!_incomingChannelStates.Contains(e.NewState) && _incomingChannelStates.Contains(e.OldState)) // Incoming newly unavailable
{
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
if (e.NewState == ChannelState.Send)
{
// If outgoing is newly available, then raise the Available event
if (!_outgoingChannelStates.Contains(e.OldState))
RaiseVideoAvailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
// If incoming was previously available, then raise the Unavailable event
if (_incomingVideoStreamStarted && _incomingChannelStates.Contains(e.OldState))
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
else if (e.NewState == ChannelState.Receive)
{
// If outgoing was previously available, then raise the Unavailable event
if (_outgoingChannelStates.Contains(e.OldState))
RaiseVideoUnavailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
// If incoming is newly available, then raise the Available event
if (_incomingVideoStreamStarted && !_incomingChannelStates.Contains(e.OldState))
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
else if (e.NewState == ChannelState.SendReceive)
{
// If outgoing is newly available, then raise the Available event
if (!_outgoingChannelStates.Contains(e.OldState))
RaiseVideoAvailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
// If incoming is newly available, then raise the Available event
if (_incomingVideoStreamStarted && !_incomingChannelStates.Contains(e.OldState))
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
else
{
// If outgoing was previously available, then raise the Unavailable event
if (_outgoingChannelStates.Contains(e.OldState))
RaiseVideoUnavailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
// If incoming was previously available, then raise the Unavailable event
if (_incomingVideoStreamStarted && _incomingChannelStates.Contains(e.OldState))
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
}
/// <summary>
/// Called when the video state changes.
///
/// Will show Incoming/Outgoing video based on the channel state.
/// </summary>
void videoChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
//posts the execution into the UI thread
CommunicationManager.UiThreadControl.BeginInvoke(new MethodInvoker(delegate()
{
//*****************************************************************************************
// Video Content
//
// The video content is only available when the Lync client is running in UISuppressionMode.
//
// The video content is not directly accessible as a stream. It's rather available through
// a video window that can de drawn in any panel or window.
//
// The incoming video is accessible from videoChannel.RenderVideoWindow
// The window will be available when the video channel state is either Receive or SendReceive.
//
//*****************************************************************************************
//TODO: Temprary to see my own window
//if the outgoing video is now active, show the video (which is only available in UI Suppression Mode)
if ((e.NewState == ChannelState.Send
|| e.NewState == ChannelState.SendReceive) && videoChannel.CaptureVideoWindow != null)
{
if (this.VideoCallStarted != null)
this.VideoCallStarted(null);
//presents the video in the panel
ShowVideo(parentHandle, bounds, videoChannel.CaptureVideoWindow);
}
// switch to see incoming
////if the incoming video is now active, show the video (which is only available in UI Suppression Mode)
//if ((e.NewState == ChannelState.Receive
// || e.NewState == ChannelState.SendReceive) && videoChannel.RenderVideoWindow != null)
//{
// //presents the video in the panel
// ShowVideo(parentHandle, bounds, videoChannel.CaptureVideoWindow);
//}
}));
}
private void channel_ChannelStateChanged(object sender, ChannelStateChangedEventArgs e)
{
outputBox.Items.Add(string.Format("Channel: {0}", e.NewState));
}
private static void VideoChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
System.Diagnostics.Debug.WriteLine(string.Format("Video Channel state change from {0} to {1}", e.OldState, e.NewState));
var videoChannel = (VideoChannel)sender;
if (_incomingChannelStates.Contains(e.NewState) && !_incomingChannelStates.Contains(e.OldState)) // Incoming newly available
{
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
else if (!_incomingChannelStates.Contains(e.NewState) && _incomingChannelStates.Contains(e.OldState)) // Incoming newly unavailable
{
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
if (e.NewState == ChannelState.Send)
{
// If outgoing is newly available, then raise the Available event
if (!_outgoingChannelStates.Contains(e.OldState))
RaiseVideoAvailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
// If incoming was previously available, then raise the Unavailable event
if (_incomingVideoStreamStarted && _incomingChannelStates.Contains(e.OldState))
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
else if (e.NewState == ChannelState.Receive)
{
// If outgoing was previously available, then raise the Unavailable event
if (_outgoingChannelStates.Contains(e.OldState))
RaiseVideoUnavailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
// If incoming is newly available, then raise the Available event
if (_incomingVideoStreamStarted && !_incomingChannelStates.Contains(e.OldState))
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
else if (e.NewState == ChannelState.SendReceive)
{
// If outgoing is newly available, then raise the Available event
if (!_outgoingChannelStates.Contains(e.OldState))
RaiseVideoAvailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
// If incoming is newly available, then raise the Available event
if (_incomingVideoStreamStarted && !_incomingChannelStates.Contains(e.OldState))
RaiseVideoAvailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
else
{
// If outgoing was previously available, then raise the Unavailable event
if (_outgoingChannelStates.Contains(e.OldState))
RaiseVideoUnavailable(videoChannel.CaptureVideoWindow, VideoDirection.Outgoing);
// If incoming was previously available, then raise the Unavailable event
if (_incomingVideoStreamStarted && _incomingChannelStates.Contains(e.OldState))
RaiseVideoUnavailable(videoChannel.RenderVideoWindow, VideoDirection.Incoming);
}
}
static void VideoChannel_StateChanged(object sender, ChannelStateChangedEventArgs e)
{
VideoChannel vc = (VideoChannel)sender;
//Are we receiving? Let's try to send!
if (e.NewState == ChannelState.Receive)
{
if (vc.CanInvoke(ChannelAction.Start))
{
vc.BeginStart(videoCallBack, vc);
}
else { Debug.WriteLine("CanInvoke said NO!"); }
//Go looking around for the IM Window (there had better just be the one we just started)
// and force it to the foreground
IntPtr childHandle = UnsafeNativeMethods.FindWindowEx(IntPtr.Zero, IntPtr.Zero, "IMWindowClass", null);
UnsafeNativeMethods.SetForegroundWindow(childHandle);
//Try to get the video to go full screen by pressing F5
WindowsInput.InputSimulator.SimulateKeyPress(WindowsInput.VirtualKeyCode.F5);
}
}
