Ejemplo n.º 1
0
        /// <summary>
        /// Construct a new MIME / Image record based on a stream.
        /// </summary>
        /// <param name="imgStream">Reference to a stream containing image data
        /// (encoded for example as a PNG or JPEG). The stream will be parsed
        /// by this class, to load its contents into the Payload of this record
        /// and set the MIME type correctly depending on the stream contents.</param>
        /// <returns>A newly constructed MIME / Image record with the stream data
        /// as payload and the MIME type automatically determined based on the
        /// image data.</returns>
        public static async Task <NdefMimeImageRecord> CreateFromStream(IRandomAccessStream imgStream)
        {
            var imgRecord = new NdefMimeImageRecord();
            await imgRecord.LoadStream(imgStream);

            return(imgRecord);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Construct a new MIME / Image record based on a file.
        /// </summary>
        /// <param name="file">Reference to a file that will be opened and parsed
        /// by this class, to load its contents into the Payload of this record
        /// and set the MIME type correctly depending on the file contents.</param>
        /// <returns>A newly constructed MIME / Image record with the file data
        /// as payload and the MIME type automatically determined based on the
        /// image data.</returns>
        public static async Task <NdefMimeImageRecord> CreateFromFile(StorageFile file)
        {
            var imgRecord = new NdefMimeImageRecord();
            await imgRecord.LoadFile(file);

            return(imgRecord);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Construct a new MIME / Image record based on a WriteableBitmap.
        /// Specify the MIME type and DPI, and the image data is encoded accordingly.
        /// </summary>
        /// <param name="bmp">Source bitmap to use for conversion.</param>
        /// <param name="mimeType">MIME type to specify the target image encoding.</param>
        /// <param name="dpi">Optional parameter to set the DPI of the encoded image
        /// (if supported by the specific MIME type).</param>
        /// <returns>A newly constructed MIME / Image record with the WriteableBitmap
        /// encoded into the specified MIME type.</returns>
        public static async Task <NdefMimeImageRecord> CreateFromBitmap(WriteableBitmap bmp, ImageMimeType mimeType,
                                                                        double dpi = 96.0)
        {
            var imgRecord = new NdefMimeImageRecord();
            await imgRecord.SetImage(bmp, mimeType, dpi);

            return(imgRecord);
        }
Ejemplo n.º 4
0
        private async Task ParseTagContents(NdefMessage ndefMessage, StringBuilder tagContents)
        {
            // Loop over all records contained in the NDEF message
            foreach (NdefRecord record in ndefMessage)
            {
                // --------------------------------------------------------------------------
                // Print generic information about the record
                if (record.Id != null && record.Id.Length > 0)
                {
                    // Record ID (if present)
                    tagContents.AppendFormat("Id: {0}\n", Encoding.UTF8.GetString(record.Id, 0, record.Id.Length));
                }
                // Record type name, as human readable string
                tagContents.AppendFormat("Type name: {0}\n", ConvertTypeNameFormatToString(record.TypeNameFormat));
                // Record type
                if (record.Type != null && record.Type.Length > 0)
                {
                    tagContents.AppendFormat("Record type: {0}\n",
                        Encoding.UTF8.GetString(record.Type, 0, record.Type.Length));
                }

                // --------------------------------------------------------------------------
                // Check the type of each record
                // Using 'true' as parameter for CheckSpecializedType() also checks for sub-types of records,
                // e.g., it will return the SMS record type if a URI record starts with "sms:"
                // If using 'false', a URI record will always be returned as Uri record and its contents won't be further analyzed
                // Currently recognized sub-types are: SMS, Mailto, Tel, Nokia Accessories, NearSpeak, WpSettings
                var specializedType = record.CheckSpecializedType(true);

                if (specializedType == typeof(NdefMailtoRecord))
                {
                    // --------------------------------------------------------------------------
                    // Convert and extract Mailto record info
                    var mailtoRecord = new NdefMailtoRecord(record);
                    tagContents.Append("-> Mailto record\n");
                    tagContents.AppendFormat("Address: {0}\n", mailtoRecord.Address);
                    tagContents.AppendFormat("Subject: {0}\n", mailtoRecord.Subject);
                    tagContents.AppendFormat("Body: {0}\n", mailtoRecord.Body);
                }
                else if (specializedType == typeof(NdefUriRecord))
                {
                    // --------------------------------------------------------------------------
                    // Convert and extract URI record info
                    var uriRecord = new NdefUriRecord(record);
                    tagContents.Append("-> URI record\n");
                    tagContents.AppendFormat("URI: {0}\n", uriRecord.Uri);
                }
                else if (specializedType == typeof(NdefSpRecord))
                {
                    // --------------------------------------------------------------------------
                    // Convert and extract Smart Poster info
                    var spRecord = new NdefSpRecord(record);
                    tagContents.Append("-> Smart Poster record\n");
                    tagContents.AppendFormat("URI: {0}", spRecord.Uri);
                    tagContents.AppendFormat("Titles: {0}", spRecord.TitleCount());
                    if (spRecord.TitleCount() > 1)
                        tagContents.AppendFormat("1. Title: {0}", spRecord.Titles[0].Text);
                    tagContents.AppendFormat("Action set: {0}", spRecord.ActionInUse());
                    // You can also check the action (if in use by the record), 
                    // mime type and size of the linked content.
                }
                else if (specializedType == typeof(NdefVcardRecordBase))
                {
                    // --------------------------------------------------------------------------
                    // Convert and extract business card info
                    var vcardRecord = new NdefVcardRecord(record);
                    tagContents.Append("-> Business Card record" + Environment.NewLine);
                    var contact = vcardRecord.ContactData;

                    // Contact has phone or email info set? Use contact manager to show the contact card
                    await _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                    {
                        if (contact.Emails.Any() || contact.Phones.Any())
                        {
                            var rect = GetElementRect(StatusOutput);
                            ContactManager.ShowContactCard(contact, rect, Placement.Below);
                        }
                        else
                        {
                            // No phone or email set - contact manager would not show the contact card.
                            // -> parse manually
                            tagContents.AppendFormat("Name: {0}\n", contact.DisplayName);
                            tagContents.Append("[not parsing other values in the demo app]");
                        }
                    });
                }
                else if (specializedType == typeof(NdefLaunchAppRecord))
                {
                    // --------------------------------------------------------------------------
                    // Convert and extract LaunchApp record info
                    var launchAppRecord = new NdefLaunchAppRecord(record);
                    tagContents.Append("-> LaunchApp record" + Environment.NewLine);
                    if (!string.IsNullOrEmpty(launchAppRecord.Arguments))
                        tagContents.AppendFormat("Arguments: {0}\n", launchAppRecord.Arguments);
                    if (launchAppRecord.PlatformIds != null)
                    {
                        foreach (var platformIdTuple in launchAppRecord.PlatformIds)
                        {
                            if (platformIdTuple.Key != null)
                                tagContents.AppendFormat("Platform: {0}\n", platformIdTuple.Key);
                            if (platformIdTuple.Value != null)
                                tagContents.AppendFormat("App ID: {0}\n", platformIdTuple.Value);
                        }
                    }
                }
                else if (specializedType == typeof(NdefMimeImageRecordBase))
                {
                    // --------------------------------------------------------------------------
                    // Convert and extract Image record info
                    var imgRecord = new NdefMimeImageRecord(record);
                    tagContents.Append("-> MIME / Image record" + Environment.NewLine);
                    _dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () => SetStatusImage(await imgRecord.GetImageAsBitmap()));

                }
                else
                {
                    // Other type, not handled by this demo
                    tagContents.Append("NDEF record not parsed by this demo app" + Environment.NewLine);
                }
            }
        }
