/// <summary>
/// Called when a new port is registered with the platform
/// </summary>
public override void PortRegistered(VPort port)
{
logger.Log("{0} got registeration notification for {1}", ToString(), port.ToString());
lock (this)
{
if (!accessibleWeatherPorts.Contains(port) &&
Role.ContainsRole(port, RoleWeather.RoleName) &&
GetCapabilityFromPlatform(port) != null)
{
accessibleWeatherPorts.Add(port);
logger.Log("{0} added port {1}", this.ToString(), port.ToString());
}
}
}
public override void OnNotification(string roleName, string opName, IList<VParamType> retVals, VPort senderPort)
{
string message;
lock (this)
{
switch (opName.ToLower())
{
case RoleDummy2.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);
}
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.Temperature = (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)
{
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);
}
public override void PortDeregistered(VPort port)
{
lock (this)
{
if (Role.ContainsRole(port, RoleSensor.RoleName))
{
if (registeredSensors.ContainsKey(port))
{
registeredSensors.Remove(port);
logger.Log("{0} removed sensor port {1}", this.ToString(), port.ToString());
}
}
if (Role.ContainsRole(port, RoleActuator.RoleName))
{
if (registeredActuators.ContainsKey(port))
{
registeredActuators.Remove(port);
logger.Log("{0} removed actuator port {1}", this.ToString(), port.ToString());
}
}
}
}
/// <summary>
/// Called when a new port is registered with the platform
/// </summary>
public override void PortRegistered(VPort port)
{
logger.Log("{0} got registeration notification for {1}", ToString(), port.ToString());
lock (this)
{
if (!accessibleDummyPorts.Contains(port) &&
Role.ContainsRole(port, RoleDummy2.RoleName) &&
GetCapabilityFromPlatform(port) != null)
{
accessibleDummyPorts.Add(port);
logger.Log("{0} added port {1}", this.ToString(), port.ToString());
if (Subscribe(port, RoleDummy2.Instance, RoleDummy2.OpEchoSubName))
logger.Log("{0} subscribed to port {1}", this.ToString(), port.ToString());
else
logger.Log("failed to subscribe to port {1}", this.ToString(), port.ToString());
}
}
}
//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);
}
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;
}
}
}
//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());
}
/// <summary>
/// Deregister a port to declare it unavailable for use by other modules
/// </summary>
/// <param name="port">The port to deregisted</param>
/// <param name="owner">The module to which the port belongs</param>
/// <returns></returns>
public int DeregisterPort(VPort port, VModule module)
{
ResultCode result;
lock (this)
{
if (registeredPorts.ContainsKey(port))
{
if (module.Equals(registeredPorts[port]))
{
logger.Log("deregistering port: {0}", port.ToString());
registeredPorts.Remove(port);
result = ResultCode.Success;
}
else
{
logger.Log("got port deregisteration for {0} from a non-owner {1}", port.ToString(), module.ToString());
result = ResultCode.Failure;
}
}
else
{
logger.Log("got deregisteration for unregistered port: {0}", port.ToString());
result = ResultCode.PortNotFound;
}
}
if (result == ResultCode.Success)
{
BroadcastPortDeregistration(port, module);
// broadcast needs to be asyncronous because the module's addin (and appdomain, ports, etc) will be wiped
/*
System.Threading.Thread newThread = new System.Threading.Thread(delegate() {
// System.Threading.Thread.Sleep(Settings.portRegisterDelay);
BroadcastPortDeregistration(port, module); });
newThread.Name = "Deregister Port " + port;
newThread.Start(); */
}
return (int)result;
}
/// <summary>
/// Install the capability on the port
/// </summary>
/// <param name="capability">The capability to install</param>
/// <param name="targetPort">The port on which to install</param>
/// <returns>If the install succeeded</returns>
private bool RemoteInstallCapability(Capability capability, VPort targetPort)
{
VModule targetModule = null;
lock (this)
{
if (registeredPorts.ContainsKey(targetPort))
{
targetModule = registeredPorts[targetPort];
}
}
if (targetModule == null)
{
logger.Log("Platform could not find the target module for port {0}", targetPort.ToString());
return false;
}
ResultCode result = (ResultCode) targetModule.InstallCapability(capability, targetPort);
if (result == ResultCode.Success) {
return true;
}
else
{
logger.Log("RemoteCapabilityInstall failed: {0}", result.ToString());
return false;
}
}
/// <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, RoleSwitchMultiLevel.RoleName) ||
Role.ContainsRole(port, RoleSwitchBinary.RoleName) ||
Role.ContainsRole(port, RoleLightColor.RoleName))
{
if (!registeredSwitches.ContainsKey(port) &&
GetCapabilityFromPlatform(port) != null)
{
var switchType = (Role.ContainsRole(port, RoleSwitchMultiLevel.RoleName)) ? SwitchType.Multi : SwitchType.Binary;
bool colored = Role.ContainsRole(port, RoleLightColor.RoleName);
InitSwitch(port, switchType, colored);
}
}
else if (Role.ContainsRole(port, RoleSpeechReco.RoleName))
{
if (!speechPorts.Contains(port) &&
GetCapabilityFromPlatform(port) != null)
{
speechPorts.Add(port);
logger.Log("SwitchController:{0} added speech port {1}", this.ToString(), port.ToString());
//TODO Call it with phrases we care about - FOR NOW HARD CODED in Kinect driver
// var retVal = Invoke(port, RoleSpeechReco.Instance, RoleSpeechReco.OpSetSpeechPhraseName, new ParamType(ParamType.SimpleType.text, "on"));
//subscribe to speech reco
if (Subscribe(port, RoleSpeechReco.Instance, RoleSpeechReco.OpPhraseRecognizedSubName))
logger.Log("{0} subscribed to port {1}", this.ToString(), port.ToString());
}
}
}
}
/// <summary>
/// Function call to register a port. Called by modules to activate new ports or to register changes in status.
/// </summary>
/// <param name="port"></param>
/// <returns></returns>
public int RegisterPort(VPort port, VModule module)
{
ResultCode result;
lock (this)
{
if (registeredPorts.ContainsKey(port))
{
logger.Log(this + " got registration for an existing port: {0}", port.ToString());
result = ResultCode.Failure;
}
else
{
if (runningModules.ContainsKey(module))
{
registeredPorts[port] = module;
logger.Log(this + " added {0} from {1}", port.ToString(), module.ToString());
result = ResultCode.Success;
}
else
{
logger.Log(this + " got port {0} registeration request from non-existent module {1}", port.ToString(), module.ToString());
result = ResultCode.ModuleNotFound;
}
}
}
if (result == ResultCode.Success)
{
SafeThread newThread = new SafeThread(delegate() {
// System.Threading.Thread.Sleep(Settings.portRegisterDelay);
BroadcastPortRegistration(port, module);
}, "RegisterPort " + port , logger);
newThread.Start();
}
return (int) result;
}
public void SendEchoRequest(VPort port, int counter)
{
try
{
DateTime requestTime = DateTime.Now;
var retVals = Invoke(port, RoleDummy2.Instance, RoleDummy2.OpEchoName, new ParamType(counter));
double diffMs = (DateTime.Now - requestTime).TotalMilliseconds;
if (retVals[0].Maintype() != (int)ParamType.SimpleType.error)
{
int rcvdNum = (int) retVals[0].Value();
logger.Log("echo success to {0} after {1} ms. sent = {2} rcvd = {3}", port.ToString(), diffMs.ToString(), counter.ToString(), rcvdNum.ToString());
}
else
{
logger.Log("echo failure to {0} after {1} ms. sent = {2} error = {3}", port.ToString(), diffMs.ToString(), counter.ToString(), retVals[0].Value().ToString());
}
}
catch (Exception e)
{
logger.Log("Error while calling echo request: {0}", e.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;
}
}
//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);
}
}
}
}
void ForgetSwitch(VPort switchPort)
{
switchFriendlyNames.Remove(switchPort.GetInfo().GetFriendlyName());
registeredSwitches.Remove(switchPort);
logger.Log("{0} removed switch/light port {1}", this.ToString(), switchPort.ToString());
}
/// <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);
}
}
}
else if (!accessibleDummyPorts.Contains(port) &&
Role.ContainsRole(port, RoleDummy.RoleName) &&
GetCapabilityFromPlatform(port) != null)
{
accessibleDummyPorts.Add(port);
logger.Log("{0} added port {1}", this.ToString(), port.ToString());
if (Subscribe(port, RoleDummy.Instance, RoleDummy.OpEchoSubName))
logger.Log("{0} subscribed to port {1}", this.ToString(), port.ToString());
else
logger.Log("failed to subscribe to port {1}", this.ToString(), port.ToString());
}
else if (Role.ContainsRole(port, RoleSwitchMultiLevel.RoleName) ||
Role.ContainsRole(port, RoleSwitchBinary.RoleName) ||
Role.ContainsRole(port, RoleLightColor.RoleName))
{
if (!registeredSwitches.ContainsKey(port) &&
GetCapabilityFromPlatform(port) != null)
{
var switchType = (Role.ContainsRole(port, RoleSwitchMultiLevel.RoleName)) ? SwitchType.Multi : SwitchType.Binary;
bool colored = Role.ContainsRole(port, RoleLightColor.RoleName);
InitSwitch(port, switchType, colored);
}
}
else if (Role.ContainsRole(port, RoleSpeechReco.RoleName))
{
if (!speechPorts.Contains(port) &&
GetCapabilityFromPlatform(port) != null)
{
speechPorts.Add(port);
logger.Log("SwitchController:{0} added speech port {1}", this.ToString(), port.ToString());
//TODO Call it with phrases we care about - FOR NOW HARD CODED in Kinect driver
// var retVal = Invoke(port, RoleSpeechReco.Instance, RoleSpeechReco.OpSetSpeechPhraseName, new ParamType(ParamType.SimpleType.text, "on"));
//subscribe to speech reco
if (Subscribe(port, RoleSpeechReco.Instance, RoleSpeechReco.OpPhraseRecognizedSubName))
logger.Log("{0} subscribed to port {1}", this.ToString(), port.ToString());
}
}
}
}
public override void OnNotification(string roleName, string opName, IList<VParamType> retVals, VPort senderPort)
{
timerCount++;
if (timerCount >= 50)
{
timerCount = 0;
//push_event_check = 0;
/*
if (push_event_check == 1)
{
push_event_check = 2; timerCount = 0;
recordingController = 2;
Console.WriteLine(this.ToString() + " : Stopped Recording");
}*/
}
if (registeredCameras.ContainsKey(senderPort))
{
if (retVals.Count >= 1 && retVals[0].Value() != null)
{
byte[] imageBytes = (byte[])retVals[0].Value();
lock (this)
{
if (recordingController == 1)
{
registeredCameras[senderPort].RecordVideo = true;
recordingController = 0;
}
else if (recordingController == 2)
{
StopRecording(senderPort, true);
recordingController = 0;
}
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());
}
}
else if (accessibleDummyPorts.Contains(senderPort))
{
string message;
lock (this)
{
switch (opName.ToLower())
{
case RoleDummy.OpEchoSubName:
int rcvdNum = (int)retVals[0].Value();
if (rcvdNum == 1)
{
message = "Bluetooth Signal";
if (timer_motion != null)
{
timer_motion.Stop();
timer_stoprecord.Stop();
}
if (timer_bluetooth != null)
{
timer_bluetooth.Stop();
timer_bluetooth.Start();
}
if (push_event_check == 1)
{
push_event_check = 2;
timerCount = 0;
recordingController = 2;
Console.WriteLine(this.ToString() + " : Stopped Recording");
}
}
else if (rcvdNum == 2)
{
message = "Motion Signal";
if (myThread == null)
{
myThread = new Thread(new ThreadStart(SendMail));
myThread.Start();
}
if (smartHome == null)
{
smartHome = new Thread(new ThreadStart(SmartHomeRun));
smartHome.Start();
}
if (timer_bluetooth == null)
{
timer_bluetooth = new System.Timers.Timer();
timer_bluetooth.Interval = 10 * 1000;
timer_bluetooth.Elapsed += new System.Timers.ElapsedEventHandler(timer_bluetooth_Elapsed);
timer_bluetooth.Start();
}
if (timer_motion == null)
{
timer_motion = new System.Timers.Timer();
timer_motion.Interval = 5 * 1000;
timer_motion.Elapsed += new System.Timers.ElapsedEventHandler(timer_motion_Elapsed);
timer_motion.Start();
timer_stoprecord = new System.Timers.Timer();
timer_stoprecord.Interval = 60 * 1000;
timer_stoprecord.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
timer_stoprecord.Start();
}
else
{
timer_motion.Start();
timer_stoprecord.Start();
}
}
else if (rcvdNum == 3)
{
message = "Bluetooth & Motion Siganl";
if (smartHome == null)
{
smartHome = new Thread(new ThreadStart(SmartHomeRun));
smartHome.Start();
}
if (timer_bluetooth == null)
{
timer_bluetooth = new System.Timers.Timer();
timer_bluetooth.Interval = 10 * 1000;
timer_bluetooth.Elapsed += new System.Timers.ElapsedEventHandler(timer_bluetooth_Elapsed);
timer_bluetooth.Start();
}
if (timer_bluetooth != null)
{
timer_bluetooth.Stop();
timer_bluetooth.Start();
}
if (timer_motion != null)
{
timer_motion.Stop();
timer_stoprecord.Stop();
}
if (push_event_check == 1)
{
push_event_check = 2; timerCount = 0;
recordingController = 2;
Console.WriteLine(this.ToString() + " : stopped Recording");
}
}
else if (rcvdNum == 0)
{
message = "Waitting";
smartHome = null;
myThread = null;
}
else
{
message = "error";
}
this.receivedMessageList.Add(message);
Console.WriteLine(message);
break;
default:
message = String.Format("Invalid async operation return {0} from {1}", opName.ToLower(), senderPort.ToString());
logger.Log(message);
break;
}
}
logger.Log("{0} {1}", this.ToString(), message);
}
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;
}
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)
{
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 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);
}
//}
}
}
}
/// <summary>
/// Called when a new port is registered with the platform
/// </summary>
public override void PortRegistered(VPort port)
{
logger.Log("Sensor:{0} got registeration notification for {1}", ToString(), port.ToString());
lock (this)
{
if (!accessibleSensorPorts.Contains(port) &&
GetCapabilityFromPlatform(port) != null &&
(Role.ContainsRole(port, RoleSensor.RoleName) || Role.ContainsRole(port, RoleSensorMultiLevel.RoleName)))
{
accessibleSensorPorts.Add(port);
logger.Log("Sensor:{0} added port {1}", this.ToString(), port.ToString());
if (Role.ContainsRole(port, RoleSensor.RoleName))
{
if (Subscribe(port, RoleSensor.Instance, RoleSensor.OpGetName))
logger.Log("Sensor:{0} subscribed to sensor port {1}", this.ToString(), port.ToString());
else
logger.Log("Sensor:{0} failed to subscribe to sensor port {1}", this.ToString(), port.ToString());
}
if (Role.ContainsRole(port, RoleSensorMultiLevel.RoleName))
{
if (Subscribe(port, RoleSensorMultiLevel.Instance, RoleSensorMultiLevel.OpGetName))
logger.Log("Sensor:{0} subscribed to multi-level sensor port {1}", this.ToString(), port.ToString());
else
logger.Log("Sensor: {0} failed to subscribe to multi-level port {1}", this.ToString(), port.ToString());
}
}
}
}
public override void OnNotification(string roleName, string opName, IList<VParamType> retVals, VPort senderPort)
{
lock (this)
{
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;
}
}
}
