MessageTransmittedHandler MessageTransmittedHandler MessageTransmittedHandler MessageTransmittedHandler MessageTransmittedHandler Delegate

Definition

Describes the method that will handle the event that's fired when a published message has been transmitted.

public : delegate void MessageTransmittedHandler(ProximityDevice sender, long messageId)
struct MessageTransmittedHandler : winrt::Windows::Foundation::IUnknown
{
   MessageTransmittedHandler(std::nullptr_t = nullptr) noexcept;
   template <typename L> MessageTransmittedHandler(L lambda);
   template <typename F> MessageTransmittedHandler(F* function);
   template <typename O, typename M> MessageTransmittedHandler(O* object, M method);
   void operator()(winrt::Windows::Networking::Proximity::ProximityDevice const& sender, long const& messageId) const;
};
public delegate void MessageTransmittedHandler(ProximityDevice sender, Int64 messageId)
Public Delegate Sub MessageTransmittedHandler(sender As ProximityDevice, messageId As Int64)
var messageTransmittedHandler = function(sender, messageId) {

 /* Your code */

}

Parameters

sender
ProximityDevice ProximityDevice ProximityDevice

The proximity device that published the message.

messageId
Int64 Int64 Int64

The publication ID of the message.

Attributes

Windows 10 requirements

Device family
Windows 10 (introduced v10.0.10240.0 - for Xbox, see UWP features that aren't yet supported on Xbox)
API contract
Windows.Foundation.UniversalApiContract (introduced v1)
Capabilities
ID_CAP_PROXIMITY [Windows Phone] proximity ID_CAP_PROXIMITY [Windows Phone]

Examples

    Windows.Networking.Proximity.ProximityDevice proximityDevice;
    long publishedMessageId = -1;
    long subscribedMessageId = -1;

    private void initializeProximityDevice()
    {
        proximityDevice = Windows.Networking.Proximity.ProximityDevice.GetDefault();

        if (proximityDevice != null)
        {
            PublishMessageButton.Click += PublishMessage;
            SubscribeForMessageButton.Click += SubscribeForMessage;
            StopSubscribingForMessageButton.Click += StopSubscribingForMessage;
            StopPublishingMessageButton.Click += StopPublishingMessage;
        }
        else
        {
            WriteMessageText("Failed to initialized proximity device.\n");
        }
    }

    private void PublishMessage(object sender, RoutedEventArgs e)
    {
        // Stop publishing the current message.
        if (publishedMessageId != -1)
        {
            proximityDevice.StopPublishingMessage(publishedMessageId);
        }

        publishedMessageId = 
            proximityDevice.PublishMessage("Windows.SampleMessage", MessageTextBlock.Text,
                                                   MessagePublished);
    }

private void MessagePublished(
    Windows.Networking.Proximity.ProximityDevice sender,
        long messageId)
    {
    // The message has been successfully published.
    }

    private void SubscribeForMessage(object sender, RoutedEventArgs e)
    {
        // Only subscribe for the message one time.
        if (subscribedMessageId == -1)
        {
            subscribedMessageId = 
            proximityDevice.SubscribeForMessage("Windows.SampleMessage", messageReceived);
        }
    }

    private void messageReceived(
        Windows.Networking.Proximity.ProximityDevice device, 
        Windows.Networking.Proximity.ProximityMessage message)
    {
        MessageBlock.Text += "Message received: " + message.DataAsString + "\n";
    }

    private void StopSubscribingForMessage(object sender, RoutedEventArgs e)
    {
        proximityDevice.StopSubscribingForMessage(subscribedMessageId);
        subscribedMessageId = -1;
    }

    private void StopPublishingMessage(object sender, RoutedEventArgs e)
    {
        proximityDevice.StopPublishingMessage(publishedMessageId);
        publishedMessageId = -1;
    }

    // Write a message to MessageBlock on the UI thread.
    private Windows.UI.Core.CoreDispatcher messageDispatcher = Window.Current.CoreWindow.Dispatcher;

    async private void WriteMessageText(string message, bool overwrite = false)
    {
        await messageDispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
            () =>
            {
                if (overwrite)
                    MessageBlock.Text = message;
                else
                    MessageBlock.Text += message;
            });
    }
    function id(elementId) {
        return document.getElementById(elementId);
    }

    var proximityDevice;
    var publishedMessageId = -1;
    var subscribedMessageId = -1;

    function initializeProximityDevice() {
        proximityDevice = Windows.Networking.Proximity.ProximityDevice.getDefault();

        if (proximityDevice) {
            id("publishMessageButton").addEventListener("click", publishMessage);
            id("subscribeForMessageButton").addEventListener("click", subscribeForMessage);
    id("stopSubscribingForMessageButton").addEventListener("click", 
        stopSubScribingForMessage);
    id("stopPublishingMessageButton").addEventListener("click", 
        stopPublishingMessage);
        }
        else {
            id("messageDiv").innerHTML += "Failed to initialized proximity device.<br />";
        }
    }

    function publishMessage() {
        // Stop publishing the current message.
        if (publishedMessageId != -1) {
            proximityDevice.stopPublishingMessage(publishedMessageId);
        }

        publishedMessageId = 
    proximityDevice.publishMessage("Windows.SampleMessage", id("messageText").value,
                                           messagePublished);
    }

