/// <summary> /// Initializes a new instance of the Client class. /// </summary> /// <param name="name">The name of the client application.</param> /// <param name="pinReady">The event to communicate there is a pin waiting.</param> public Client(string name, AutoResetEvent pinReady) { this.PinReady = pinReady; // Create the BusAttachment and other prep for accepting input from the client(s). this.ConnectBus = new Task(() => { try { this.InitializeAllJoyn(name); App app = Windows.UI.Xaml.Application.Current as App; app.Bus = this.Bus; } catch (Exception ex) { const string ErrorFormat = "Bus intialization for client produced error(s). QStatus = 0x{0:X}."; QStatus status = AllJoynException.GetErrorCode(ex.HResult); string error = string.Format(ErrorFormat, status); System.Diagnostics.Debug.WriteLine(error); App.OutputLine(error); } }); this.ConnectBus.Start(); }
/// <summary> /// Advertise the well known name 'name' for client to discover /// </summary> /// <param name="name">Well known name to advertise</param> /// <param name="transport">Transport type for which to advertise the name over</param> public void DoAdvertise(string name, TransportMaskType transport) { try { lock (this.requestedNames) { if (this.requestedNames.Contains(name)) { this.busAtt.AdvertiseName(name, transport); lock (this.advertisedNames) { this.advertisedNames.Add(name); } } else { this.mainPage.Output(name + " must first be requested from the bus before it can be advertised"); } } } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("BusAttachment.AdvertiseName(" + name + ", " + (uint)transport + ") failed: " + errMsg); } }
/// <summary> /// Initialize the AllJoyn portions of the application. /// </summary> private void InitializeAllJoyn() { Task t1 = new Task(() => { try { Debug.UseOSLogging(true); //Debug.SetDebugLevel("ALL", 1); //Debug.SetDebugLevel("ALLJOYN", 7); bus = new BusAttachment(ApplicationName, true, 4); bus.Start(); const string connectSpec = "null:"; bus.ConnectAsync(connectSpec).AsTask().Wait(); DisplayStatus("Connected to AllJoyn successfully."); busListeners = new Listeners(bus, this); bus.RegisterBusListener(busListeners); chatService = new ChatSessionObject(bus, ObjectPath, this); bus.RegisterBusObject(chatService); bus.FindAdvertisedName(NamePrefix); } catch (Exception ex) { QStatus stat = AllJoynException.GetErrorCode(ex.HResult); string errMsg = AllJoynException.GetErrorMessage(ex.HResult); DisplayStatus("InitializeAllJoyn Error : " + errMsg); } }); t1.Start(); }
private void RxLoop() { Task rxLoopTask = new Task(() => { try { while (_running) { byte[] buf = new byte[2048]; int[] received = new int[1]; // sockstream is blocking _sockStream.Recv(buf, buf.Length, received); if (received[0] >= 0) { _rxCount += received[0]; // TODO write to file } else { break; } } } catch (Exception e) { var m = AllJoynException.GetErrorMessage(e.HResult); var h = AllJoynException.GetErrorCode(e.HResult); } }); rxLoopTask.Start(); }
/// <summary> /// Run the default stress op which stresses the bus attachment /// </summary> private void RunDefault() { try { BusListener busListener = new BusListener(this.busAtt); this.busAtt.RegisterBusListener(busListener); BusObject busObject = new BusObject(this.busAtt, "/default", false); this.busAtt.RegisterBusObject(busObject); this.DebugPrint("Registered BusListener and BusObject"); uint flags = (uint)(RequestNameType.DBUS_NAME_REPLACE_EXISTING | RequestNameType.DBUS_NAME_DO_NOT_QUEUE); string randServiceName = null; lock (rand) { randServiceName = ServiceName + ".n" + rand.Next(10000000); } this.busAtt.RequestName(randServiceName, flags); this.busAtt.AdvertiseName(randServiceName, TransportMaskType.TRANSPORT_ANY); this.DebugPrint("Advertising WKN : " + randServiceName); this.busAtt.CancelAdvertiseName(randServiceName, TransportMaskType.TRANSPORT_ANY); this.busAtt.ReleaseName(randServiceName); this.busAtt.UnregisterBusListener(busListener); this.busAtt.UnregisterBusObject(busObject); this.DebugPrint("Successfully unraveled the default operation"); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.DebugPrint(">>>> Default Execution Error >>>> : " + errMsg); } }
async void InitializeAllJoyn() { Debug.UseOSLogging(true); Debug.SetDebugLevel("ALLJOYN", 7); _bus = new BusAttachment(APPLICATION_NAME, true, 4); string connectSpec = "null:"; _bus.Start(); try { _mp3Reader = new MP3Reader(); if (_streamingSong != null) { _streamingSongBasicProperties = await _streamingSong.GetBasicPropertiesAsync(); if (_streamingSongBasicProperties != null) { _streamingSongMusicProperties = await _streamingSong.Properties.GetMusicPropertiesAsync(); if (_streamingSongMusicProperties != null) { await _mp3Reader.SetFileAsync(_streamingSong); _bus.ConnectAsync(connectSpec).AsTask().Wait(); _connected = true; _listeners = new Listeners(_bus, this); _bus.RegisterBusListener(_listeners); _mediaSource = new MediaSource(_bus); _audioStream = new AudioStream(_bus, "mp3", _mp3Reader, 100, 1000); _mediaSource.AddStream(_audioStream); /* Register MediaServer bus object */ _bus.RegisterBusObject(_mediaSource.MediaSourceBusObject); /* Request a well known name */ _bus.RequestName(MediaServerName, (int)(RequestNameType.DBUS_NAME_REPLACE_EXISTING | RequestNameType.DBUS_NAME_DO_NOT_QUEUE)); /* Advertise name */ _bus.AdvertiseName(MediaServerName, TransportMaskType.TRANSPORT_ANY); /* Bind a session for incoming client connections */ SessionOpts opts = new SessionOpts(TrafficType.TRAFFIC_MESSAGES, true, ProximityType.PROXIMITY_ANY, TransportMaskType.TRANSPORT_ANY); ushort[] portOut = new ushort[1]; _bus.BindSessionPort(SESSION_PORT, portOut, opts, _listeners); } } } } catch (Exception ex) { string message = ex.Message; QStatus status = AllJoynException.GetErrorCode(ex.HResult); string errMsg = AllJoynException.GetErrorMessage(ex.HResult); } }
/// <summary> /// connects with the bus, creates an interface and advertises a well-known name for /// clients to join a session with. /// </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 (busObject == null && busAtt == null) { Task task = new Task(async() => { try { busAtt = new BusAttachment("SignalServiceApp", true, 4); busObject = new SignalServiceBusObject(busAtt); OutputLine("BusObject Created."); busListener = new SignalServiceBusListener(busAtt); OutputLine("BusAttachment and BusListener Created."); busAtt.RegisterBusListener(busListener); OutputLine("BusListener Registered."); busAtt.Start(); await busAtt.ConnectAsync(SignalServiceGlobals.ConnectSpec); OutputLine("Bundled Daemon Registered."); OutputLine("BusAttachment Connected to " + SignalServiceGlobals.ConnectSpec + "."); SessionOpts sessionOpts = new SessionOpts( SignalServiceGlobals.SessionProps.TrType, SignalServiceGlobals.SessionProps.IsMultiPoint, SignalServiceGlobals.SessionProps.PrType, SignalServiceGlobals.SessionProps.TmType); try { ushort[] portOut = new ushort[1]; busAtt.BindSessionPort(SignalServiceGlobals.SessionProps.SessionPort, portOut, sessionOpts, busListener); busAtt.RequestName(SignalServiceGlobals.WellKnownServiceName, (int)RequestNameType.DBUS_NAME_DO_NOT_QUEUE); busAtt.AdvertiseName(SignalServiceGlobals.WellKnownServiceName, TransportMaskType.TRANSPORT_ANY); OutputLine("Name is Being Advertised as: " + SignalServiceGlobals.WellKnownServiceName); } catch (COMException ce) { QStatus s = AllJoynException.GetErrorCode(ce.HResult); OutputLine("Errors were produced while establishing the service."); TearDown(); } } catch (Exception ex) { OutputLine("Errors occurred while setting up the service."); QStatus status = AllJoynException.GetErrorCode(ex.HResult); busObject = null; busAtt = null; } }); task.Start(); } }
/// <summary> /// Set the specified AllJoyn module to the specified level /// </summary> /// <param name="moduleName">AllJoyn module name</param> /// <param name="level">Debug level</param> public void DoDebug(string moduleName, uint level) { try { AllJoyn.Debug.SetDebugLevel(moduleName.ToUpper(), level); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("AllJoyn.Debug.SetDebugLevel(" + moduleName + ", " + level + ") failed: " + errMsg); } }
/// <summary> /// Cancel the previously started find advertised name action of namePrefix /// </summary> /// <param name="namePrefix">Name prefix of advertised name</param> public void DoCancelFind(string namePrefix) { try { this.busAtt.CancelFindAdvertisedName(namePrefix); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("BusAttachment.CancelFindAdvertisedName(" + namePrefix + ") failed: " + errMsg); } }
/// <summary> /// Sends a 'Chat' signal using the specified parameters /// </summary> /// <param name="filter">filter to use </param> public void AddRule(string filter) { try { this.busObject.Bus.AddMatch(filter); } catch (Exception ex) { QStatus status = AllJoynException.GetErrorCode(ex.HResult); string errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.sessionOps.Output("adding a rule failed: " + errMsg); } }
/// <summary> /// Sends a 'Chat' signal using the specified parameters /// </summary> /// <param name="sessionId">A unique SessionId used to contain the signal</param> /// <param name="msg">Message that will be sent over the 'Chat' signal</param> /// <param name="flags">Flags for the signal</param> /// <param name="ttl">Time To Live for the signal</param> public void SendChatSignal(uint sessionId, string msg, byte flags, ushort ttl) { try { MsgArg msgArg = new MsgArg("s", new object[] { msg }); this.busObject.Signal(string.Empty, sessionId, this.chatSignal, new MsgArg[] { msgArg }, ttl, flags); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.sessionOps.Output("Sending Chat Signal failed: " + errMsg); } }
/// <summary> /// Run the service stress op which stresses the bus attachment in a service type /// configuration by advertising a well known name which an implementation of the /// 'cat' method /// </summary> /// <param name="isMultipoint">True if operation uses multipoint sessions</param> private void RunService(bool isMultipoint) { try { ServiceBusListener serviceBusListener = new ServiceBusListener(this.busAtt, this); ServiceBusObject serviceBusObject = new ServiceBusObject(this.busAtt, this); this.DebugPrint("Registered the Service BusListener and BusObject"); uint flags = (uint)(RequestNameType.DBUS_NAME_REPLACE_EXISTING | RequestNameType.DBUS_NAME_DO_NOT_QUEUE); string randServiceName = null; lock (rand) { randServiceName = ServiceName + ".n" + rand.Next(10000000); } this.busAtt.RequestName(randServiceName, flags); SessionOpts optsIn = new SessionOpts( TrafficType.TRAFFIC_MESSAGES, isMultipoint, ProximityType.PROXIMITY_ANY, TransportMaskType.TRANSPORT_ANY); ushort[] portOut = new ushort[1]; this.busAtt.BindSessionPort(ServicePort, portOut, optsIn, (SessionPortListener)serviceBusListener); this.busAtt.AdvertiseName(randServiceName, TransportMaskType.TRANSPORT_ANY); this.DebugPrint("Advertising WKN : " + randServiceName); int wait = 0; lock (rand) { wait = 8000 + rand.Next(6000); } Task.Delay(wait).AsAsyncAction().AsTask().Wait(); this.DebugPrint("Unraveling the service opertaion"); this.busAtt.CancelAdvertiseName(randServiceName, TransportMaskType.TRANSPORT_ANY); this.busAtt.UnbindSessionPort(ServicePort); this.busAtt.ReleaseName(randServiceName); this.busAtt.UnregisterBusObject((BusObject)serviceBusObject); this.busAtt.UnregisterBusListener((BusListener)serviceBusListener); this.DebugPrint("Successfully unraveled the service opertaion"); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.DebugPrint(">>>> Service Exectution Execution Error >>>> : " + errMsg); } }
/// <summary> /// This method sends the current message to the chat service for delivery to the remote device. /// </summary> /// <param name="id">The session ID associated with this message.</param> /// <param name="message">The actual message being sent.</param> private void SendMyMessage(uint id, string message) { try { this.OnChat(this.SessionId, "Me : ", message); this.chatService.SendChatSignal(this.SessionId, message); this.MessageBox.Text = string.Empty; } catch (Exception ex) { QStatus stat = AllJoynException.GetErrorCode(ex.HResult); string errMsg = AllJoynException.GetErrorMessage(ex.HResult); DisplayStatus("SendMessage Error : " + errMsg); } }
/// <summary> /// Request the well known name 'name' from the bus /// </summary> /// <param name="name">Well known name to request</param> public void DoRequestName(string name) { try { this.busAtt.RequestName(name, (uint)RequestNameType.DBUS_NAME_DO_NOT_QUEUE); lock (this.requestedNames) { this.requestedNames.Add(name); } } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("BusAttachment.RequestName(" + name + ") failed: " + errMsg); } }
/// <summary> /// Unbind the session port previously bound /// </summary> /// <param name="port">Bound session port number</param> public void DoUnbind(uint port) { try { this.busAtt.UnbindSessionPort((ushort)port); lock (this.sessionPortMap) { this.sessionPortMap.Remove(port); } } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("BusAttachment.UnbindSessionPort(" + port + ") failed: " + errMsg); } }
public void SayHiHandler(InterfaceMember member, Message message) { Assert.AreEqual("hello", message.GetArg(0).Value.ToString()); MsgArg retArg = new MsgArg("s", new object[] { "aloha" }); try { // BUGBUG: Throws exception saying signature of the msgArg is not what was expected, but its correct. this.busObject.MethodReplyWithQStatus(message, QStatus.ER_OK); } catch (Exception ex) { string err = AllJoynException.GetExceptionMessage(ex.HResult); Assert.IsFalse(true); } }
/// <summary> /// Leave the currently active chat session. /// </summary> private void LeaveChannel() { try { this.bus.LeaveSession(this.SessionId); this.DisplayStatus("Leave chat session " + this.SessionId + " successfully"); } catch (Exception ex) { QStatus stat = AllJoynException.GetErrorCode(ex.HResult); string errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.DisplayStatus("Leave chat session " + this.SessionId + " failed: " + errMsg); } this.SessionId = 0; }
/// <summary> /// Release well known name previously obtained through request name call /// </summary> /// <param name="name">Well Known name to release</param> public void DoReleaseName(string name) { try { this.busAtt.ReleaseName(name); lock (this.requestedNames) { this.requestedNames.Remove(name); } } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("BusAttachment.ReleaseName(" + name + ") failed: " + errMsg); } }
/// <summary> /// Concatenate the two string arguments and return the result to the caller /// </summary> /// <param name="member">Method interface member entry.</param> /// <param name="message">The received method call message containing the two strings /// to concatenate</param> public void Cat(InterfaceMember member, Message message) { try { string arg1 = message.GetArg(0).Value as string; string arg2 = message.GetArg(1).Value as string; MsgArg retArg = new MsgArg("s", new object[] { arg1 + arg2 }); this.busObject.MethodReply(message, new MsgArg[] { retArg }); this.DebugPrint("Method Reply successful (ret=" + arg1 + arg2 + ")"); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.DebugPrint("Method Reply unsuccessful: " + errMsg); } }
/// <summary> /// Do the work of joining a session. /// </summary> /// <param name="folder">The folder to put the received file in.</param> /// <returns>true if all the input variables look good.</returns> public bool StartJoinSessionTask(StorageFolder folder) { bool returnValue = false; this.Folder = folder; if (null != this.Bus && null != this.Folder) { Task task = new Task(async() => { try { if (0 != this.SessionId) { this.Bus.LeaveSession(this.SessionId); } this.lastIndex = 0; this.CreateInterfaceAndBusObject(); this.AddSignalHandler(); // We found a remote bus that is advertising the well-known name so connect to it. bool result = await this.JoinSessionAsync(); if (result) { App.OutputLine("Successfully joined session."); } } catch (Exception ex) { QStatus status = AllJoynException.GetErrorCode(ex.HResult); string message = string.Format( "Errors were produced while establishing the application '{0}' (0x{0:X}).", status.ToString(), status); App.OutputLine(message); } }); task.Start(); returnValue = true; } return(returnValue); }
/// <summary> /// Bind the session port /// </summary> /// <param name="port">Port number to bind</param> /// <param name="opts">Session options for binding the port</param> public void DoBind(uint port, SessionOpts opts) { try { ushort[] sessionPortOut = new ushort[1]; this.busAtt.BindSessionPort((ushort)port, sessionPortOut, opts, (SessionPortListener)this.busListener); lock (this.sessionPortMap) { this.sessionPortMap.Add(port, new SessionPortInfo(port, this.busAtt.UniqueName, opts)); } } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("BusAttachment.BindSessionPort for port " + port + " failed: " + errMsg); } }
/// <summary> /// Shut down the hosted channel. /// </summary> private void StopChannel() { try { var wellKnownName = this.MakeWellKnownName(this.channelHosted); this.bus.CancelAdvertiseName(wellKnownName, alljoynTransports); this.bus.UnbindSessionPort(ContactPort); this.bus.ReleaseName(wellKnownName); this.Channels.Remove(this.channelHosted); this.channelHosted = null; } catch (Exception ex) { QStatus stat = AllJoynException.GetErrorCode(ex.HResult); string errMsg = AllJoynException.GetErrorMessage(ex.HResult); DisplayStatus("StopChannel Error : " + errMsg); } }
/// <summary> /// Add the session details to the session port and session maps /// </summary> /// <param name="port">Port used by the session</param> /// <param name="sessionId">Session Id for the joined session</param> /// <param name="joiner">Device/Endpoint joining the session</param> public void SessionJoined(ushort port, uint sessionId, string joiner) { lock (this.sessionPortMap) { if (this.sessionPortMap.ContainsKey(port)) { try { this.busAtt.SetSessionListener(sessionId, (SessionListener)this.busListener); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("BusAttachment.SetSessionListener(" + sessionId + ", ...) failed: " + errMsg); } lock (this.sessionMap) { if (!this.sessionMap.ContainsKey(sessionId)) { this.sessionMap.Add(sessionId, new SessionInfo(sessionId, this.sessionPortMap[port])); } this.sessionMap[sessionId].AddPeer(joiner); } this.mainPage.Output("SessionJoined with " + joiner + " (sessionId=" + sessionId + ")"); } else { this.mainPage.Output("Leaving unexpected session " + sessionId + " with " + joiner); try { this.busAtt.LeaveSession(sessionId); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("BusAttachment.LeaveSession(" + sessionId + ") failed: " + errMsg); } } } }
/// <summary> /// Run the stress operation by setting up alljoyn, running the specified stress /// operation then tearing down alljoyn. /// </summary> /// <param name="stressType">Type of stress operation to run</param> /// <param name="manager">Stress manager which is managing this task</param> /// <param name="isMultipoint">True if operation uses multipoint sessions</param> public void Start(StressType stressType, StressManager manager, bool isMultipoint) { this.stressManager = manager; try { // Set up alljoyn this.DebugPrint("Creating and Starting the bus attachment"); this.busAtt = new BusAttachment("BusStress", true, 4); this.busAtt.Start(); this.busAtt.ConnectAsync(ConnectSpecs).AsTask().Wait(); this.DebugPrint("Successfully connected to the bundled daemon"); // Run the stress operation if (stressType == StressType.Default) { this.RunDefault(); } else if (stressType == StressType.Service) { this.RunService(isMultipoint); } else { this.foundName = new AutoResetEvent(false); this.RunClient(isMultipoint); } // Tear down alljoyn this.DebugPrint("Disconnecting and stopping the bus attachment"); this.busAtt.DisconnectAsync(ConnectSpecs).AsTask().Wait(); this.busAtt.StopAsync().AsTask().Wait(); this.DebugPrint("Successfully disconnected and stopped the bus attachment"); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.DebugPrint(">>>> BusAttachment Error >>>> : " + errMsg); } this.busAtt = null; }
/// <summary> /// Start up the channel we are hosting. /// </summary> /// <param name="name">The name, minus the name prefix, for the channel we are hosting.</param> private void StartChannel(string name) { try { this.channelHosted = name; string wellKnownName = this.MakeWellKnownName(name); this.bus.RequestName(wellKnownName, (int)RequestNameType.DBUS_NAME_DO_NOT_QUEUE); this.bus.AdvertiseName(wellKnownName, alljoynTransports); ushort[] portOut = new ushort[1]; SessionOpts opts = new SessionOpts(TrafficType.TRAFFIC_MESSAGES, true, ProximityType.PROXIMITY_ANY, alljoynTransports); this.bus.BindSessionPort(ContactPort, portOut, opts, this.busListeners); DisplayStatus("Start Chat channel " + name + " successfully"); } catch (Exception ex) { QStatus stat = AllJoynException.GetErrorCode(ex.HResult); string errMsg = AllJoynException.GetErrorMessage(ex.HResult); DisplayStatus("StartChannel Error : " + errMsg); } }
/// <summary> /// Cancel advertising the well known name 'name' /// </summary> /// <param name="name">Well known name currently being advertised</param> /// <param name="transport">Transport type which 'name' is being advertised over</param> public void DoCancelAdvertise(string name, TransportMaskType transport) { try { lock (this.advertisedNames) { if (this.advertisedNames.Contains(name)) { this.busAtt.CancelAdvertiseName(name, transport); this.advertisedNames.Remove(name); } else { this.mainPage.Output(name + " is not currently being advertised"); } } } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("BusAttachment.CancelAdvertiseName(" + name + ", " + (uint)transport + ") failed: " + errMsg); } }
/// <summary> /// Join an existing channel with the given name. /// </summary> /// <param name="name">The name of the channel to join.</param> private async void JoinChannel(string name) { try { this.DisplayStatus("Joining chat session: " + name); string wellKnownName = this.MakeWellKnownName(name); SessionOpts opts = new SessionOpts(TrafficType.TRAFFIC_MESSAGES, true, ProximityType.PROXIMITY_ANY, alljoynTransports); SessionOpts[] opts_out = new SessionOpts[1]; this.channelJoined = name; JoinSessionResult result = await this.bus.JoinSessionAsync( wellKnownName, ContactPort, this.busListeners, opts, opts_out, null); if (result.Status == QStatus.ER_OK) { this.SessionId = result.SessionId; this.DisplayStatus("Join chat session " + this.SessionId + " successfully"); await this.coreDispatcher.RunAsync( CoreDispatcherPriority.Normal, () => { this.JoinChannelButton.Content = "Leave Channel"; }); } else { this.DisplayStatus("Join chat session " + result.SessionId + " failed. Error: " + result.Status); } } catch (Exception ex) { QStatus stat = AllJoynException.GetErrorCode(ex.HResult); string errMsg = AllJoynException.GetErrorMessage(ex.HResult); DisplayStatus("JoinChannel Error : " + errMsg); } }
private void InitializeAllJoyn() { Task _t1 = new Task(() => { Debug.UseOSLogging(true); //Debug.SetDebugLevel("ALLJOYN", 7); string connectSpec = "null:"; try { _bus = new BusAttachment(APPLICATION_NAME, true, 4); } catch (Exception ex) { QStatus stat = AllJoynException.GetErrorCode(ex.HResult); } _bus.Start(); _bus.ConnectAsync(connectSpec).AsTask().Wait(); _listeners = new Listeners(_bus, this); _bus.RegisterBusListener(_listeners); _mediaSink = new MediaSink(_bus); _mediaRender = new MediaRenderer(); _mediaRender.OnOpen += OnOpen; _mediaRender.OnPlay += OnPlay; _mediaRender.OnPause += OnPause; _mediaRender.OnClose += OnClose; _bus.FindAdvertisedName(MEDIA_SERVER_NAME); }); _t1.Start(); }
/// <summary> /// Leave the session with specified session id /// </summary> /// <param name="sessionId">Session Id of session to leave</param> public void DoLeave(uint sessionId) { lock (this.sessionMap) { if (this.sessionMap.ContainsKey(sessionId)) { try { this.busAtt.LeaveSession(sessionId); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("Leave Session was unsuccessful: " + errMsg); } this.sessionMap.Remove(sessionId); } else { this.mainPage.Output("Session Id doesn't exist in currently joined sessions"); } } }
/// <summary> /// Initializes a new instance of the <see cref="SessionOperations"/> class. Creates and registers /// the bus attachment, bus listener, bus object and interface for the application then establishes /// the alljoyn tcp connection. /// </summary> /// <param name="mp">Main page for the application</param> public SessionOperations(MainPage mp) { Task task = new Task(async() => { try { this.mainPage = mp; this.busAtt = new BusAttachment("Sessions", true, 4); this.busObject = new MyBusObject(this.busAtt, this); this.busListener = new MyBusListener(this.busAtt, this); this.busAtt.Start(); await this.busAtt.ConnectAsync(ConnectSpecs); } catch (Exception ex) { var errMsg = AllJoynException.GetErrorMessage(ex.HResult); this.mainPage.Output("Couldn't connect to AllJoyn: " + errMsg); } }); task.Start(); }