// Starts a new recording if there isn't one already under way
private void StartRecording(VPort cameraPort, int videoWidth, int videoHeight, int videoFPSNum, int videoFPSDen, int videoEncBitrate)
{
if (registeredCameras[cameraPort].VideoWriter != null)
{
return;
}
logger.Log("Started new clip for {0}", cameraPort.GetInfo().GetFriendlyName());
CameraInfo cameraInfo = registeredCameras[cameraPort];
string fileName = GetMediaFileName(cameraPort.GetInfo().GetFriendlyName(), MediaType.MediaType_Video_MP4);
if (null == registeredCameras[cameraPort].VideoWriter)
{
registeredCameras[cameraPort].VideoWriter = new VideoWriter();
}
cameraInfo.CurrVideoStartTime = DateTime.Now;
cameraInfo.CurrVideoEndTime = cameraInfo.CurrVideoStartTime + DEFAULT_VIDEO_CLIP_LEN;
int result = cameraInfo.VideoWriter.Init(fileName, videoWidth, videoHeight, videoFPSNum, videoFPSDen, videoEncBitrate);
if (result != 0)
{
string message = String.Format("Failed to start recording for {0} at {1}. Error code = {2}",
cameraPort.GetInfo().GetFriendlyName(), DateTime.Now, result);
logger.Log(message);
}
}
/// <summary>
/// Called when a new port is registered with the platform
/// </summary>
/// <param name="port"></param>
public override void PortRegistered(VPort port)
{
lock (this)
{
if (Role.ContainsRole(port, RoleCamera.RoleName))
{
if (!registeredCameras.ContainsKey(port))
{
InitCamera(port);
}
else
{
//the friendly name of the port might have changed. update that.
string oldFriendlyName = null;
foreach (var pair in cameraFriendlyNames)
{
if (pair.Value.Equals(port) &&
!pair.Key.Equals(port.GetInfo().GetFriendlyName()))
{
oldFriendlyName = pair.Key;
break;
}
}
if (oldFriendlyName != null)
{
cameraFriendlyNames.Remove(oldFriendlyName);
cameraFriendlyNames.Add(port.GetInfo().GetFriendlyName(), port);
}
}
}
}
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
if (registeredCameras.ContainsKey(senderPort))
{
if (retVals.Count >= 1 && retVals[0].Value() != null)
{
byte[] imageBytes = (byte[])retVals[0].Value();
lock (this)
{
registeredCameras[senderPort].LastImageBytes = imageBytes;
if (registeredCameras[senderPort].RecordVideo)
{
Rectangle rectObject = new Rectangle(0, 0, 0, 0);
MemoryStream stream = new MemoryStream(imageBytes);
Bitmap image = null;
image = (Bitmap)Image.FromStream(stream);
if (null != registeredCameras[senderPort].BitmapImage)
{
registeredCameras[senderPort].BitmapImage.Dispose();
registeredCameras[senderPort].BitmapImage = null;
}
registeredCameras[senderPort].BitmapImage = image;
//lets check if the image is what we expect
if (image.PixelFormat != PixelFormat.Format24bppRgb)
{
string message = String.Format("Image format from {0} is not correct. PixelFormat: {1}",
senderPort.GetInfo().GetFriendlyName(), image.PixelFormat);
logger.Log(message);
return;
}
string fileName2 = GetMediaFileName(senderPort.GetInfo().GetFriendlyName(), MediaType.MediaType_Image_JPEG);
if (fileName2 != null)
{
image.Save(fileName2);
}
registeredCameras[senderPort].RecordVideo = false;
}
}
}
else
{
logger.Log("{0} got null image", this.ToString());
}
}
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
string message;
string sensorData;
string sensorTag = senderPort.GetInfo().GetFriendlyName() + roleName;
lock (this)
{
if (roleName.Contains(RoleSensor.RoleName) && opName.Equals(RoleSensor.OpGetName))
{
byte rcvdNum = (byte)(int)retVals[0].Value();
sensorData = rcvdNum.ToString();
}
else if (roleName.Contains(RoleSensorMultiLevel.RoleName) && opName.Equals(RoleSensorMultiLevel.OpGetName))
{
double rcvdNum = (double)retVals[0].Value();
sensorData = rcvdNum.ToString();
}
else
{
sensorData = String.Format("Sensor: Invalid role->op {0}->{1} from {2}", roleName, opName, sensorTag);
}
///////////////Write to Azure Event Hub
bool bIsEventSent = sender.SendEvents(gHome_Id, DateTime.Now, senderPort.GetInfo().GetFriendlyName(), roleName, sensorData);
if (false == bIsEventSent)
{
logger.Log("*****Sending data to event hub failed****");
logger.Log("[Log Data Offline]{0}|{1}|{2}|{3}|{4}", gHome_Id, DateTime.Now.ToString(), gHome_Id, DateTime.Now.ToString(), senderPort.GetInfo().GetFriendlyName(), roleName, sensorData, roleName, sensorData);
}
}
//Create local list of alerts for display
message = String.Format("{0}\t{1}\t{2}", DateTime.Now, sensorTag, sensorData);
this.receivedMessageList.Enqueue(message);
if (this.receivedMessageList.Count > gNumStringstoShow)
{
this.receivedMessageList.Dequeue();
}
logger.Log("Sensor\t{0}", message);
//if applicable write the information to a local file.
if (this.writingToLocalFile)
{
WriteToLocalFile(message);
}
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
string message;
string sensorData;
string sensorTag = senderPort.GetInfo().GetFriendlyName() + roleName;
lock (this)
{
if (roleName.Contains(RoleSensor.RoleName) && opName.Equals(RoleSensor.OpGetName))
{
byte rcvdNum = (byte)(int)retVals[0].Value();
sensorData = rcvdNum.ToString();
}
else if (roleName.Contains(RoleSensorMultiLevel.RoleName) && opName.Equals(RoleSensorMultiLevel.OpGetName))
{
double rcvdNum = (double)retVals[0].Value();
sensorData = rcvdNum.ToString();
}
else
{
sensorData = String.Format("Sensor: Invalid role->op {0}->{1} from {2}", roleName, opName, sensorTag);
}
try
{
//Write to the stream
WriteToStream(sensorTag, sensorData);
}
catch (Exception exp)
{
logger.Log("Sensor:{0}: WriteToStream failed. Exception caught.");
logger.Log(exp.ToString());
}
}
//Create local list of alerts for display
message = String.Format("{0}\t{1}\t{2}", DateTime.Now, sensorTag, sensorData);
this.receivedMessageList.Enqueue(message);
if (this.receivedMessageList.Count > gNumStringstoShow)
{
this.receivedMessageList.Dequeue();
}
logger.Log("Sensor\t{0}", message);
//if applicable write the information to a local file.
if (this.writingToLocalFile)
{
WriteToLocalFile(message);
}
//record latest data in our monitoring dictionary
if (monitorDataValues.ContainsKey(sensorTag))
{
(monitorDataValues[sensorTag]).UpdateDataVal(sensorData);
}
else
{
monitorDataValues.Add(sensorTag, new MonitorDataVal(sensorData));
}
}
//called when the lock is acquired and cameraPort is non-existent in the dictionary
private void InitCamera(VPort cameraPort)
{
VCapability capability = GetCapability(cameraPort, Constants.UserSystem);
//return if we didn't get a capability
if (capability == null)
{
logger.Log("{0} didn't get a capability for {1}", this.ToString(), cameraPort.ToString());
return;
}
//otherwise, add this to our list of cameras
logger.Log("{0} adding camera port {1}", this.ToString(), cameraPort.ToString());
CameraInfo cameraInfo = new CameraInfo();
cameraInfo.Capability = capability;
cameraInfo.LastImageBytes = new byte[0];
cameraInfo.VideoWriter = null;
cameraInfo.CurrVideoStartTime = DateTime.MinValue;
cameraInfo.CurrVideoEndTime = DateTime.MinValue;
registeredCameras.Add(cameraPort, cameraInfo);
string cameraFriendlyName = cameraPort.GetInfo().GetFriendlyName();
cameraFriendlyNames.Add(cameraFriendlyName, cameraPort);
cameraPort.Subscribe(RoleCamera.RoleName, RoleCamera.OpGetVideo, ControlPort, cameraInfo.Capability, ControlPortCapability);
}
void ForgetSwitch(VPort switchPort)
{
switchFriendlyNames.Remove(switchPort.GetInfo().GetFriendlyName());
registeredSwitches.Remove(switchPort);
logger.Log("{0} removed switch/light port {1}", this.ToString(), switchPort.ToString());
}
void InitSwitch(VPort switchPort, SwitchType switchType, bool isColored)
{
logger.Log("{0} adding switch {1} {2}", this.ToString(), switchType.ToString(), switchPort.ToString());
SwitchInfo switchInfo = new SwitchInfo();
switchInfo.Capability = GetCapability(switchPort, Constants.UserSystem);
switchInfo.Level = 0;
switchInfo.Type = switchType;
switchInfo.IsColored = isColored;
switchInfo.Color = Color.Black;
registeredSwitches.Add(switchPort, switchInfo);
string switchFriendlyName = switchPort.GetInfo().GetFriendlyName();
switchFriendlyNames.Add(switchFriendlyName, switchPort);
if (switchInfo.Capability != null)
{
IList <VParamType> retVals;
if (switchType == SwitchType.Multi)
{
retVals = switchPort.Invoke(RoleSwitchMultiLevel.RoleName, RoleSwitchMultiLevel.OpGetName, null,
ControlPort, switchInfo.Capability, ControlPortCapability);
switchPort.Subscribe(RoleSwitchMultiLevel.RoleName, RoleSwitchMultiLevel.OpGetName, ControlPort, switchInfo.Capability, ControlPortCapability);
if (retVals[0].Maintype() < 0)
{
logger.Log("SwitchController could not get current level for {0}", switchFriendlyName);
}
else
{
switchInfo.Level = (double)retVals[0].Value();
}
}
else
{
retVals = switchPort.Invoke(RoleSwitchBinary.RoleName, RoleSwitchBinary.OpGetName, null,
ControlPort, switchInfo.Capability, ControlPortCapability);
switchPort.Subscribe(RoleSwitchBinary.RoleName, RoleSwitchBinary.OpGetName, ControlPort, switchInfo.Capability, ControlPortCapability);
if (retVals[0].Maintype() < 0)
{
logger.Log("SwitchController could not get current level for {0}", switchFriendlyName);
}
else
{
bool boolLevel = (bool)retVals[0].Value();
switchInfo.Level = (boolLevel) ? 1 : 0;
}
}
}
}
/// <summary>
/// Get device Type from VPort
/// </summary>
/// <param name="vp"></param>
/// <returns></returns>
private String getDeviceTypeFromPort(VPort vp)
{
VPortInfo vpi = vp.GetInfo();
string address = vpi.ModuleFacingName();
string[] split = address.Split('|');
address = split[split.Length - 3].ToString();
address = address.Trim();
return(address);
}
//called when the lock is acquired
private void ForgetCamera(VPort cameraPort)
{
cameraFriendlyNames.Remove(cameraPort.GetInfo().GetFriendlyName());
//stop recording if we have a video make object
StopRecording(cameraPort, true);
registeredCameras.Remove(cameraPort);
logger.Log("{0} removed camera port {1}", this.ToString(), cameraPort.ToString());
}
public override void PortDeregistered(VPort port)
{
lock (this)
{
if (accessibleSensorPorts.Contains(port))
{
accessibleSensorPorts.Remove(port);
logger.Log("Sensor:{0} deregistered port {1}", this.ToString(), port.GetInfo().ModuleFacingName());
}
}
}
/// <summary>
/// Does the given port contain the given role
/// </summary>
/// <param name="port"></param>
/// <param name="roleName"></param>
/// <returns></returns>
public static bool ContainsRole(VPort port, string roleName)
{
foreach (VRole role in port.GetInfo().GetRoles())
{
if (ContainsRole(role.Name(), roleName))
{
return(true);
}
}
return(false);
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
if (retVals.Count >= 1)
{
byte val = (byte)(int)retVals[0].Value();
//hack for techfest since we are using a multi-level switch as a doorbell
//if (RoleSwitchMultiLevel.RoleName.Equals(roleName, StringComparison.CurrentCultureIgnoreCase))
// val = 0;
Alert newAlert = new Alert()
{
TimeTriggered = DateTime.Now,
SensorFriendlyName = senderPort.GetInfo().GetFriendlyName(),
SensorLocation = senderPort.GetInfo().GetLocation().Name(),
Value = val,
Acknowledged = false,
};
bool notify = //settings.Mode != AlertMode.none &&
IsAlertTime() &&
!SuppressAlert(newAlert) &&
((RoleSwitchMultiLevel.RoleName.Equals(roleName, StringComparison.CurrentCultureIgnoreCase) && (val == 99 || val == 0)) ||
(RoleSensor.RoleName.Equals(roleName, StringComparison.CurrentCultureIgnoreCase) && val == 255));
logger.Log("{0}: got notified by {1} [{2}] val = {3} notify = {4}\n",
this.ToString(), newAlert.SensorFriendlyName, roleName, val.ToString(), notify.ToString());
if (notify)
{
InsertAlert(newAlert);
GenerateMessage(newAlert);
}
}
else
{
logger.Log("{0}: got unexpected retvals [{1}] from {2}", ToString(), retVals.Count.ToString(), senderPort.ToString());
}
}
private void StopRecording(VPort cameraPort, bool force)
{
bool stopConditionMet = false;
CameraInfo cameraInfo = registeredCameras[cameraPort];
//if ((DateTime.Now - registeredCameras[cameraPort].CurrVideoStartTime).TotalMinutes >=
// MAX_VIDEO_CLIP_LEN_IN_MINUTES)
if (DateTime.Now >= registeredCameras[cameraPort].CurrVideoEndTime)
{
stopConditionMet = true;
}
if ((force || stopConditionMet) && (cameraInfo.VideoWriter != null))
{
string cameraName = cameraPort.GetInfo().GetFriendlyName();
VideoWriter VideoWriter = cameraInfo.VideoWriter;
SafeThread helper = new SafeThread(delegate() { StopRecordingHelper(VideoWriter, cameraName); },
"stoprecordinghelper-" + cameraName, logger);
helper.Start();
cameraInfo.RecordVideo = false;
cameraInfo.VideoWriter = null;
cameraInfo.CurrVideoStartTime = DateTime.MinValue;
cameraInfo.CurrVideoEndTime = DateTime.MinValue;
if (stopConditionMet)
{
logger.Log("Stop recording because the clip time has elapsed for {0}",
cameraPort.GetInfo().GetFriendlyName());
}
else
{
logger.Log("Stop recording for {0}", cameraPort.GetInfo().GetFriendlyName());
}
}
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
string message;
string sensorData;
string sensorTag = senderPort.GetInfo().GetFriendlyName() + roleName;
lock (this)
{
if (roleName.Contains(RoleSensor.RoleName) && opName.Equals(RoleSensor.OpGetName))
{
byte rcvdNum = (byte)(int)retVals[0].Value();
sensorData = rcvdNum.ToString();
}
else if (roleName.Contains(RoleSensorMultiLevel.RoleName) && opName.Equals(RoleSensorMultiLevel.OpGetName))
{
double rcvdNum = (double)retVals[0].Value();
sensorData = rcvdNum.ToString();
}
else
{
sensorData = String.Format("Sensor: Invalid role->op {0}->{1} from {2}", roleName, opName, sensorTag);
}
//log to the azure sql db via azure mobile services
WriteToDB(sensorTag, Convert.ToSingle(sensorData));
}
//Create local list of alerts for display
message = String.Format("{0}\t{1}\t{2}", DateTime.Now, sensorTag, sensorData);
this.receivedMessageList.Enqueue(message);
if (this.receivedMessageList.Count > gNumStringstoShow)
{
this.receivedMessageList.Dequeue();
}
logger.Log("Sensor\t{0}", message);
//if applicable write the information to a local file.
if (this.writingToLocalFile)
{
WriteToLocalFile(message);
}
}
private bool ExtractObjectFromFrame(Bitmap image, VPort cameraPort, ref Rectangle rectObject)
{
bool foundObject = false;
// Lock the bitmap's bits.
Rectangle rect = new Rectangle(0, 0, image.Width, image.Height);
BitmapData bmpData = image.LockBits(rect, ImageLockMode.ReadOnly, image.PixelFormat);
// Get the address of the first line.
IntPtr ptr = bmpData.Scan0;
if (null == registeredCameras[cameraPort].ObjectDetector)
{
registeredCameras[cameraPort].ObjectDetector = new ObjectDetector();
}
unsafe
{
if (!registeredCameras[cameraPort].ObjectDetector.IsInitialized())
{
registeredCameras[cameraPort].ObjectDetector.InitializeFromFrame((byte *)ptr, 3 * image.Width * image.Height, image.Width, image.Height, null);
}
else
{
rectObject = registeredCameras[cameraPort].ObjectDetector.GetObjectRect((byte *)ptr, 3 * image.Width * image.Height);
if (rectObject.Width != 0 && rectObject.Height != 0)
{
foundObject = true;
}
}
if (foundObject)
{
logger.Log("Object detected by camera {0} with co-ordinates X={1}, Y={2}, Width={3}, Height={4}",
cameraPort.GetInfo().GetFriendlyName(), rectObject.X.ToString(), rectObject.Y.ToString(), rectObject.Width.ToString(), rectObject.Height.ToString());
}
}
image.UnlockBits(bmpData);
return(foundObject);
}
internal List <string> GetAllSwitches()
{
List <string> retList = new List <string>();
foreach (string friendlyName in switchFriendlyNames.Keys)
{
VPort switchPort = switchFriendlyNames[friendlyName];
SwitchInfo switchInfo = registeredSwitches[switchPort];
retList.Add(friendlyName);
retList.Add(switchPort.GetInfo().GetLocation().ToString());
retList.Add(switchInfo.Type.ToString());
retList.Add(switchInfo.Level.ToString());
retList.Add(switchInfo.IsColored.ToString());
retList.Add(switchInfo.Color.R.ToString());
retList.Add(switchInfo.Color.G.ToString());
retList.Add(switchInfo.Color.B.ToString());
}
return(retList);
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
if (registeredCameras.ContainsKey(senderPort))
{
if (retVals.Count >= 1 && retVals[0].Value() != null)
{
byte[] imageBytes = (byte[])retVals[0].Value();
lock (this)
{
registeredCameras[senderPort].LastImageBytes = imageBytes;
if (registeredCameras[senderPort].RecordVideo ||
registeredCameras[senderPort].EnableObjectTrigger)
{
bool addFrame = false;
Rectangle rectObject = new Rectangle(0, 0, 0, 0);
MemoryStream stream = new MemoryStream(imageBytes);
Bitmap image = null;
image = (Bitmap)Image.FromStream(stream);
if (null != registeredCameras[senderPort].BitmapImage)
{
registeredCameras[senderPort].BitmapImage.Dispose();
registeredCameras[senderPort].BitmapImage = null;
}
registeredCameras[senderPort].BitmapImage = image;
//lets check if the image is what we expect
if (image.PixelFormat != PixelFormat.Format24bppRgb)
{
string message = String.Format("Image format from {0} is not correct. PixelFormat: {1}",
senderPort.GetInfo().GetFriendlyName(), image.PixelFormat);
logger.Log(message);
return;
}
// stop if needed
StopRecording(senderPort, false /* force*/);
//// if recording is underway don't bother that, it will stop after that clip time lapses
//// if recording needs to be done only on motion (object) triggers, check with the result of the object
//// detector above
//if (registeredCameras[senderPort].RecordVideo)
//{
// //if record video is still true, see if we need to add his frame
// if (registeredCameras[senderPort].VideoWriter != null || !registeredCameras[senderPort].EnableObjectTrigger)
// {
// addFrame = true;
// }
// else
// {
// if (registeredCameras[senderPort].ObjectFound)
// addFrame = true;
// }
//}
if (registeredCameras[senderPort].RecordVideo)
{
addFrame = true;
}
else
{
if (registeredCameras[senderPort].EnableObjectTrigger &&
registeredCameras[senderPort].ObjectFound)
{
addFrame = true;
}
}
if (addFrame)
{
StartRecording(senderPort, image.Width, image.Height, VIDEO_FPS_NUM, VIDEO_FPS_DEN, VIDEO_ENC_FRAMERATE);
long sampleTime = (DateTime.Now - registeredCameras[senderPort].CurrVideoStartTime).Ticks;
AddFrameToVideo(image, senderPort, sampleTime);
if (registeredCameras[senderPort].ObjectFound)
{
registeredCameras[senderPort].ObjectFound = false;
rectObject = registeredCameras[senderPort].LastObjectRect;
WriteObjectImage(senderPort, image, rectObject, true /* center */);
}
}
}
}
}
else
{
logger.Log("{0} got null image", this.ToString());
}
}
}
private void AddFrameToVideo(Bitmap image, VPort cameraPort, long sampleTime)
{
// Lock the bitmap's bits.
Rectangle rect = new Rectangle(0, 0, image.Width, image.Height);
BitmapData bmpData = image.LockBits(rect, ImageLockMode.ReadOnly, image.PixelFormat);
// Get the address of the first line.
IntPtr ptr = bmpData.Scan0;
int result;
unsafe
{
result = registeredCameras[cameraPort].VideoWriter.AddFrame((byte *)ptr, 3 * image.Width * image.Height, image.Width, image.Height, sampleTime);
}
image.UnlockBits(bmpData);
if (result != 0)
{
string message = String.Format("Failed to add frame for {0}. ResultCode: {1:x}", cameraPort.GetInfo().GetFriendlyName(), ((uint)result));
logger.Log(message);
}
}
private void WriteObjectImage(VPort cameraPort, Bitmap image, Rectangle rectSrc, bool center)
{
Rectangle rectTarget = rectSrc;
int srcPixelShiftX = 0;
int srcPixelShiftY = 0;
if (rectSrc.Width == 0 && rectSrc.Height == 0)
{
logger.Log("Write Object Image Called with Rect with zero height and width!");
return;
}
if (center)
{
rectTarget.X = (int)((image.Width - rectSrc.Width) / 2.0);
rectTarget.Y = (int)((image.Height - rectSrc.Height) / 2.0);
srcPixelShiftX = rectTarget.X - rectSrc.X;
srcPixelShiftY = rectTarget.Y - rectSrc.Y;
}
// create the destination based upon layer one
BitmapData bmpData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
int stride = bmpData.Stride;
image.UnlockBits(bmpData);
WriteableBitmap composite = new WriteableBitmap(image.Width, image.Height, 96, 96, System.Windows.Media.PixelFormats.Rgb24, null);
Int32Rect sourceRect = new Int32Rect(0, 0, (int)image.Width, (int)image.Height);
byte[] pixels = new byte[stride * image.Height];
for (int x = 0; x < image.Width; ++x)
{
for (int y = 0; y < image.Height; ++y)
{
if (rectSrc.Contains(x, y))
{
Color clr = image.GetPixel(x, y);
pixels[stride * (y + srcPixelShiftY) + 3 * (x + srcPixelShiftX)] = clr.R;
pixels[stride * (y + srcPixelShiftY) + 3 * (x + srcPixelShiftX) + 1] = clr.G;
pixels[stride * (y + srcPixelShiftY) + 3 * (x + srcPixelShiftX) + 2] = clr.B;
}
else if (!rectTarget.Contains(x, y))
{
pixels[stride * y + 3 * x] = 0x00;
pixels[stride * y + 3 * x + 1] = 0x00;
pixels[stride * y + 3 * x + 2] = 0x00;
}
}
}
composite.WritePixels(sourceRect, pixels, stride, 0);
// encode the bitmap to the output file
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(composite));
string filepath = GetMediaFileName(cameraPort.GetInfo().GetFriendlyName(), MediaType.MediaType_Image_JPEG);
if (null == filepath)
{
logger.Log("GetMediaFileName failed to get a file name, are there more than 10 files of the same name?");
return;
}
using (var stream = new FileStream(filepath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
encoder.Save(stream);
}
}
//public int Receive(IMessage message)
//{
// return _view.Receive(MessageAdapter.C2V(message));
//}
public IPortInfo GetInfo()
{
return(PortInfoAdapter.V2C(_view.GetInfo()));
}