doCleanup1()
{
//unload xrefs
ObjectIdCollection xrefBTRs = xRef.getXRefBlockTableRecords();
BaseObjs._db.UnloadXrefs(xrefBTRs);
//unload CIVIL3D2015.dvb
try{
acadApp.UnloadDVB(@"C:\TSet\VBA2015\CIVIL3D2015.dvb");
}
catch {}
Extents3d ext3d = BaseObjs._getExtents;
//change view to all
VPort.zoomWindow(ext3d);
TypedValue[] tvs = new TypedValue[4] {
new TypedValue((int)DxfCode.Operator, "<OR"),
new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(MText)).DxfName),
new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(Leader)).DxfName),
new TypedValue((int)DxfCode.Operator, "OR>")
};
SelectionSet ss = Select.buildSSet(tvs);
ObjectId[] ids = null;
if (ss != null)
{
ids = ss.GetObjectIds();
for (int i = 0; i < ids.Length; i++)
{
ids[i].clearAllXdata();
}
}
//explode
tvs = new TypedValue[17] {
new TypedValue((int)DxfCode.Operator, "<NOT"),
new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(Polyline3d)).DxfName),
new TypedValue((int)DxfCode.Operator, "NOT>"),
new TypedValue((int)DxfCode.Operator, "<NOT"),
new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(CogoPoint)).DxfName),
new TypedValue((int)DxfCode.Operator, "NOT>"),
new TypedValue((int)DxfCode.Operator, "<NOT"),
new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(MText)).DxfName),
new TypedValue((int)DxfCode.Operator, "NOT>"),
new TypedValue((int)DxfCode.Operator, "<NOT"),
new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(Leader)).DxfName),
new TypedValue((int)DxfCode.Operator, "NOT>"),
new TypedValue((int)DxfCode.Operator, "<NOT"),
new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(Wipeout)).DxfName),
new TypedValue((int)DxfCode.Operator, "NOT>"),
new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(BlockReference)).DxfName),
new TypedValue((int)DxfCode.Operator, "NOT>")
};
ss = Select.buildSSet(tvs, ext3d.MinPoint, ext3d.MaxPoint);
if (ss != null)
{
ids = ss.GetObjectIds();
ObjectIdCollection idsExp = ids.explode();
}
//delete breaklines and points
//DELETE BREAKLINES
tvs = new TypedValue[2] {
new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(Polyline3d)).DxfName),
new TypedValue((int)DxfCode.LayerName, "CPNT-BRKLINE")
};
ss = Select.buildSSet(tvs);
if (ss != null)
{
ids = ss.GetObjectIds();
ids.deleteObjs();
}
//DELETE COGO POINTS
tvs = new TypedValue[1] {
new TypedValue((int)DxfCode.Start, RXClass.GetClass(typeof(CogoPoint)).DxfName),
};
ss = Select.buildSSet(tvs);
if (ss != null)
{
ids = ss.GetObjectIds();
ids.deleteObjs();
}
//load CIVIL3D2015.dvb
try
{
acadApp.LoadDVB(@"C:\TSet\VBA2015\CIVIL3D2015.dvb");
}
catch { }
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
//...
if (opName == RoleSwitchBinary.OpGetName)
{
if (retVals.Count >= 1 && retVals[0].Value() != null)
{
bool level = (bool)retVals[0].Value();
registeredSwitches[senderPort].Level = (level)? 1 : 0;
}
else
{
logger.Log("{0} got bad result for getlevel subscription from {1}", this.ToString(), senderPort.ToString());
}
}
}
public override IList <VParamType> Invoke(string roleName, string opName, IList <VParamType> parameters, VPort p, VCapability reqCap, VCapability respCap)
{
return(CollectionAdapters.ToIList <IParamType, VParamType>(_contract.Invoke(roleName, opName,
CollectionAdapters.ToIListContract <VParamType, IParamType>(parameters, BaseTypeAdapter.V2C, BaseTypeAdapter.C2V),
PortAdapter.V2C(p),
CapabilityAdapter.V2C(reqCap),
CapabilityAdapter.V2C(respCap)),
BaseTypeAdapter.C2V, BaseTypeAdapter.V2C));
}
/// <summary>
/// The handler for operation notifications.
/// The module class should override this function if operation subscriptions are being used.
/// </summary>
/// <param name="roleName"></param>
/// <param name="opName"></param>
/// <param name="retVals"></param>
/// <param name="senderPort"></param>
public virtual void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
throw new NotImplementedException("The module is using subscription without implementing an OnNotification that overrides this function in the parent class");
}
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 override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
string message;
lock (this)
{
switch (opName.ToLower())
{
case RoleDummy.OpEchoSubName:
int rcvdNum = (int)retVals[0].Value();
message = String.Format("async echo response from {0}. rcvd = {1}", senderPort.ToString(), rcvdNum.ToString());
this.receivedMessageList.Add(message);
break;
default:
message = String.Format("Invalid async operation return {0} from {1}", opName.ToLower(), senderPort.ToString());
break;
}
}
logger.Log("{0} {1}", this.ToString(), message);
}
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;
}
}
//fix the color up now
if (isColored)
{
var retValsColor = switchPort.Invoke(RoleLightColor.RoleName, RoleLightColor.OpGetName, null,
ControlPort, switchInfo.Capability, ControlPortCapability);
switchPort.Subscribe(RoleLightColor.RoleName, RoleLightColor.OpGetName, ControlPort, switchInfo.Capability, ControlPortCapability);
if (retVals[0].Maintype() < 0)
{
logger.Log("SwitchController could not get color for {0}", switchFriendlyName);
}
else
{
byte red, green, blue;
red = Math.Min(Math.Max((byte)(int)retValsColor[0].Value(), (byte)0), (byte)255);
green = Math.Min(Math.Max((byte)(int)retValsColor[1].Value(), (byte)0), (byte)255);
blue = Math.Min(Math.Max((byte)(int)retValsColor[2].Value(), (byte)0), (byte)255);
switchInfo.Color = Color.FromArgb(red, green, blue);
}
}
}
}
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)
{
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());
}
}
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
string message;
lock (this)
{
switch (opName.ToLower())
{
case "echosub":
string rcvdData = (string)retVals[0].Value();
irDataList.Add(rcvdData);
//ProcessData(rcvdData);
message = String.Format("async echo response from {0}. rcvd = {1}", senderPort.ToString(), rcvdData.ToString());
this.receivedMessageList.Add(message);
break;
default:
message = String.Format("Invalid async operation return {0} from {1}", opName.ToLower(), senderPort.ToString());
break;
}
}
//logger.Log("{0} {1}", this.ToString(), message);
}
private TableEntry readEntry(DxfEntryTemplate template)
{
TableEntry table = null;
//Get the entry
switch (template.TableName)
{
case DxfFileToken.TableAppId:
table = new AppId(template);
break;
case DxfFileToken.TableBlockRecord:
table = new BlockRecord(template);
break;
case DxfFileToken.TableDimstyle:
table = new DimensionStyle(template);
break;
case DxfFileToken.TableLayer:
table = new Layer(template);
break;
case DxfFileToken.TableLinetype:
table = new LineType(template);
break;
case DxfFileToken.TableStyle:
table = new Style(template);
break;
case DxfFileToken.TableUcs:
table = new UCS(template);
break;
case DxfFileToken.TableView:
table = new View(template);
break;
case DxfFileToken.TableVport:
table = new VPort(template);
break;
default:
Debug.Fail($"Unhandeled table {template.Name}.");
break;
}
//Jump the SubclassMarker
m_reader.ReadNext();
Dictionary <DxfCode, object> map = table?.GetCadObjectMap() ?? new Dictionary <DxfCode, object>();
while (m_reader.LastDxfCode != DxfCode.Start)
{
//Check if the dxf code is registered
if (map.ContainsKey(m_reader.LastDxfCode))
{
//Set the value
map[m_reader.LastDxfCode] = m_reader.LastValue;
}
m_reader.ReadNext();
}
//Build the table based on the map
table?.Build(map);
return(table);
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
string message = string.Empty;
lock (this)
{
bool isSignalR = (this.Connection != null && this.Connection.State == ConnectionState.Connected);
switch (opName.ToLower())
{
case RoleSignalDigital.OnDigitalEvent:
int slot = (int)retVals[0].Value();
int join = (int)retVals[1].Value();
bool value = (bool)retVals[2].Value();
if (isSignalR && this.HubProxy != null)
{
this.HubProxy.Invoke("OnDigitalEvent", slot, join, value);
}
if (this.azureEventHub != null)
{
this.azureEventHub.SendEvents(RoleSignalDigital.OnDigitalEvent, slot, join, value, string.Empty);
}
message = String.Format("async OnDigitalEvent from {0}. slot = {1} join={2} value = {3}", senderPort.ToString(), slot, join, value);
// this.receivedMessageList.Add(message);
break;
case RoleSignalDigital.OnConnectEvent:
if (isSignalR)
{
this.HubProxy.Invoke("OnConnectEvent", retVals);
}
message = String.Format("async OnConnectEvent from {0}.", senderPort.ToString());
// this.receivedMessageList.Add(message);
if (this.azureEventHub != null)
{
this.azureEventHub.SendEvents(RoleSignalDigital.OnConnectEvent, -1, -1, false, senderPort.ToString());
}
break;
case RoleSignalDigital.OnDisconnectEvent:
if (isSignalR)
{
this.HubProxy.Invoke("OnDisconnectEvent", retVals);
}
message = String.Format("async OnDisconnectEvent from {0}. DisconnectReasonMessage = {1}", retVals[0].Value());
if (this.azureEventHub != null)
{
this.azureEventHub.SendEvents(RoleSignalDigital.OnDisconnectEvent, -1, -1, false, retVals[0].Value().ToString());
}
// this.receivedMessageList.Add(message);
break;
case RoleSignalDigital.OnErrorEvent:
if (isSignalR)
{
this.HubProxy.Invoke("OnErrorEvent", retVals);
}
message = string.Empty;
if (retVals != null && retVals.Count > 0)
{
message = String.Format("async OnErrorEvent from {0}. ErrorMessage = {1}", retVals[0].Value());
}
if (this.azureEventHub != null)
{
this.azureEventHub.SendEvents(RoleSignalDigital.OnErrorEvent, -1, -1, false, retVals[0].Value().ToString());
}
break;
default:
message = String.Format("Invalid async operation return {0} from {1}", opName.ToLower(), senderPort.ToString());
if (this.azureEventHub != null)
{
this.azureEventHub.SendEvents(RoleSignalDigital.OnErrorEvent, -1, -1, false, message);
}
break;
}
}
logger.Log("{0} {1}", this.ToString(), message);
}
public abstract override void PortDeregistered(VPort port);
internal void SetLevel(string switchFriendlyName, double level)
{
if (switchFriendlyNames.ContainsKey(switchFriendlyName))
{
VPort switchPort = switchFriendlyNames[switchFriendlyName];
if (registeredSwitches.ContainsKey(switchPort))
{
SwitchInfo switchInfo = registeredSwitches[switchPort];
IList <VParamType> args = new List <VParamType>();
//make sure that the level is between zero and 1
if (level < 0)
{
level = 0;
}
if (level > 1)
{
level = 1;
}
if (switchInfo.Type == SwitchType.Multi)
{
var retVal = Invoke(switchPort, RoleSwitchMultiLevel.Instance, RoleSwitchMultiLevel.OpSetName, new ParamType(level));
if (retVal != null && retVal.Count == 1 && retVal[0].Maintype() == (int)ParamType.SimpleType.error)
{
logger.Log("Error in setting level: {0}", retVal[0].Value().ToString());
throw new Exception(retVal[0].Value().ToString());
}
}
else
{
//interpret all non-zero values as ON
bool boolLevel = (level > 0) ? true : false;
var retVal = Invoke(switchPort, RoleSwitchBinary.Instance, RoleSwitchBinary.OpSetName, new ParamType(boolLevel));
if (retVal != null && retVal.Count == 1 && retVal[0].Maintype() == (int)ParamType.SimpleType.error)
{
logger.Log("Error in setting level: {0}", retVal[0].Value().ToString());
throw new Exception(retVal[0].Value().ToString());
}
}
lock (this)
{
this.lastSet = DateTime.Now;
}
switchInfo.Level = level;
}
}
else
{
throw new Exception("Switch with friendly name " + switchFriendlyName + " not found");
}
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
lock (this)
{
//check if notification is speech event
if (roleName.Contains(RoleSpeechReco.RoleName) && opName.Equals(RoleSpeechReco.OpPhraseRecognizedSubName))
{
string rcvdCmd = (string)retVals[0].Value();
switch (rcvdCmd)
{
case "ALLON":
SetAllSwitches(1.0);
break;
case "ALLOFF":
SetAllSwitches(0.0);
break;
case "PLAYMOVIE":
SetAllSwitches(0.1);
break;
case "DISCO":
DiscoSwitches();
break;
}
return;
}
if (!registeredSwitches.ContainsKey(senderPort))
{
throw new Exception("Got notification from an unknown port " + senderPort.ToString());
}
switch (opName)
{
case RoleSwitchBinary.OpGetName:
{
if (retVals.Count >= 1 && retVals[0].Value() != null)
{
bool level = (bool)retVals[0].Value();
registeredSwitches[senderPort].Level = (level)? 1 : 0;
}
else
{
logger.Log("{0} got bad result for getlevel subscription from {1}", this.ToString(), senderPort.ToString());
}
}
break;
case RoleSwitchMultiLevel.OpGetName:
{
if (retVals.Count >= 1 && retVals[0].Value() != null)
{
double level = (double)retVals[0].Value();
registeredSwitches[senderPort].Level = level;
}
else
{
logger.Log("{0} got bad result for getlevel subscription from {1}", this.ToString(), senderPort.ToString());
}
}
break;
case RoleLightColor.OpGetName:
{
if (!registeredSwitches[senderPort].IsColored)
{
logger.Log("Got {0} for non-colored switch {1}", opName, senderPort.ToString());
return;
}
if (retVals.Count >= 3)
{
byte red, green, blue;
red = Math.Min(Math.Max((byte)(int)retVals[0].Value(), (byte)0), (byte)255);
green = Math.Min(Math.Max((byte)(int)retVals[1].Value(), (byte)0), (byte)255);
blue = Math.Min(Math.Max((byte)(int)retVals[2].Value(), (byte)0), (byte)255);
registeredSwitches[senderPort].Color = Color.FromArgb(red, green, blue);
}
else
{
logger.Log("{0} got bad result for getlevel subscription from {1}", this.ToString(), senderPort.ToString());
}
}
break;
default:
logger.Log("Got notification from incomprehensible operation: " + opName);
break;
}
}
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
logger.Log("Notitification from {0} for {0}", roleName, opName);
if (retVals.Count >= 1)
{
this.IsOn = (int)retVals[0].Value();
}
else
{
logger.Log("{0}: got unexpected retvals [{1}] from {2}", ToString(), retVals.Count.ToString(), senderPort.ToString());
}
}
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());
}
}
public void StopRecording(string cameraFriendlyName)
{
VPort cameraPort = cameraFriendlyNames[cameraFriendlyName];
StopRecording(cameraPort, true);
}
public override void PortRegistered(VPort port)
{
lock (this)
{
if (Role.ContainsRole(port, RoleCamera.RoleName))
{
VCapability capability = GetCapability(port, Constants.UserSystem);
if (cameraPorts.ContainsKey(port))
{
cameraPorts[port] = capability;
}
else
{
cameraPorts.Add(port, capability);
}
logger.Log("{0} added camera port {1}", this.ToString(), port.ToString());
}
//lets not monitor switches
//if (Role.ContainsRole(port, RoleSwitchMultiLevel.RoleName))
//{
// if (port.GetInfo().GetFriendlyName().Equals(switchFriendlyName, StringComparison.CurrentCultureIgnoreCase))
// {
// switchPort = port;
// switchPortCapability = GetCapability(port, Constants.UserSystem);
// if (switchPortCapability != null)
// {
// switchPort.Subscribe(RoleSwitchMultiLevel.RoleName, RoleSwitchMultiLevel.OpGetName,
// this.ControlPort, switchPortCapability, this.ControlPortCapability);
// }
// }
//}
if (Role.ContainsRole(port, RoleSensor.RoleName))
{
//if (port.GetInfo().GetFriendlyName().Equals(sensorFriendlyName, StringComparison.CurrentCultureIgnoreCase))
//{
// sensorPort = port;
VCapability capability = GetCapability(port, Constants.UserSystem);
if (registeredSensors.ContainsKey(port))
{
registeredSensors[port] = capability;
}
else
{
registeredSensors.Add(port, capability);
}
if (capability != null)
{
port.Subscribe(RoleSensor.RoleName, RoleSensor.OpGetName,
this.ControlPort, capability, this.ControlPortCapability);
}
//}
}
}
}
public override void PortRegistered(VPort port)
{
}
/// <summary>
/// Called when a new port is registered with the platform
/// </summary>
public override void PortRegistered(VPort port)
{
ConnectToPairedDevices();
}
public override bool Unsubscribe(string roleName, string opName, VPort fromPort, VCapability respCap)
{
return(_contract.Unsubscribe(roleName, opName, PortAdapter.V2C(fromPort), CapabilityAdapter.V2C(respCap)));
}
public override void OnNotification(string roleName, string opName, IList <VParamType> retVals, VPort senderPort)
{
}
public override void AsyncReturn(string roleName, string opName, IList <VParamType> retVals, VPort p, VCapability respCap)
{
_contract.AsyncReturn(roleName, opName,
CollectionAdapters.ToIListContract <VParamType, IParamType>(retVals, BaseTypeAdapter.V2C, BaseTypeAdapter.C2V),
PortAdapter.V2C(p), CapabilityAdapter.V2C(respCap));
}
/// <summary>
/// Called by (app) modules to invoke operations
/// </summary>
/// <param name="toPort"></param>
/// <param name="role"></param>
/// <param name="opName"></param>
/// <param name="values"></param>
/// <returns></returns>
public IList <VParamType> Invoke(VPort toPort, Role role, string opName, params ParamType[] values)
{
//first check the store if we have the capability
VCapability capability = GetCapabilityFromStore(toPort);
//if not, then try to get it from the platform
if (capability == null)
{
capability = GetCapabilityFromPlatform(toPort);
}
//if capability is still null, throw exception
if (capability == null)
{
throw new AccessViolationException("This module does not have access to this port");
}
var operation = role.GetOperation(opName);
if (operation == null)
{
throw new InvalidOperationException(opName + " is not a valid operation for Role " + role.Name());
}
//check the number of parameters
if (values.Length != operation.Parameters().Count)
{
throw new ArgumentException("Incorrect number of arguments for operation " + opName);
}
//check the types of arguments
for (int index = 0; index < values.Length; index++)
{
if ((values[index].Maintype() != operation.Parameters()[index].Maintype()))
{
throw new ArgumentException(String.Format("Argument {0} is of invalid type. Expected {1}. Got {2}.", index, (ParamType.SimpleType)operation.Parameters()[index].Maintype(), (ParamType.SimpleType)values[index].Maintype()));
}
}
//now invoke the operation
IList <VParamType> retVals = toPort.Invoke(role.Name(), opName, values, ControlPort, capability, ControlPortCapability);
//if we got an error, pass it along
if (retVals.Count >= 1 && retVals[0].Maintype() == (int)ParamType.SimpleType.error)
{
return(retVals);
}
//if we didn't get an error, sanity check the return values
//check the number of elements
if (retVals.Count != operation.ReturnValues().Count)
{
throw new ArgumentException("Incorrect number of return values for operation " + opName);
}
//check the types of elements in return values
for (int index = 0; index < retVals.Count; index++)
{
if ((retVals[index].Maintype() != operation.ReturnValues()[index].Maintype()))
{
throw new ArgumentException(String.Format("Return value {0} is of invalid type. Expected {1}. Got {2}.", index, (ParamType.SimpleType)operation.ReturnValues()[index].Maintype(), (ParamType.SimpleType)retVals[index].Maintype()));
}
}
//otherwise, lets return these values
return(retVals);
}