function messagePublished(sender, messageId) {
    // The message has been successfully published.
    }

    function subscribeForMessage() {
        // Only subscribe for the message one time.
        if (subscribedMessageId === -1) {
            subscribedMessageId = 
        proximityDevice.subscribeForMessage("Windows.SampleMessage", messageReceived);
        }
    }

    function messageReceived(device, message) {
        id("messageDiv").innerHTML += "Message received: " + message.dataAsString + "<br />";
    }

function stopSubscribingForMessage() {
    proximityDevice.stopSubscribingForMessage(subscribedMessageId);
        subscribedMessageId = -1;
}

function stopPublishingMessage() {
    proximityDevice.stopPublishingMessage(publishedMessageId);
        publishedMessageId = -1;
}
Private proximityDevice As Windows.Networking.Proximity.ProximityDevice
Private publishedMessageId As Long = -1
Private subscribedMessageId As Long = -1

Private Sub initializeProximityDevice()
    proximityDevice = Windows.Networking.Proximity.ProximityDevice.GetDefault()

    If proximityDevice IsNot Nothing Then
        AddHandler PublishMessageButton.Click, AddressOf PublishMessage
        AddHandler SubscribeForMessageButton.Click, AddressOf SubscribeForMessage
        AddHandler StopSubscribingForMessageButton.Click, AddressOf StopSubscribingForMessage
        AddHandler StopPublishingMessageButton.Click, AddressOf StopPublishingMessage
    Else
        WriteMessageText("Failed to initialized proximity device." & vbTab)
    End If
End Sub

Private Sub PublishMessage(sender As Object, e As RoutedEventArgs)
    ' Stop publishing the current message.
    If publishedMessageId <> -1 Then
        proximityDevice.StopPublishingMessage(publishedMessageId)
    End If

    publishedMessageId =
        proximityDevice.PublishMessage("Windows.SampleMessage", MessageTextBlock.Text,
                                       AddressOf MessagePublished)
End Sub

Private Sub MessagePublished(
sender As Windows.Networking.Proximity.ProximityDevice,
    messageId As Long)

' The message has been successfully published.
End Sub

Private Sub SubscribeForMessage(sender As Object, e As RoutedEventArgs)
    ' Only subscribe for the message one time.
    If subscribedMessageId = -1 Then
        subscribedMessageId =
        proximityDevice.SubscribeForMessage("Windows.SampleMessage", AddressOf messageReceived)
    End If
End Sub

Private Sub messageReceived(
    device As Windows.Networking.Proximity.ProximityDevice,
    message As Windows.Networking.Proximity.ProximityMessage)

    MessageBlock.Text &= "Message received: " & message.DataAsString & vbTab
End Sub

Private Sub StopSubscribingForMessage(sender As Object, e As RoutedEventArgs)
    proximityDevice.StopSubscribingForMessage(subscribedMessageId)
    subscribedMessageId = -1
End Sub

Private Sub StopPublishingMessage(sender As Object, e As RoutedEventArgs)
    proximityDevice.StopPublishingMessage(publishedMessageId)
    publishedMessageId = -1
End Sub

' Write a message to MessageBlock on the UI thread.
Private Async Sub WriteMessageText(message As String, Optional overwrite As Boolean = False)
    Await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
        Sub()
            If overwrite Then
                MessageBlock.Text = message
            Else
                MessageBlock.Text &= message
            End If
        End Sub)
End Sub

Remarks

Messages continue to be published until the StopPublishingMessage method is called or the ProximityDevice on the publishing computer is released. Messages are delivered to all apps that have subscribed for the same message type.

When using the PublishMessage method, the only supported message type is one that begins with "Windows.". To publish messages using another message type, such as "WindowsMime." or "NDEF:WriteTag", you must use the PublishBinaryMessage method.

The MessageTransmittedHandler delegate is called each time a message is successfully transmitted to a device, regardless of whether any apps were subscribed to the message on that device.

See also