public MethodCallResult DeserializeResult(Stream stream, Type expectedType)
{
var reader = XmlReader.Create(stream);
while (reader.NodeType != XmlNodeType.Element)
{
reader.Read();
}
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
}
var rv = new MethodCallResult();
if (reader.Name == "Exception")
{
rv.Exception = reader.ReadElementContentAsString();
}
else if (reader.Name == "Object")
{
var ser = Cache.GetContext()[expectedType];
rv.Result = ((ISerializable)ser.Serializer.Deserialize(reader)).Value;
}
return(rv);
}
private void OnMethodCallResult(MethodCallResult message)
{
if (!this.messageRegister.TryGetValue(message.CallId, out var taskCompletionSource))
{
return;
}
taskCompletionSource.SetResult(message);
this.messageRegister.Remove(message.CallId);
}
public MethodCallResult DeserializeResult(Stream stream, Type expectedType)
{
var reader = CreateReader(stream);
reader.MoveToContent();
var rv = new MethodCallResult();
if (reader.Value.ToString() == "Result")
{
rv.Result = _serializer.Deserialize(reader.Next(), expectedType);
reader.Next();
}
else
{
rv.Exception = reader.ReadProperty("Exception").ToString();
}
reader.MoveToEnd();
return(rv);
}
internal AbstractMethodCallBuilder(LambdaExpression expression)
{
this.methodCallExpression = MethodCallParser.Parse(expression);
}
/// <summary>
/// Run the client stress op which stresses the bus attachment in a client type
/// configuration which find the well-known service name and calls the 'cat'
/// method
/// </summary>
/// <param name="isMultipoint">True if operation uses multipoint sessions</param>
private void RunClient(bool isMultipoint)
{
try
{
ClientBusListener clientBusListener = new ClientBusListener(this.busAtt, this, this.foundName);
this.busAtt.FindAdvertisedName(ServiceName);
this.DebugPrint("Looking for WKN : " + ServiceName);
this.foundName.WaitOne(12000);
SessionOpts optsIn = new SessionOpts(
TrafficType.TRAFFIC_MESSAGES,
isMultipoint,
ProximityType.PROXIMITY_ANY,
TransportMaskType.TRANSPORT_ANY);
SessionOpts[] optsOut = new SessionOpts[1];
Task <JoinSessionResult> joinTask = this.busAtt.JoinSessionAsync(
this.DiscoveredName,
ServicePort,
(SessionListener)clientBusListener,
optsIn,
optsOut,
null).AsTask <JoinSessionResult>();
joinTask.Wait();
JoinSessionResult joinResult = joinTask.Result;
QStatus status = joinResult.Status;
ProxyBusObject proxyBusObj = null;
if (QStatus.ER_OK == status)
{
this.DebugPrint("JoinSession with " + this.DiscoveredName + " was successful (sessionId=" + joinResult.SessionId + ")");
proxyBusObj = new ProxyBusObject(this.busAtt, this.DiscoveredName, ServicePath, joinResult.SessionId);
Task <IntrospectRemoteObjectResult> introTask = proxyBusObj.IntrospectRemoteObjectAsync(null).AsTask <IntrospectRemoteObjectResult>();
introTask.Wait();
IntrospectRemoteObjectResult introResult = introTask.Result;
status = introResult.Status;
if (QStatus.ER_OK == status)
{
this.DebugPrint("Introspection of the service was successfull");
MsgArg hello = new MsgArg("s", new object[] { "Hello " });
MsgArg world = new MsgArg("s", new object[] { "World!" });
InterfaceMember catMethod = proxyBusObj.GetInterface(InterfaceName).GetMethod("cat");
byte flags = (byte)0;
Task <MethodCallResult> catTask = proxyBusObj.MethodCallAsync(catMethod, new MsgArg[] { hello, world }, null, 5000, flags).AsTask <MethodCallResult>();
catTask.Wait();
MethodCallResult catResult = catTask.Result;
if (catResult.Message.Type == AllJoynMessageType.MESSAGE_METHOD_RET)
{
this.DebugPrint(this.DiscoveredName + ".cat ( path=" + ServicePath + ") returned \"" + catResult.Message.GetArg(0).Value.ToString() + "\"");
}
else
{
this.DebugPrint("Method call on " + this.DiscoveredName + ".cat failed (ReturnType=" + catResult.Message.Type.ToString() + ")");
}
}
else
{
this.DebugPrint("Introspection was unsuccessful: " + status.ToString());
}
}
else
{
this.DebugPrint("Join Session was unsuccessful: " + status.ToString());
}
this.busAtt.CancelFindAdvertisedName(ServiceName);
this.busAtt.UnregisterBusListener(clientBusListener);
this.DebugPrint("Successfully unraveled the client operation");
}
catch (ArgumentNullException ex)
{
this.DebugPrint(">>>> TIMEOUT, Client could not find WKN >>>>");
}
catch (Exception ex)
{
var errMsg = AllJoynException.GetErrorMessage(ex.HResult);
this.DebugPrint(">>>> Client Execution Error >>>> " + errMsg);
}
}
/// <summary>
/// This method is called when the advertised name is found.
/// </summary>
/// <param name="wellKnownName">A well known name that the remote bus is advertising.</param>
/// <param name="transportMask">Transport that received the advertisement.</param>
/// <param name="namePrefix">The well-known name prefix used in call to FindAdvertisedName that triggered this callback.</param>
private async void FoundAdvertisedName(string wellKnownName, TransportMaskType transportMask, string namePrefix)
{
if (!string.IsNullOrEmpty(wellKnownName) && wellKnownName.CompareTo(App.ServiceName) == 0)
{
string foundIt = string.Format(
"Client found advertised name '{0}' on {1}.",
wellKnownName,
transportMask.ToString());
App.OutputLine(foundIt);
// We found a remote bus that is advertising the well-known name so connect to it.
bool result = await this.JoinSessionAsync();
if (result)
{
InterfaceDescription secureInterface = this.Bus.GetInterface(App.InterfaceName);
this.ProxyObject = new ProxyBusObject(this.Bus, App.ServiceName, App.ServicePath, 0);
this.ProxyObject.AddInterface(secureInterface);
MsgArg[] inputs = new MsgArg[1];
inputs[0] = new MsgArg("s", new object[] { "Client says Hello AllJoyn!" });
MethodCallResult callResults = null;
try
{
callResults = await this.ProxyObject.MethodCallAsync(App.InterfaceName, "Ping", inputs, null, 5000, 0);
}
catch (Exception ex)
{
const string ErrorFormat =
"ProxyObject.MethodCallAsync(\"Ping\") call produced error(s). QStatus = 0x{0:X} ('{1}').";
QStatus status = AllJoynException.GetErrorCode(ex.HResult);
string error = string.Format(ErrorFormat, status, status.ToString());
System.Diagnostics.Debug.WriteLine(error);
App.OutputLine(error);
}
if (callResults != null)
{
Message mess = callResults.Message;
AllJoynMessageType messType = mess.Type;
if (messType == AllJoynMessageType.MESSAGE_METHOD_RET)
{
string strRet = mess.GetArg(0).Value as string;
if (!string.IsNullOrEmpty(strRet))
{
string output = string.Format(
"{0}.Ping (path = {1}) returned \"{2}\"",
App.InterfaceName,
App.ServicePath,
strRet);
App.OutputLine(output);
}
else
{
const string Error =
"Error: Server returned null or empty string in response to ping.";
App.OutputLine(Error);
System.Diagnostics.Debug.WriteLine(Error);
}
}
else
{
string error =
string.Format("Server returned message of type '{0}'.", messType.ToString());
App.OutputLine(error);
System.Diagnostics.Debug.WriteLine(error);
}
}
}
}
}
/// <summary>
/// Connects to the bus, finds the service and calls the 'cat' with the two
/// arguments "Hello " and "World!"
/// </summary>
/// <param name="sender">UI control which signaled the click event</param>
/// <param name="e">arguments associated with the click event</param>
private void Button_RunClick(object sender, RoutedEventArgs e)
{
if (!runningClient)
{
Task task = new Task(async() =>
{
try
{
runningClient = true;
busAtt = new BusAttachment("ClientApp", true, 4);
this.OutputLine("BusAttachment Created.");
BasicClientBusListener basicClientBusListener = new BasicClientBusListener(busAtt, foundNameEvent);
busAtt.RegisterBusListener(basicClientBusListener);
this.OutputLine("BusListener Registered.");
/* Create and register the bundled daemon. The client process connects to daemon over tcp connection */
busAtt.Start();
await busAtt.ConnectAsync(BasicClientGlobals.ConnectSpec);
this.OutputLine("Bundled Daemon Registered.");
this.OutputLine("BusAttachment Connected to " + BasicClientGlobals.ConnectSpec + ".");
busAtt.FindAdvertisedName(BasicClientGlobals.WellKnownServiceName);
foundNameEvent.WaitOne();
/* Configure session properties and request a session with device with wellKnownName */
SessionOpts sessionOpts = new SessionOpts(
BasicClientGlobals.SessionProps.TrType,
BasicClientGlobals.SessionProps.IsMultiPoint,
BasicClientGlobals.SessionProps.PrType,
BasicClientGlobals.SessionProps.TmType);
SessionOpts[] sOptsOut = new SessionOpts[1];
JoinSessionResult joinResults = await busAtt.JoinSessionAsync(
BasicClientGlobals.WellKnownServiceName,
BasicClientGlobals.SessionProps.SessionPort,
basicClientBusListener,
sessionOpts,
sOptsOut,
null);
QStatus status = joinResults.Status;
if (QStatus.ER_OK != status)
{
this.OutputLine("Joining a session with the Service was unsuccessful.");
}
else
{
this.OutputLine("Join Session was successful (sessionId=" + joinResults.SessionId + ").");
}
// Create the proxy for the service interface by introspecting the service bus object
ProxyBusObject proxyBusObject = new ProxyBusObject(busAtt, BasicClientGlobals.WellKnownServiceName, BasicClientGlobals.ServicePath, 0);
if (QStatus.ER_OK == status)
{
IntrospectRemoteObjectResult introResult = await proxyBusObject.IntrospectRemoteObjectAsync(null);
status = introResult.Status;
if (QStatus.ER_OK != status)
{
this.OutputLine("Introspection of the service bus object failed.");
}
else
{
this.OutputLine("Introspection of the service bus object was successful.");
}
}
if (QStatus.ER_OK == status)
{
// Call 'cat' method with the two string to be concatenated ("Hello" and " World!")
MsgArg[] catMe = new MsgArg[2];
catMe[0] = new MsgArg("s", new object[] { "Hello" });
catMe[1] = new MsgArg("s", new object[] { " World!" });
InterfaceDescription interfaceDescription = proxyBusObject.GetInterface(BasicClientGlobals.InterfaceName);
InterfaceMember interfaceMember = interfaceDescription.GetMember("cat");
this.OutputLine("Calling the 'cat' method of the service with args 'Hello' and ' World!'");
MethodCallResult callResults = await proxyBusObject.MethodCallAsync(interfaceMember, catMe, null, 100000, 0);
Message msg = callResults.Message;
if (msg.Type == AllJoynMessageType.MESSAGE_METHOD_RET)
{
string strRet = msg.GetArg(0).Value as string;
this.OutputLine("Sender '" + msg.Sender + "' returned the value '" + strRet + "'");
}
else
{
this.OutputLine("The 'cat' method call produced errors of type: " + msg.Type.ToString());
}
}
TearDown();
}
catch (Exception ex)
{
QStatus s = AllJoynException.GetErrorCode(ex.HResult);
}
});
task.Start();
}
}