Ejemplo n.º 5
0
 /// <summary>
 /// Construct a new MIME / Image record based on a WriteableBitmap.
 /// Specify the MIME type and DPI, and the image data is encoded accordingly. 
 /// </summary>
 /// <param name="bmp">Source bitmap to use for conversion.</param>
 /// <param name="mimeType">MIME type to specify the target image encoding.</param>
 /// <param name="dpi">Optional parameter to set the DPI of the encoded image
 /// (if supported by the specific MIME type).</param>
 /// <returns>A newly constructed MIME / Image record with the WriteableBitmap
 /// encoded into the specified MIME type.</returns>
 public static async Task<NdefMimeImageRecord> CreateFromBitmap(WriteableBitmap bmp, ImageMimeType mimeType,
     double dpi = 96.0)
 {
     var imgRecord = new NdefMimeImageRecord();
     await imgRecord.SetImage(bmp, mimeType, dpi);
     return imgRecord;
 }
Ejemplo n.º 6
0
 /// <summary>
 /// Construct a new MIME / Image record based on a stream.
 /// </summary>
 /// <param name="imgStream">Reference to a stream containing image data
 /// (encoded for example as a PNG or JPEG). The stream will be parsed
 /// by this class, to load its contents into the Payload of this record
 /// and set the MIME type correctly depending on the stream contents.</param>
 /// <returns>A newly constructed MIME / Image record with the stream data
 /// as payload and the MIME type automatically determined based on the 
 /// image data.</returns>
 public static async Task<NdefMimeImageRecord> CreateFromStream(IRandomAccessStream imgStream)
 {
     var imgRecord = new NdefMimeImageRecord();
     await imgRecord.LoadStream(imgStream);
     return imgRecord;
 }
Ejemplo n.º 7
0
 /// <summary>
 /// Construct a new MIME / Image record based on a file.
 /// </summary>
 /// <param name="file">Reference to a file that will be opened and parsed
 /// by this class, to load its contents into the Payload of this record
 /// and set the MIME type correctly depending on the file contents.</param>
 /// <returns>A newly constructed MIME / Image record with the file data
 /// as payload and the MIME type automatically determined based on the 
 /// image data.</returns>
 public static async Task<NdefMimeImageRecord> CreateFromFile(StorageFile file)
 {
     var imgRecord = new NdefMimeImageRecord();
     await imgRecord.LoadFile(file);
     return imgRecord;
 }