public static Camera CreateCamera()
{
Camera camera = new Camera();
camera.Id = ObjectId.NewObjectId();
return camera;
}
public PublishServiceSelectionViewModel(PublishServiceModel model, Camera camera)
{
if (model == null)
throw new ArgumentNullException("model");
if (camera == null)
throw new ArgumentNullException("camera");
Model = model;
SelectedCamera = camera;
ServiceCollection = new ObservableCollection<MediaService>();
Status = ViewModelStatus.Initializing;
Model.GetServices(GetServicesCallback);
}
public PublishedCameraConfigurationViewModel(PublishedCameraModel model, MediaService service, Camera camera)
{
if (model == null)
throw new ArgumentNullException("model");
if (service == null)
throw new ArgumentNullException("service");
if (camera == null)
throw new ArgumentNullException("camera");
Model = model;
SelectedService = service;
SelectedCamera = camera;
DestinationPort = 9999;
}
internal static ResponsiveMDIChild MakeLiveVideoView(Camera camera)
{
if (camera == null)
throw new ArgumentNullException("camera");
ResponsiveMDIChild mdi = new ResponsiveMDIChild()
{
Title = camera.Name,
Content = new Grid()
};
LiveVideoViewRouter.SetEntry(mdi.Content as Grid, camera);
return mdi;
}
public void PublishCamera(Camera camera, string address, int port)
{
try
{
AsyncWorkerHandle<Camera> handle = AsyncWorkerHelper.DoWork<Camera>(
delegate(object sender, DoWorkEventArgs e)
{
e.Result = PublishCameraSync(camera, address, port);
},
null, null);
}
catch (Exception ex)
{
ExceptionHandler.Handle(ex);
}
}
public void SetObject(object target)
{
if (target == null)
throw new ArgumentNullException("target");
Camera camera = target as Camera;
if (camera == null)
throw new ArgumentNullException("camera");
UpdatedCamera = camera;
this.SelectedVideoSourceDescription = camera.VideoSourceDescription;
this.SelectedVideoSourceName = camera.VideoSourceDescription.FriendlyName;
this.CameraName = camera.Name;
this.CameraDescription = camera.Description;
this.CameraTags = camera.Tags;
}
public void CheckCameraName(Camera camera, EventHandler<AsyncWorkerCallbackEventArgs<bool>> callback)
{
if (camera == null)
throw new ArgumentNullException("camera");
try
{
AsyncWorkerHandle<bool> handle = AsyncWorkerHelper.DoWork<bool>(
delegate(object sender, DoWorkEventArgs e)
{
e.Result = true; // check here, true is available, false is in using
GetCamerasRequest request = new GetCamerasRequest();
GetCamerasResponse response =
ServiceProvider.GetService<IDeviceConnectorService, IDeviceConnectorCallbackService>(
ViewModelLocator.ServiceClient,
ViewModelLocator.SelectedService.HostName,
ViewModelLocator.SelectedService.Uri.ToString()
).GetCameras(request);
if (response.Cameras != null)
{
foreach (var item in response.Cameras)
{
if (item.Profile.Name == camera.Name)
{
e.Result = false;
break;
}
}
}
},
null, callback);
}
catch (Exception ex)
{
ExceptionHandler.Handle(ex);
}
}
public void GetCameras(EventHandler<AsyncWorkerCallbackEventArgs<IList<Camera>>> callback)
{
try
{
AsyncWorkerHandle<IList<Camera>> handle = AsyncWorkerHelper.DoWork<IList<Camera>>(
delegate(object sender, DoWorkEventArgs e)
{
List<Camera> cameras = new List<Camera>();
GetCamerasRequest request = new GetCamerasRequest();
GetCamerasResponse response =
ServiceProvider.GetService<IDeviceConnectorService, IDeviceConnectorCallbackService>(
ViewModelLocator.ServiceClient,
ViewModelLocator.SelectedService.HostName,
ViewModelLocator.SelectedService.Uri.ToString()
).GetCameras(request);
if (response.Cameras != null)
{
foreach (var item in response.Cameras)
{
Camera camera = new Camera()
{
Id = item.Profile.Id,
Name = item.Profile.Name,
Description = item.Profile.Description,
Tags = item.Profile.Tags,
Thumbnail = item.Thumbnail
};
camera.VideoSourceDescription = new VideoSourceDescription()
{
FriendlyName = item.Config.FriendlyName,
OriginalSourceString = item.Config.OriginalSourceString,
SourceString = item.Config.SourceString,
FrameInterval = item.Config.FrameInterval,
FrameRate = item.Config.FrameRate,
UserName = item.Config.UserName,
Password = item.Config.Password,
UserAgent = item.Config.UserAgent,
};
if (item.Config.Resolution != null)
{
camera.VideoSourceDescription.Resolution = new Resolution() { Width = item.Config.Resolution.Width, Height = item.Config.Resolution.Height };
}
switch (item.Profile.FilterType)
{
case FilterTypeData.LocalCamera:
camera.VideoSourceDescription.SourceType = VideoSourceType.LocalCamera;
break;
case FilterTypeData.LocalDesktop:
camera.VideoSourceDescription.SourceType = VideoSourceType.LocalDesktop;
break;
case FilterTypeData.LocalAVIFile:
camera.VideoSourceDescription.SourceType = VideoSourceType.LocalAVIFile;
break;
case FilterTypeData.NetworkJPEG:
camera.VideoSourceDescription.SourceType = VideoSourceType.NetworkJPEG;
break;
case FilterTypeData.NetworkMJPEG:
camera.VideoSourceDescription.SourceType = VideoSourceType.NetworkMJPEG;
break;
default:
break;
}
camera.HostName = ViewModelLocator.SelectedService.HostName;
camera.HostUri = ViewModelLocator.SelectedService.Uri.ToString();
cameras.Add(camera);
}
}
e.Result = cameras;
},
null, callback);
}
catch (Exception ex)
{
ExceptionHandler.Handle(ex);
}
}
public void DeleteCamera(Camera camera, EventHandler<AsyncWorkerCallbackEventArgs<bool>> callback)
{
if (camera == null)
throw new ArgumentNullException("camera");
try
{
AsyncWorkerHandle<bool> handle = AsyncWorkerHelper.DoWork<bool>(
delegate(object sender, DoWorkEventArgs e)
{
DeleteCameraRequest request = new DeleteCameraRequest();
request.CameraId = camera.Id;
DeleteCameraResponse response =
ServiceProvider.GetService<IDeviceConnectorService, IDeviceConnectorCallbackService>(
ViewModelLocator.ServiceClient,
ViewModelLocator.SelectedService.HostName,
ViewModelLocator.SelectedService.Uri.ToString()
).DeleteCamera(request);
e.Result = true;
},
null, callback);
}
catch (Exception ex)
{
ExceptionHandler.Handle(ex);
}
}
private void SetCameraDisplayProtectionMask(Camera camera)
{
camera.IsDisplayProtectionMask = false;
}
private void SetCameraOnScreenDisplay(Camera camera)
{
camera.IsDisplayOnScreenDisplay = true;
}
private static Camera UnpublishCameraSync(Camera camera, string address, int port)
{
MediaService service = GetDeviceConnectorServiceSync(camera.HostUri);
if (service != null)
{
UnpublishCameraRequest request = new UnpublishCameraRequest()
{
CameraId = camera.Id,
Destination = new PublishDestinationData()
{
Address = address,
Port = port,
},
};
UnpublishCameraResponse response =
ServiceProvider
.GetService<IDeviceConnectorService, IDeviceConnectorCallbackService>(
ViewModelLocator.ServiceClient, service.HostName, service.Uri.ToString())
.UnpublishCamera(request);
}
return camera;
}
public void CreateCamera(Camera camera, EventHandler<AsyncWorkerCallbackEventArgs<Camera>> callback)
{
if (camera == null)
throw new ArgumentNullException("camera");
try
{
AsyncWorkerHandle<Camera> handle = AsyncWorkerHelper.DoWork<Camera>(
delegate(object sender, DoWorkEventArgs e)
{
CreateCameraRequest request = new CreateCameraRequest();
request.Camera = new CameraData();
request.Camera.Profile = new CameraProfileData();
request.Camera.Profile.Id = camera.Id;
request.Camera.Profile.Name = camera.Name;
request.Camera.Profile.Description = camera.Description;
request.Camera.Profile.Tags = camera.Tags;
request.Camera.Profile.FilterType = FilterTypeData.None;
switch (camera.VideoSourceDescription.SourceType)
{
case VideoSourceType.Mock:
break;
case VideoSourceType.LocalAVIFile:
request.Camera.Profile.FilterType = FilterTypeData.LocalAVIFile;
request.Camera.Profile.FilterId = camera.VideoSourceDescription.OriginalSourceString;
break;
case VideoSourceType.LocalCamera:
request.Camera.Profile.FilterType = FilterTypeData.LocalCamera;
request.Camera.Profile.FilterId = camera.VideoSourceDescription.OriginalSourceString;
break;
case VideoSourceType.LocalDesktop:
request.Camera.Profile.FilterType = FilterTypeData.LocalDesktop;
request.Camera.Profile.FilterId = camera.VideoSourceDescription.OriginalSourceString;
break;
case VideoSourceType.NetworkJPEG:
request.Camera.Profile.FilterType = FilterTypeData.NetworkJPEG;
request.Camera.Profile.FilterId = camera.VideoSourceDescription.OriginalSourceString;
break;
case VideoSourceType.NetworkMJPEG:
request.Camera.Profile.FilterType = FilterTypeData.NetworkMJPEG;
request.Camera.Profile.FilterId = camera.VideoSourceDescription.OriginalSourceString;
break;
default:
break;
}
request.Camera.Config = new CameraConfigData()
{
FriendlyName = camera.VideoSourceDescription.FriendlyName,
OriginalSourceString = camera.VideoSourceDescription.OriginalSourceString,
SourceString = camera.VideoSourceDescription.SourceString,
FrameInterval = camera.VideoSourceDescription.FrameInterval,
FrameRate = camera.VideoSourceDescription.FrameRate,
UserName = camera.VideoSourceDescription.UserName,
Password = camera.VideoSourceDescription.Password,
UserAgent = camera.VideoSourceDescription.UserAgent,
};
if (camera.VideoSourceDescription.Resolution != null)
{
request.Camera.Config.Resolution = new ResolutionData()
{
Width = camera.VideoSourceDescription.Resolution.Width,
Height = camera.VideoSourceDescription.Resolution.Height
};
}
// 默认请求超时时间为1分钟
CreateCameraResponse response =
ServiceProvider.GetService<IDeviceConnectorService, IDeviceConnectorCallbackService>(
ViewModelLocator.ServiceClient,
ViewModelLocator.SelectedService.HostName,
ViewModelLocator.SelectedService.Uri.ToString()
).CreateCamera(request);
if (response.Camera != null)
{
e.Result = camera;
}
},
null, callback);
}
catch (Exception ex)
{
ExceptionHandler.Handle(ex);
}
}
private Camera GetCameraDevice()
{
MediaService service = GetDeviceConnectorServiceSync(Camera.Profile.DeviceServiceUri);
GetCameraRequest request = new GetCameraRequest()
{
CameraId = Camera.Profile.CameraId,
};
GetCameraResponse response =
ServiceProvider
.GetService<IDeviceConnectorService, IDeviceConnectorCallbackService>(
DeviceConnectorServiceClient.ServiceClient, service.HostName, service.Uri.ToString())
.GetCamera(request);
Camera camera = null;
if (response.Camera != null)
{
camera = new Camera()
{
Id = response.Camera.Profile.Id,
Name = response.Camera.Profile.Name,
Description = response.Camera.Profile.Description,
Tags = response.Camera.Profile.Tags,
Thumbnail = response.Camera.Thumbnail
};
// camera video source
camera.VideoSourceDescription = new VideoSourceDescription()
{
FriendlyName = response.Camera.Config.FriendlyName,
OriginalSourceString = response.Camera.Config.OriginalSourceString,
SourceString = response.Camera.Config.SourceString,
FrameInterval = response.Camera.Config.FrameInterval,
FrameRate = response.Camera.Config.FrameRate,
UserName = response.Camera.Config.UserName,
Password = response.Camera.Config.Password,
UserAgent = response.Camera.Config.UserAgent,
};
if (response.Camera.Config.Resolution != null)
{
camera.VideoSourceDescription.Resolution = new Resolution() { Width = response.Camera.Config.Resolution.Width, Height = response.Camera.Config.Resolution.Height };
}
// translate cameras came from remote server
switch (response.Camera.Profile.FilterType)
{
case FilterTypeData.LocalCamera:
case FilterTypeData.LocalDesktop:
case FilterTypeData.LocalAVIFile:
case FilterTypeData.NetworkJPEG:
case FilterTypeData.NetworkMJPEG:
camera.VideoSourceDescription.SourceType = VideoSourceType.NetworkRtpStream;
break;
default:
break;
}
// where is this camera
camera.HostName = service.HostName;
camera.HostUri = service.Uri.ToString();
}
return camera;
}
private static Camera KeepPublishedCameraAliveSync(Camera camera, string address, int port)
{
MediaService service = GetDeviceConnectorServiceSync(camera.HostUri);
if (service != null)
{
KeepPublishedCameraAliveRequest request = new KeepPublishedCameraAliveRequest()
{
CameraId = camera.Id,
Destination = new PublishDestinationData()
{
Address = address,
Port = port,
},
};
KeepPublishedCameraAliveResponse response =
ServiceProvider
.GetService<IDeviceConnectorService, IDeviceConnectorCallbackService>(
DeviceConnectorServiceClient.ServiceClient, service.HostName, service.Uri.ToString())
.KeepPublishedCameraAlive(request);
}
return camera;
}
public void Stop()
{
lock (_syncRoot)
{
if (!IsStreaming) return;
if (_device != null)
{
try
{
string address = LocalMachine.HostName;
int port = int.Parse(_device.VideoSource.Source);
StopStream(_device, address, port);
_device.NewFrameEvent -= OnNewFrame;
_device.Stop();
}
catch { }
_device = null;
}
if (_streamingServer != null)
{
try
{
_streamingServer.Stop();
}
catch { }
_streamingServer = null;
}
IsStreaming = false;
}
}
public override void Cleanup()
{
base.Cleanup();
TargetCamera = null;
if (_keepCameraAliveTimer != null)
{
_keepCameraAliveTimer.Change(Timeout.Infinite, Timeout.Infinite);
_keepCameraAliveTimer.Dispose();
_keepCameraAliveTimer = null;
}
}
private void SetCameraTimestamp(Camera camera)
{
camera.IsDisplayTimestamp = true;
}
private void SetCameraRotation(Camera camera)
{
camera.IsFlipX = false;
camera.IsFlipY = false;
}
private void StopStream(Camera device, string address, int port)
{
UnpublishCameraSync(device, address, port);
}
public void UpdateCamera(Camera camera, EventHandler<AsyncWorkerCallbackEventArgs<Camera>> callback)
{
if (camera == null)
throw new ArgumentNullException("camera");
try
{
AsyncWorkerHandle<Camera> handle = AsyncWorkerHelper.DoWork<Camera>(
delegate(object sender, DoWorkEventArgs e)
{
UpdateCameraRequest request = new UpdateCameraRequest();
request.CameraId = camera.Id;
request.CameraName = camera.Name;
request.Description = camera.Description;
request.Tags = camera.Tags;
UpdateCameraResponse response =
ServiceProvider.GetService<IDeviceConnectorService, IDeviceConnectorCallbackService>(
ViewModelLocator.ServiceClient,
ViewModelLocator.SelectedService.HostName,
ViewModelLocator.SelectedService.Uri.ToString()
).UpdateCamera(request);
if (response.Camera != null)
{
e.Result = camera;
}
},
null, callback);
}
catch (Exception ex)
{
ExceptionHandler.Handle(ex);
}
}
public object Clone()
{
Camera camera = new Camera();
camera.Id = this.Id;
camera.Name = this.Name;
camera.HostName = this.HostName;
camera.Tags = this.Tags;
camera.Description = this.Description;
camera.VideoSourceDescription = this.VideoSourceDescription;
camera.Thumbnail = this.Thumbnail;
return camera;
}
private void SetCameraDisplayLogo(Camera camera)
{
camera.IsDisplayLogo = false;
}
private void SetCameraDecorators(Camera camera)
{
SetCameraRotation(camera);
SetCameraTimestamp(camera);
SetCameraOnScreenDisplay(camera);
SetCameraDisplayLogo(camera);
SetCameraDisplayProtectionMask(camera);
SetCameraMotionDetection(camera);
}
private static List<Camera> GetCamerasSync()
{
List<MediaService> services = GetDeviceConnectorServicesSync();
List<Camera> cameras = new List<Camera>();
foreach (var service in services)
{
GetCamerasRequest request = new GetCamerasRequest();
GetCamerasResponse response =
ServiceProvider
.GetService<IDeviceConnectorService, IDeviceConnectorCallbackService>(
ViewModelLocator.ServiceClient, service.HostName, service.Uri.ToString())
.GetCameras(request);
if (response.Cameras != null)
{
foreach (var item in response.Cameras)
{
Camera camera = new Camera()
{
Id = item.Profile.Id,
Name = item.Profile.Name,
Description = item.Profile.Description,
Tags = item.Profile.Tags,
Thumbnail = item.Thumbnail
};
// camera video source
camera.VideoSourceDescription = new VideoSourceDescription()
{
FriendlyName = item.Config.FriendlyName,
OriginalSourceString = item.Config.OriginalSourceString,
SourceString = item.Config.SourceString,
FrameInterval = item.Config.FrameInterval,
FrameRate = item.Config.FrameRate,
UserName = item.Config.UserName,
Password = item.Config.Password,
UserAgent = item.Config.UserAgent,
};
if (item.Config.Resolution != null)
{
camera.VideoSourceDescription.Resolution = new Resolution() { Width = item.Config.Resolution.Width, Height = item.Config.Resolution.Height };
}
// translate cameras came from remote server
switch (item.Profile.FilterType)
{
case FilterTypeData.LocalCamera:
case FilterTypeData.LocalDesktop:
case FilterTypeData.LocalAVIFile:
case FilterTypeData.NetworkJPEG:
case FilterTypeData.NetworkMJPEG:
camera.VideoSourceDescription.SourceType = VideoSourceType.NetworkRtpStream;
break;
default:
break;
}
// where is this camera
camera.HostName = service.HostName;
camera.HostUri = service.Uri.ToString();
cameras.Add(camera);
}
}
}
return cameras;
}
private void SetCameraMotionDetection(Camera camera)
{
camera.IsMotionDetection = false;
MotionDetectorType detectorType = MotionDetectorType.TwoFramesDifference;
// 设置移动侦测方式
switch (detectorType)
{
case MotionDetectorType.TwoFramesDifference:
camera.MotionDetector = new MotionDetector(new TwoFramesDifferenceDetector(true));
SetCameraMotionDetectorProcessor(camera);
break;
case MotionDetectorType.CustomFrameDifference:
camera.MotionDetector = new MotionDetector(new CustomFrameDifferenceDetector(true, true));
SetCameraMotionDetectorProcessor(camera);
break;
case MotionDetectorType.SimpleBackgroundModeling:
camera.MotionDetector = new MotionDetector(new SimpleBackgroundModelingDetector(true, true));
SetCameraMotionDetectorProcessor(camera);
break;
default:
break;
}
}
public void Start()
{
lock (_syncRoot)
{
if (IsStreaming) return;
_streamingServer = new MJpegStreamingServer(Port);
_streamingServer.Start();
_device = GetCameraDevice();
if (_device != null)
{
_device.NewFrameEvent += OnNewFrame;
_device.Start();
string address = LocalMachine.HostName;
int port = int.Parse(_device.VideoSource.Source);
StartStream(_device, address, port);
}
IsStreaming = true;
}
}
private void SetCameraMotionDetectorProcessor(Camera camera)
{
MotionProcessorType motionProcessorAlgorithm = MotionProcessorType.BlobCountingObjects;
// 设置移动侦测处理算法
switch (motionProcessorAlgorithm)
{
case MotionProcessorType.GridMotionArea:
camera.MotionDetector.MotionProcessingAlgorithm = new GridMotionAreaProcessing();
((GridMotionAreaProcessing)camera.MotionDetector.MotionProcessingAlgorithm).HighlightColor = System.Drawing.Color.Blue;
break;
case MotionProcessorType.BlobCountingObjects:
camera.MotionDetector.MotionProcessingAlgorithm = new BlobCountingObjectsProcessing();
((BlobCountingObjectsProcessing)camera.MotionDetector.MotionProcessingAlgorithm).HighlightColor = System.Drawing.Color.Blue;
break;
case MotionProcessorType.MotionBorderHighlighting:
camera.MotionDetector.MotionProcessingAlgorithm = new MotionBorderHighlighting();
((MotionBorderHighlighting)camera.MotionDetector.MotionProcessingAlgorithm).HighlightColor = System.Drawing.Color.Blue;
break;
case MotionProcessorType.MotionAreaHighlighting:
camera.MotionDetector.MotionProcessingAlgorithm = new MotionAreaHighlighting();
((MotionAreaHighlighting)camera.MotionDetector.MotionProcessingAlgorithm).HighlightColor = System.Drawing.Color.Blue;
break;
default:
break;
}
}
public PublishPair(MediaService service, Camera camera)
: this()
{
Service = service;
Camera = camera;
}
private void CleanCameraTimestamp(Camera camera)
{
camera.IsDisplayTimestamp = false;
}
