public void onDefault(UdbusMessagePair messageData)
{
foreach (IUdbusMessageVisitor visitor in this.visitors)
{
visitor.onDefault(messageData);
} // Ends loop over visitors
}
public void HandleSignalMessage(UdbusMessagePair messageData)
{
foreach (IHandleDbusSignal handler in this.handlers)
{
handler.HandleSignalMessage(messageData);
}
}
public void onMethodReturn(UdbusMessagePair messageData)
{
foreach (IUdbusMessageVisitor visitor in this.visitors)
{
visitor.onMethodReturn(messageData);
} // Ends loop over visitors
}
public void onError(UdbusMessagePair messageData)
{
foreach (IUdbusMessageVisitor visitor in this.visitors)
{
visitor.onError(messageData);
}
}
protected override void HandleMessage(UdbusMessagePair messageData)
{
if (messageData.Data.reply_serial == this.serialholder.Serial)
{
this.bStop = true;
}
}
/// <summary>
/// Receive a dbus message.
/// </summary>
/// <param name="id">Id of message to receive.</param>
/// <returns>Received message.</returns>
public UdbusMessagePair ReceiveMessage(uint id, out int result)
{
UdbusMessagePair resultData = this.receiverPool.ReceiveMessageData(this.serviceConnectionParams.Connector, id, out result);
this.receiverPool.TracePool();
return(resultData);
}
public static int Visit(int result, UdbusMessagePair messageData, IUdbusMessageVisitor visitor)
{
UdbusMessagePair releaseMessageData;
int visitResult = Visit(result, messageData, visitor, out releaseMessageData);
//releaseMessageData.Dispose();
return(visitResult);
}
internal static int Visit(int result, Udbus.Serialization.NMessageHandle.UdbusMessageHandle msg, IUdbusMessageVisitor visitor, out UdbusMessagePair releaseMessageData)
{
if (result == 0)
{
UdbusMessagePair messageData = new UdbusMessagePair(msg);
result = Visit(result, messageData, visitor, out releaseMessageData);
}
else
{
HandleMessageError(result, visitor, out releaseMessageData);
}
return(result);
}
/// <summary>
/// Call into a visitor, and pass back message data if visitor stops.
/// </summary>
/// <remarks>
/// Note that it is up to calling code to dispose of the message handle,
/// and that if the visitor Stop flag is set the message handle is moved into the out parameter
/// evading disposal.
/// </remarks>
/// <param name="result">Receive result.</param>
/// <param name="messageData">Received message data.</param>
/// <param name="visitor">Visitor to handle message handle.</param>
/// <param name="releaseMessageData">Message data if visitor sets Stop flag.</param>
/// <returns>Receive result.</returns>
public static int Visit(int result, UdbusMessagePair messageData, IUdbusMessageVisitor visitor, out UdbusMessagePair releaseMessageData)
{
releaseMessageData = default(UdbusMessagePair);
if (result == 0) // If got message ok
{
switch ((Udbus.Types.dbus_msg_type)messageData.Data.typefield.type)
{
case Udbus.Types.dbus_msg_type.DBUS_TYPE_METHOD_CALL:
visitor.onMethod(messageData);
break;
case Udbus.Types.dbus_msg_type.DBUS_TYPE_SIGNAL:
visitor.onSignal(messageData);
break;
case Udbus.Types.dbus_msg_type.DBUS_TYPE_METHOD_RETURN:
visitor.onMethodReturn(messageData);
break;
case Udbus.Types.dbus_msg_type.DBUS_TYPE_ERROR:
visitor.onError(messageData);
break;
default:
visitor.onDefault(messageData);
break;
} // Ends switch received message type
if (visitor.Stop) // If stopping
{
// No disposing thanks very much.
//UdbusMessagePair releaseMessageData = messageData.Release();
releaseMessageData = messageData.Release();
//msg.Release();
} // Ends if stopping
} // Ends if got message ok
else // Else failed to get message
{
HandleMessageError(result, visitor);
} // Ends else failed to get message
return(result);
}
public static UdbusMessagePair LoopUdbusFind(Udbus.Serialization.UdbusConnector connector, IUdbusMessageVisitor visitor, System.IO.TextWriter output, System.Threading.WaitHandle stop)
{
output.WriteLine("Looping...");
int r = 0;
UdbusMessagePair result = default(UdbusMessagePair);
while (r == 0 && visitor.Stop == false && stop.WaitOne(0) == false)
{
using (var msg = connector.ReceiveHandle(out r))
{
Visit(r, msg, visitor, out result);
} // Ends using received message
} // Ends loop while getting results and not told to stop
visitor.Reset();
output.WriteLine("Finished looping...");
return(result);
}
public override void onSignal(UdbusMessagePair messageData)
{
const string StorageSpaceLow = "storage_space_low";
if (messageData.Data.method.StartsWith(StorageSpaceLow))
{
Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(messageData.Handle);
Int32 percentage = 0;
int result = reader.ReadInt32(out percentage);
if (result != 0)
{
this.dumpError(messageData, "Reading percentage from storage space low signal");
}
else
{
this.dumpStuff(messageData, string.Format("Signal. Left {0}%", percentage));
}
}
else
{
base.onSignal(messageData);
}
}
public UdbusMessagePair Clone()
{
UdbusMessagePair clone = new UdbusMessagePair(this);
return(clone);
}
public virtual void onDefault(UdbusMessagePair messageData)
{
this.dumpStuff(messageData, "Dunno");
}
public virtual void onMethodReturn(UdbusMessagePair messageData)
{
this.dumpStuff(messageData, "Method Return");
}
virtual protected void dumpError(UdbusMessagePair messageData, string description)
{
this.dDumpError(messageData, "Error: " + description);
}
public void onError(UdbusMessagePair messageData)
{
}
virtual protected void dumpStuff(UdbusMessagePair messageData, string description)
{
this.dDump(messageData, description);
}
public void onDefault(UdbusMessagePair messageData)
{
}
public virtual void onSignal(UdbusMessagePair messageData)
{
this.dumpStuff(messageData, "Signal");
}
abstract protected void HandleMessage(UdbusMessagePair messageData);
public void onError(UdbusMessagePair messageData)
{
this.dumpStuff(messageData, "Error message");
}
public virtual void onSignal(UdbusMessagePair messageData)
{
this.HandleMessage(messageData);
}
public void onResultError(int error)
{
UdbusMessagePair errordata = new UdbusMessagePair();
this.dDumpError(errordata, string.Format("Error result: {0}", error));
}
public virtual void onMethodReturn(UdbusMessagePair messageData)
{
this.HandleMessage(messageData);
}
protected override void HandleMessage(UdbusMessagePair messageData)
{
this.stop = true;
}
public void onError(UdbusMessagePair messageData)
{
this.HandleMessage(messageData);
}
public void HandleSignalMessage(UdbusMessagePair messageData)
{
}
public virtual void onDefault(UdbusMessagePair messageData)
{
this.HandleMessage(messageData);
}
public void HandleSignalMessage(UdbusMessagePair messageData)
{
this.writemessage(messageData.Data.ToString());
}
private UdbusMessagePair(UdbusMessagePair source)
: this(source.Handle, source.data)
{
}