public void PingAdversary(ProximityDevice device, NotifyNfcReady notify)
{
if (subscribeId != -1)
{
proximityDevice.StopSubscribingForMessage(subscribeId);
subscribeId = -1;
}
if (publishId != -1)
{
proximityDevice.StopPublishingMessage(publishId);
publishId = -1;
}
if (state == NfcManager.ProtoState.Busy)
{
return;
}
state = NfcManager.ProtoState.NotReady;
notifyReady = notify;
initialMessage.devicetime = random.NextDouble();
MemoryStream stream = new MemoryStream();
DataContractSerializer serializer = new DataContractSerializer(initialMessage.GetType());
serializer.WriteObject(stream, initialMessage);
stream.Position = 0;
var dataWriter = new DataWriter();
dataWriter.WriteBytes(stream.GetBuffer());
proximityDevice = device;
publishId = proximityDevice.PublishBinaryMessage("Windows.CarTrumps", dataWriter.DetachBuffer());
subscribeId = proximityDevice.SubscribeForMessage("Windows.CarTrumps", OnMessageReceived);
}
/// <summary>
/// Stop sending the message that is being published
/// </summary>
/// <param name="messageId"></param>
public void StopSendMessage(long messageId)
{
if (messageId != null)
{
pDevice.StopPublishingMessage(messageId);
}
}
protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
{
device.StopPublishingMessage(writableTagId);
if (isPublishing)
{
if (device != null)
{
device.StopPublishingMessage(msgId);
}
isPublishing = false;
}
}
/// <summary>
/// When the app is started, start listening for other devices.
/// </summary>
/// <param name="sender">The CoronaRuntimeEnvironment that dispatched the event.</param>
/// <param name="e">Provides the Lua event table's fields/properties.</param>
private CoronaLabs.Corona.WinRT.ICoronaBoxedData OnStartSubscribeAndPublish(
CoronaLabs.Corona.WinRT.CoronaRuntimeEnvironment sender,
CoronaLabs.Corona.WinRT.CoronaLuaEventArgs e)
{
string str = "";
// Fetch the "event.message" property.
var boxedMessage = e.Properties.Get("message") as CoronaLabs.Corona.WinRT.CoronaBoxedString;
if (boxedMessage == null)
{
// A "message" property was not provided or it was not of type string.
// Return an error message to Lua describing what went wrong.
return(CoronaLabs.Corona.WinRT.CoronaBoxedString.From("'event.message' is a required field."));
}
if (_subscribedMessageID == -1)
{
_subscribedMessageID = _proximityDevice.SubscribeForMessage("Windows.ProximityDemo", messageReceived);
str += "Subscribed";
}
else
{
str += "Already Subscribed";
}
//Stop Publishing the current message.
if (_publishedMessageID != -1)
{
_proximityDevice.StopPublishingMessage(_publishedMessageID);
}
string msg = boxedMessage.ToString();
if (msg.Length > 0)
{
_publishedMessageID = _proximityDevice.PublishMessage("Windows.ProximityDemo", msg);
str += " - Published";
}
else
{
str += " - Error Length 0";
}
// Return a success message to Lua.
return(CoronaLabs.Corona.WinRT.CoronaBoxedString.From("Started Proximity: " + str));
}
void DeviceArrived(ProximityDevice proximityDevice)
{
var ignored = Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
Synopsis.Text += "Proximate device arrived\n\n";
Synopsis.Text += "Wi-Fi Direct requested\n\n";
Synopsis.Text += "ServerConnected\n\n";
});
//subscribedMessageId = proximityDevice.SubscribeForMessage("NDEF:wkt.HelloWorld", messageReceived);
//subscribedMessageId = -1;
//if(publishedUriId == -1)
// PublishLaunchApp();
publishedUriId =
proximityDevice.PublishUriMessage(new Uri("http://www.microsoft.com"));
if (publishedUriId != -1)
{
proximityDevice.StopPublishingMessage(publishedUriId);
}
//SplitAndCombine.combineFile();
//Connecting();
}
private void btnWriteLauch_Click(object sender, RoutedEventArgs e)
{
ProximityDevice device = ProximityDevice.GetDefault();
if (device != null)
{
//var appId = Windows.ApplicationModel.Store.CurrentApp.AppId;
var appId = "4bad5210-10de-4ae1-a10d-3bb5ce218d66";
const string launchArgs = "user=default";
string appName = "NFCMessage" + "!" + appId;
string launchAppMessage = launchArgs + "\tWindows\t" + appName;
var dataWriter = new DataWriter {
UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf16LE
};
dataWriter.WriteString(launchAppMessage);
_launchAppPubId = device.PublishBinaryMessage(
"LaunchApp:WriteTag", dataWriter.DetachBuffer(), (proximityDevice, id) =>
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
device.StopPublishingMessage(_launchAppPubId);
MessageBox.Show("Nachricht erfolgreich geschrieben !");
}));
}
}
private void WriteToNFCButton_Click(object sender, RoutedEventArgs e)
{
// make sure the device exists and was initialized
if (_proximityDevice == null)
{
return;
}
// cancel if it's currently publishing a message
if (_publishedUriId != -1)
{
_proximityDevice.StopPublishingMessage(_publishedUriId);
}
//Encoding the URL we write (must be Utf16)
var dataWriter = new DataWriter {
UnicodeEncoding = UnicodeEncoding.Utf16LE
};
//Capacity of tags differs
dataWriter.WriteString(UriTextBox.Text);
var dataBuffer = dataWriter.DetachBuffer();
// write our data to the tag, handler will get called upon successful transmission
_publishedUriId = _proximityDevice.PublishBinaryMessage("WindowsUri:WriteTag", dataBuffer, messageTransmittedHandler);
}
private void StopWritingMessage()
{
if (_writingMessageId.HasValue)
{
_nfcDevice.StopPublishingMessage(_writingMessageId.Value);
_writingMessageId = null;
}
}
private void StopPublishingMessage()
{
if (publishId != -1)
{
proximityDevice.StopPublishingMessage(publishId);
publishId = -1;
}
}
/// <summary>
/// Unpublishes the specified identifier.
/// </summary>
/// <param name="id">The identifier.</param>
public void Unpublish(Guid id)
{
if (_published.ContainsKey(id))
{
_device.StopPublishingMessage(_published[id]);
_published.Remove(id);
}
}
private void StopPublishingMessage(bool writeToStatusOutput)
{
if (_publishingMessageId != 0 && _device != null)
{
// Stop publishing the message
_device.StopPublishingMessage(_publishingMessageId);
_publishingMessageId = 0;
}
}
private void messageTransmittedHandler(ProximityDevice sender, long messageId)
{
sender.StopPublishingMessage(msgId);
isPublishing = false;
Dispatcher.BeginInvoke(() =>
{
pressed.IsEnabled = true;
MessageBox.Show("The LaunchApp content has been written to the tag");
});
}
public async Task <WriteResult> WriteTag(NdefMessage message, CancellationToken cancellationToken, TimeSpan timeout)
{
if (!IsSupported)
{
if (_dontThrowExpceptionWhenNotSupported)
{
return(null);
}
throw new NotSupportedException("This device does not support NFC (or perhaps it's disabled)");
}
Task timeoutTask = null;
if (timeout != default(TimeSpan))
{
timeoutTask = Task.Delay(timeout);
}
long subscription;
TaskCompletionSource <WriteResult> resultSource = new TaskCompletionSource <WriteResult>(); //needs a message type
using (cancellationToken.Register((s => ((TaskCompletionSource <WriteResult>)s).TrySetCanceled()), resultSource))
{
byte[] theMessage = message.ToByteArray();
subscription = _proximityDevice.PublishBinaryMessage("NDEF:WriteTag", theMessage.AsBuffer(), (sender, id) =>
{
WriteResult result = new WriteResult();
result.NFCTag = new NFCTag();
result.ReasonForFailure = FailureReasons.DidNotFail;
resultSource.TrySetResult(result);
});
try
{
if (timeoutTask != null)
{
await Task.WhenAny(timeoutTask, resultSource.Task);
if (timeoutTask.IsCompleted)
{
throw new TimeoutException("NFC message not recieved in time");
}
}
if (resultSource.Task.IsCanceled)
{
return(null);
}
return(await resultSource.Task);
}
finally
{
_proximityDevice.StopPublishingMessage(subscription);
}
}
}
private void btnStopPublic_Click(object sender, RoutedEventArgs e)
{
ProximityDevice device = ProximityDevice.GetDefault();
// Prüfen ob NFC auf diesem Gerät verfügbar ist
if (device != null && _publishedMessageId > -1)
{
device.StopPublishingMessage(_publishedMessageId);
_publishedMessageId = -1;
}
}
/// <summary>
/// Invoked when nfc message was published.
/// </summary>
/// <param name="sender">The nfc device the message was subscribed with</param>
/// <param name="messageId">The id of the written message</param>
private void PublishedHandler(ProximityDevice sender, long messageId)
{
// Let the device vibrate to indicate that a new message was written
var vibrationDevice = VibrationDevice.GetDefault();
if (vibrationDevice != null)
{
vibrationDevice.Vibrate(TimeSpan.FromSeconds(0.2));
}
// Stops the publishing of the current message
sender.StopPublishingMessage(messageId);
}
/// <summary>
/// Executes the Proximity service.
/// </summary>
/// <param name="title">The title proximityd.</param>
/// <param name="message">The message proximityd.</param>
/// <param name="link">The link proximityd.</param>
/// <param name="type">The image proximityd.</param>
public void ShareUri(string uriString)
{
var cancelPublishUriMessageDialog = GetCancelTapSendMesssage();
// Make sure NFC is supported
if (_device != null)
{
var uri = new Uri(uriString, UriKind.RelativeOrAbsolute);
long Id = _device.PublishUriMessage(uri, (sender, messageId) =>
{
_device.StopPublishingMessage(messageId);
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
cancelPublishUriMessageDialog.Dismiss();
});
});
cancelPublishUriMessageDialog.Dismissed += (sender, e) =>
{
_device.StopPublishingMessage(Id);
};
cancelPublishUriMessageDialog.Show();
}
}
private void btnPublish_Click(object sender, RoutedEventArgs e)
{
ProximityDevice device = ProximityDevice.GetDefault();
// Prüfen ob NFC auf diesem Gerät verfügbar ist
if (device != null)
{
if (_publishedMessageId > -1)
{
device.StopPublishingMessage(_publishedMessageId);
}
_publishedMessageId = device.PublishMessage("Windows.WindowsDeveloper.MessageType", "Hallo Welt via NFC");
}
}
/// <summary>
/// Stops all, publishing and subscribing.
/// </summary>
public void StopAll()
{
if (_publishedMsgId != -1)
{
_proximityDevice.StopPublishingMessage(_publishedMsgId);
_publishedMsgId = -1;
}
if (_subscribedMsgId != -1)
{
_proximityDevice.StopSubscribingForMessage(_subscribedMsgId);
_subscribedMsgId = -1;
}
}
private void StopPublishingMessage(bool writeToStatusOutput)
{
if (_publishingMessageId != 0 && _device != null)
{
// Stop publishing the message
_device.StopPublishingMessage(_publishingMessageId);
_publishingMessageId = 0;
// Update enabled / disabled state of buttons in the User Interface
UpdateUiForNfcStatus();
// Update status text for UI - only if activated
if (writeToStatusOutput)
{
SetStatusOutput(AppResources.StatusPublicationStopped);
}
}
}
private void DoWriteTag()
{
try
{
using (var writer = new DataWriter {
UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf16LE
})
{
Debug.WriteLine("Writing message to NFC: " + Url);
writer.WriteString(Url);
long id = _proximityDevice.PublishBinaryMessage("WindowsUri:WriteTag", writer.DetachBuffer());
_proximityDevice.StopPublishingMessage(id);
}
}
catch (Exception e)
{
Debug.WriteLine(e.StackTrace);
}
}
private void PublishRecordToTag(NDEFRecordShort record, MessageTransmittedHandler handler)
{
if (record == null ||
record.Data == null)
{
return;
}
IBuffer buffer = record.Data.AsBuffer();
device.PublishBinaryMessage("NDEF:WriteTag", buffer, (sender, msgID) => {
if (handler != null)
{
handler(sender, msgID);
}
device.StopPublishingMessage(msgID);
});
}
private void btnWriteMimePublish_Click(object sender, RoutedEventArgs e)
{
ProximityDevice device = ProximityDevice.GetDefault();
if (device != null)
{
btnWriteMimePublish.IsEnabled = false;
_idTxtPlain = device.PublishBinaryMessage(
"WindowsMime:WriteTag.text/plain",
Encoding.UTF8.GetBytes(tbMime.Text).AsBuffer(),
(proximityDevice, messageId) => {
Deployment.Current.Dispatcher.BeginInvoke(() => {
device.StopPublishingMessage(_idTxtPlain);
MessageBox.Show("Nachricht erfolgreich geschrieben !");
btnWriteMimePublish.IsEnabled = true;
});
}
);
}
}
private void btnWriteURI_Click(object sender, RoutedEventArgs e)
{
ProximityDevice device = ProximityDevice.GetDefault();
if (device != null)
{
_idUriWrite = device.PublishBinaryMessage(
"WindowsUri:WriteTag",
Encoding.Unicode.GetBytes(tbUrl.Text).AsBuffer(),
(proximityDevice, messageId) =>
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
device.StopPublishingMessage(_idUriWrite);
MessageBox.Show("Nachricht erfolgreich geschrieben !");
});
}
);
}
}
private void MessageWrittenHandler(ProximityDevice sender, long messageId)
{
proximityDevice.StopPublishingMessage(messageId);
}
private void writerHandler(ProximityDevice sender, long messageId)
{
nfcDevice.StopPublishingMessage(messageId);
RaiseTagDisconnected(nfcTag);
}
//Write to NFC Tag
async void SettingsWriteNFCTag_Click(object sender, RoutedEventArgs e)
{
try
{
ProximityDevice vProximityDevice = ProximityDevice.GetDefault();
if (vProximityDevice != null)
{
Nullable <bool> MessageDialogResult = null;
MessageDialog MessageDialog = new MessageDialog("After this message hold your NFC tag to this device's NFC area so the tag can be written.", "TimeMe");
MessageDialog.Commands.Add(new UICommand("Continue", new UICommandInvokedHandler((cmd) => MessageDialogResult = true)));
MessageDialog.Commands.Add(new UICommand("Cancel", new UICommandInvokedHandler((cmd) => MessageDialogResult = false)));
await MessageDialog.ShowAsync();
if (MessageDialogResult == true)
{
Button Button = (Button)sender;
string LaunchArgs = Button.Tag.ToString();
Set_NFCTags.Opacity = 0.60; Set_NFCTags.IsHitTestVisible = false;
//Create 10 seconds timeout timer
int TimeoutTime = 0;
DispatcherTimer TimeoutTimer = new DispatcherTimer();
TimeoutTimer.Interval = TimeSpan.FromSeconds(1);
TimeoutTimer.Tick += delegate
{
TimeoutTime++;
if (TimeoutTime >= 11)
{
vProximityDevice = null; TimeoutTimer.Stop(); Set_NFCTags.Opacity = 1; Set_NFCTags.IsHitTestVisible = true; sp_StatusBar.Visibility = Visibility.Collapsed;
}
else
{
txt_StatusBar.Text = "Waiting on NFC tag for " + (11 - TimeoutTime).ToString() + "sec..."; sp_StatusBar.Visibility = Visibility.Visible;
}
};
TimeoutTimer.Start();
//Start checking for NFC tag if NFC device is active
vProximityDevice.DeviceArrived += async delegate
{
if (vProximityDevice != null)
{
string WinAppId = Package.Current.Id.FamilyName + "!" + "App";
string AppMsg = LaunchArgs + "\tWindows\t" + WinAppId;
using (DataWriter DataWriter = new DataWriter {
UnicodeEncoding = UnicodeEncoding.Utf16LE
})
{
DataWriter.WriteString(AppMsg);
long PublishBinaryMessage = vProximityDevice.PublishBinaryMessage("LaunchApp:WriteTag", DataWriter.DetachBuffer());
vProximityDevice.StopPublishingMessage(PublishBinaryMessage);
vProximityDevice = null;
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async delegate
{
TimeoutTimer.Stop();
Set_NFCTags.Opacity = 1; Set_NFCTags.IsHitTestVisible = true;
sp_StatusBar.Visibility = Visibility.Collapsed;
await new MessageDialog("The NFC tag has successfully been written to your tag, please note that this might not work with all NFC tags due to incompatibility issues or with some tags that are locked.", "TimeMe").ShowAsync();
});
}
}
};
}
}
else
{
vProximityDevice = null;
Nullable <bool> MessageDialogResult = null;
MessageDialog MessageDialog = new MessageDialog("It seems like your device's NFC is disabled or does not support NFC, please make sure NFC is turned on before writing a new NFC tag, do you want to enable your device's NFC functionality?", "TimeMe");
MessageDialog.Commands.Add(new UICommand("Enable", new UICommandInvokedHandler((cmd) => MessageDialogResult = true)));
MessageDialog.Commands.Add(new UICommand("Cancel", new UICommandInvokedHandler((cmd) => MessageDialogResult = false)));
await MessageDialog.ShowAsync();
if (MessageDialogResult == true)
{
await Launcher.LaunchUriAsync(new Uri("ms-settings:proximity"));
}
}
}
catch (Exception Ex) { await new MessageDialog("NFCError: " + Ex.Message, "TimeMe").ShowAsync(); }
}
