Yort on .NET

Share Contact for Windows Phone Privacy Policy

2016-06-23T22:51:00.003+12:00

Share Contact for Windows Phone is used to deliberately and explicitly share contact information, either your own or other peoples, from your phone address book. It will only share data when you specifically ask it to, and it allows you to choose which data is shared. When sharing by email or SMS, you will be able to see the message before it is sent, allowing for final control over the data shared.

The app may capture your own contact information for the purposes of later sharing with other people. In this case you will be explicitly asked to provide the contact information yourself. The information will be stored on your device, but will only be shared when you specify.

When sharing other people’s contact information please ensure you respect their privacy and only share their details with their consent. You are responsible for the act of and information shared. The application may gather anonymous usage data, as aggregate values, or data stored against anonymous device or user id’s which are not directly linked to your identity. This data will be used for the purposes of improving and fixing the app. It will not be sold or deliberately shared. The data may be collected and/or stored in 3rd party systems such as cloud services, but only as private data and not shared with the 3rd party host.

Your Consent
By using our services and application, you consent to our privacy policy and disclaimer.

Contacting Us If there are any questions regarding this privacy policy you may contact us using the information below;
email: yort@yortondotnet.com

Disclaimer
This program is provided "as is" without warranty of any kind, either express or implied, including but not limited to, the implied warranties of merchantability and fitness for a particular purpose.
The entire risk as to the quality and performance of the program is with you. Should the program prove defective, you assume the cost of all necessary servicing, repair and/or correction. In no event unless required by applicable law will any copyright holder, or any other party be liable to you for damages, including any general, special, incidental or consequential damages arising out of the use, misuse or inability to use the program (including but not limited to loss of use, data or profits), even if such holder or other party has been advised of the possibility of such damages.
By accepting this disclaimer you agree to use the software at your own risk and irrevocably waive all your rights to seek damages or relief of any nature from us arising out of or in connection with your use of the software.

Azure Notification Hub "Tags" Cannot Contain Spaces

2016-01-11T19:21:00.000+13:00

A quick word on Azure Notification Hub "Tags".

"Tags" cannot contain spaces. This isn't covered/obvious is most of the samples/tutorials. They don't use spaces and don't discuss restrictions on the tag content.

The only documentation I've found so far on allowed characters is this; https://msdn.microsoft.com/en-us/library/windows/apps/xaml/dn792122.aspx

Before I found this I spent some time trying to figure out why my push notifications weren't working. It appears the Microsoft.Azure.NotificationHub packages doesn't report errors with invalid tags when registering them.

Calling methods such as CreateMpnsTemplateRegistrationAsync with an invalid tag will not throw an exception. The result object will appear correct, with a valid registration id. The only hint of a problem (apart from it not working) is the tags collection on the result will be empty. If more than one tag is supplied but only some are invalid, none register.

SendTemplateNotificationAsync does throw an exception if you send to an invalid tag.

In my case I was sending to a valid tag, but it was not registered because one of the other tags was invalid during registration. It took me a while to figure it out since the registration looked like it was working and the send was successful but no notification arrived.

The lack of spaces is pretty sad given my requirements (many of my tags come from user configuration). What is most annoying though is the lack of validation/error reporting on registration. An exception with a good error message would have saved me a lot of time. Hopefully this note saves someone else the time I wasted.

Getting Lazy with LINQ, Json.Net and WebAPI

2015-08-27T18:31:00.001+12:00

I've been working on a project that uses a WebAPI hosted via OWIN inside a Win32 client application. Yes, inside a client application. Forgive me. Let's not quibble about it.

My Controller Actions generally return an IEnumerable<T>, with T varying depending on the Action. Most of my Actions return the (raw) result of a LINQ query, which is convertible to IEnumerable<T>. A contrived example;

[HttpGet]
public IEnumerable<ApiCustomer> GetAllCustomers()
{
  return (from customer 
    in _CustomerRepository.GetAll 
    where c.IsPublic 
    select GetApiCustomerFromFullCustomer(customer));
}

All was well until I needed to return an IEnumerable<BaseType> with the elements as different derived types. To enable this, you must tell the serialisation formatter to include type information. This allows the client to determine what type to create and populate from the serialised data. Luckily, the awesome Json.Net solves this problem. Just configure your default serialiser to include the type information;

config.Formatters.JsonFormatter.SerializerSettings.TypeNameHandling = TypeNameHandling.Auto;

TypeNameHandling.Object should also work. The difference is Auto is only adds the type information where it detects a difference in the types used. Object always includes the type information.

Unfortunately, this is where I came unstuck. I have declared a return type of IEnumerable<T>, but I'm not returning one. Sort of. IEnumerable<T> is an interface, so you can't actually return an instance of it. You can, and I do, return something that is castable/convertible to it.

The result of a LINQ statement is actually a generic type, created by the compiler at runtime. If you check the type at runtime you'll see a name like "WhereSelectIterator`2". This object instance is an enumerator (IEnumerator<T> or IEnumerator) that allows lazy enumeration of the query. It is also convertible to IEnumerable<T>, so without type information (de)serialises fine.

Json.Net serialises the LINQ result with type information of "WhereSelectIterator`2" (or similar). Presumably because "WhereSelectIterator`2" isn’t exactly IEnumerable<T>. When the client deserialises the data it can't find "WhereSelectIterator`2". That type only existed at runtime on the server, it's not defined in any assembly on the client. This results in an exception being thrown.

Json.Net already knows how to serialise some types when returned as IEnumerable<T>. Lists and arrays work (serialised as a Json array), and maybe other collection types too. Because of that behaviour, I had expected anything convertible to IEnumerable<T> would do the same. Unfortunately the enumerators from LINQ queries aren't treated the same way. I'm not sure if this is a bug in Json.Net. I haven't checked the Json.Net code, so I don't know what it actually does in detail. I'm also not sure if there are use cases I'm unaware of that might depend on this behaviour. It’s possible this behaviour is by design. Either way, I had a problem.

I needed a solution. The obvious one, often given on the interwebs, is to "just add ToList or ToArray" to the LINQ queries, so they return a type that exists on the client. This does work, but it didn't suit me.

I have a lot of Controllers and Actions using this pattern and I don't want to change them all. Calling ToList/ToArray also has a cost in terms of memory allocation and CPU usage. These may be minor and we shouldn't "prematurely optimise", but ignoring these issues felt sloppy. There's also the environment to consider. The API is running in a long lived instance of a client application, on low spec hardware and often in use by a local interactive user simultaneously. It wasn't designed up front to host the API, or to serve more than one user at once. Memory fragmentation, garbage collections and excessive CPU usage would all be cause for alarm. In a perfect world we'd have a different design. At the moment time to market and available resources are choosing our path. Another concern is every developer who ever works on this has to avoid the same issue. This isn't obvious. The code compiles and runs fine on the server. It's only when you try to deserialise it in a remote process that you'll find a problem. Even then, you might not understand the problem or how to solve it. That moves the "pit of success" out of the common path.

I could have written a WebAPI filter which automatically called ToArray/ToList when appropriate. This would have solved some of the problems above, but not the efficiency issues.

There's always a question of "did you look hard enough?" but I only found one other published solution. This is to change the Action return type to IList<T>, List<T>, or Array<T> or something similar that is a 'more concrete' type. This has pretty much all the same issues as the other solution, perhaps more. Some people insisted this was more correct architecture anyway, which I question. It's possible Array<T> is more 'correct', but even then I think it's questionable. List/IList definitely doesn't seem better to me.

So without further ado, I present my solution: A JsonConverter for generic enumerators. This class plugs into the Json.Net serialiser, detects when the object to serialise is an IEnumerator<T> and writes out a Json array. Deserialisation is left to Json.Net to handle with its default logic. With this class and one line of code to use it, all my Controller Action methods now work as I expect.

Consider this code released under the MIT license, and with the caveat that it "works for me". I'm not aware of any immediate short comings, but I didn't code it for anyone else. There's no error handling, no unit tests. I haven't checked if it copes with nulls. I didn't worry about the naming. I haven't optimised the code for maximum performance. I didn’t try it with other generic types. It’s provided “as is” and I do not want to set any expectations of quality. YMMV.

You can configure the default serialiser to use it like this;

config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new LinqToIEnumerableJsonConverter());

Here's the class itself (also available as a gist);

internal class LinqToIEnumerableJsonConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        if (!objectType.IsGenericType) return false;
        var genericType = objectType.GenericTypeArguments.First();

        var enumeratorType = typeof(IEnumerator<>).MakeGenericType(genericType);

        return (objectType.GetInterface(enumeratorType.Name) != null);
    }

    public override bool CanRead
    {
        get
        {
            return false;
        }
    }

    public override bool CanWrite
    {
        get
        {
            return true;
        }
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        return null;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        writer.WriteStartArray();
        foreach (var item in (IEnumerable)value)
        {
            serializer.Serialize(writer, item);
        }
        writer.WriteEndArray();
    }
}

Now go forth and serialise!

Compose Tasks, UWP & Crash Workarounds

2015-07-27T10:44:00.001+12:00

If you’ve worked on WP Silverlight applications you’re probably familiar with the ‘compose tasks’. These present consistent UI for composing email, sms messages or making a phone call.

Recently I needed similar behaviour in a UWP application where the API is different. The good news is this functionality still exists. It's just not always be obvious where to look.

The replacement for PhoneCallTask is Windows.ApplicationModel.Calls.PhoneCallManager.ShowPhoneCallUI.

The replacement for EmailComposeTask is the Windows.ApplicationModel.Email.EmailManager.ShowComposeNewEmailAsync method and the Windows.ApplicationModel.Email.EmailMessage class.

The ComposeSmsTask also has a replacement API. There is a significant issue using this on the desktop versions of Windows 10.

The replacement for ComposeSmsTask is the Windows.ApplicationModel.Chat.ChatMessageManager. ShowComposeSmsMessageAsync method and Windows.ApplicationModel.Chat.ChatMessage class.

This is a universal API and thus is available on desktop and mobile platforms. In the pre-release bits for UWP, this works fine on mobile but will crash the app on desktop. Whether this will be fixed before the official release is unknown. Note I really mean crash. There is no exception to catch and the unhandled exception event doesn't get raised. The process just dies in a nasty way. ApiInformation.IsTypePresent and such don't help because the API is intentionally available on both platforms.

This leaves you with no (good) way to support the feature and avoid the crash. Thankfully @aruntalkstech has the answer. You can use ChatMessageManager.GetTransportsAsync to determine if the current device supports any messaging protocols. If it does, it’s safe to call the compose API, if not then you should avoid it. For more information sample code, see Arun’s blog post.

Mobile Barcode Scanning With Zxing.Net

2015-07-26T14:22:00.000+12:00

A LOB mobile application I’m working on requires the ability to scan barcodes. A proper hardware solution would be best but sourcing something suitable has proven challenging. As a result we’re trying to scan barcodes using the device’s camera.

When we started the app was a Xamarin project so we tried Zxing.Net.Mobile. Unfortunately performance was abysmal. Many barcodes wouldn’t scan at all and the ones that did required many seconds to get a read. To be fair, we may have configured the settings badly. We found little guidance on the right settings. Even on iOS, enabling Apple's native API’s for decoding barcodes only made marginal difference.

We then looked at commercial solutions. We're not against paying for quality. Most of these SDK's provided a great experience. Yet we found the licenses over the top and difficult to understand. One company wanted tens of thousands of dollars because we will distribute the app via the store. This is despite our app requiring a specialised back end, limiting the audience to a few thousand people. Several others wanted per user per symbology, or per user per platform licenses. These quickly rack up into the tens of thousands as well. The licenses were all yearly or monthly renewals too. Tracking the exact number of users is problematic. Our devices may not connect to the internet, or connect only periodically. These devices aren’t personal the same way most mobile phones are. We will have several different users using the same device at different times. There isn’t an accurate way to track users per device, or total users. No one talked about these issues, or how to report active users for licensing purposes. Another problem is most of these SDK’s only support one or two platforms not all three.

When we changed to a UWP application the situation was even worse. There are few SDK’s for the Windows platform and none that currently target UWP. There are some for WinRT that work in a UWP project, but they have separate binaries for x86/x64 and arm. None have packaged these binaries in a way a UWP project can reference and remain 'universal'. I believe this can be solved by repackaging the binaries ourselves but we never tried.

So we returned to Zxing.Net-, but this time only for decoding the barcodes. We wrote our own camera integration, based on the CameraGetPreviewFrame sample from Microsoft. We also configured Zxing differently. Now we have something with ‘acceptable’ performance for camera based barcode scanning. Unscientific tests show it out performs some implementations our competitors have used on iOS. What follows are tips based on our experience for getting the best out of Zxing. Your mileage may vary. Hardware, environmental conditions and use cases can have an impact. These tips should serve as a good starting point though.

Speed is King

The key take away is this: ensure decoding the barcode is fast. Slow decoding of the barcode is death to the user experience. This might seem counter-intuitive because accuracy would seem just as important. The trick is, with camera based scanning you have a lot of ‘dead’ frames. Frames where the barcode isn't present, isn't in focus or isn't lit correctly. The longer it takes to process each dead frame, the longer it will take to get a read.

Use a low to medium resolution. In my testing resolutions between 640x480 and 1024x768 work best. A higher resolution might seem better, as it should improve the barcode definition. In reality it slows down the decoding process and doesn’t help. Most mobile devices pick the highest resolution by default. They assume you’re trying to take video for the sake of video. You need to choose a sensible resolution for barcode scanning.
Don’t queue frames. I never actually tried this, but I did think about it. Later I found someone who had tried it, and abandoned it as a bad idea. Most queued frames will be ‘dead’ frames. Processing dead frames means getting a valid read will take longer. Just get a frame, attempt a decode, then get another frame. Don’t worry about the frames that get dropped.
Configure Zxing for best performance. Your use cases determine the best settings for you. I recommend these settings as a starting point.
- AutoRotate = false. Turning this on means decodes take about three times as long. Note you may need to enable this if you're scanning 2D barcodes. For 1D barcodes it is generally not helpful as orientation doesn't matter anyway.
- TryHarder = false. This setting isn’t intended for mobile scanning. It’s for large documents (say A4 document scans) that may contain barcodes anywhere. It makes a big impact to speed. Turn this off. You don’t need it. Trust me.
- TryInverted = false. I haven't found this ever helped.
- Only add barcode formats you need to decode. As a general rule every barcode symbology you add increases the decode time. Get rid of the ones you don’t need. In our app we either enable all 1D barcodes and QR codes, or just all 1D barcodes. Which set is based on the context we are scanning in.
If you need to rotate the preview frames, do so efficiently. The Microsoft sample referenced above shows the most efficient way. There is a more discoverable, simpler mechanism but it is significantly slower. Use the one from the sample.

Using these settings we get a decode rate of 80-110ms per frame on a Lumia 636. We average about 10 decoded frames a second. While this might not sound great, we get a pretty good experience.

Auto Focus is Overrated

My last tip concerns focus. There’s a lot written about the need for ‘auto focus’ to get fast accurate reads. There’s also ‘continuous focus’ supported on some phones which sounds like a great idea. We have abandoned both of these. Continuous focus was never good enough to get a barcode read, in my experience. The frames looked ok to my eyes but Zxing.Net never found a barcode.

Auto focus is a bit more complex. It does work. We do use it in our app. We will perform an auto-focus if the user taps on the frame preview control on screen. This helps if the user is having difficulty or is scanning small or large barcodes. We don't perform auto-focus by default or automatically though.

Our default focus when scanning starts is a manual focus. We ask the camera to focus, once, at it’s smallest focal length. Depending on your hardware you may want to use some other (manual) value, but this works well for us.

The manual focus eliminates the camera seeking back and forth through the focal range. This improves the read speed. A user familiar with the system will get an instant read by holding the barcode the right distance away. For those not so familiar the read is still quick. If the barcode isn’t in focus immediately, the user can move the barcode or the phone slightly closer or further away. Scan times under a second are common.

Give manual focus try and see how it works for you.

Obviously none of this matches the performance of dedicated barcode scanning hardware. Yet it’s the best we’ve been able to achieve with what we have. It’s also better than where we started, and so far it’s been free.

One Last Thing

We haven’t tried this. It's just supposition.

It’s possible recompiling Zxing as a UWP library using .Net Native may improve things further. This should provide better performance for the decoding process.

PointerDownThemeAnimation, PointerUpThemeAnimation & Null Reference Exceptions

2015-07-25T13:24:00.000+12:00

WinRT and UWP projects have access to PointerDownThemeAnimation and PointerUpThemeAnimation. These animations provide a consistent visual feedback experience with the OS and other apps. Unfortunately these animations have some specific implementation details and don’t always behave as expected. This is most often true when using them from code behind instead of declaring them in XAML. This usually happens when you’re building a templated control, behaviour or similar reusable component.

The most common issue that occurs is an unexpected null reference exception. To avoid this;

Ensure the target element (the one to be animated) has a name. The easiest way is to assign one in XAML at design time. If no name is present at runtime you need to assign one.
Ensure you set the TargetName property on the animation. Setting the Target property won’t work. You must set the TargetName property, and that’s why you need a name set on the target.
You must add the animation into the logical tree for the target. My suggestion is to add it to the resources collection for the target. If you don’t do this the system has no context to search in so it still won’t find the target. This will also result in a null reference exception.

It's a shame there isn’t a better error message. The inability to assign a target object without a name is also disappointing.

Another issue is the duration property for these animations. You can set it without receiving an error, but the duration won’t change. This is fine as you should be seeking consistency with other apps. It's just sad that this is a silent failure. It is noted on MSDN though.

Below is a draft XAML Behaviour to apply these animations to any visual element. Feel free to use it (Apache 2.0 license). I have Windows 10 UWP code based on this and it should work in WinRT for Windows 8.1 too. In both cases it requires the Behaviours SDK for WinRT.

This custom behaviour adds both the animation and a command binding. If specified the bound command will execute after the animation completes. If the command reports as not executable, neither the animation nor the command executes.

   1:      public class BehaviourBase<T> : DependencyObject, IBehavior where T : DependencyObject

   2:      {

3:

   4:          private T _AssociatedObject;

5:

   6:          public DependencyObject AssociatedObject

   7:          {

   8:              get

   9:              {

  10:                  return _AssociatedObject;

  11:          }

  12:          }

13:

  14:          public T TypedAssociatedObject

  15:          {

  16:              get { return _AssociatedObject; }

  17:          }

18:

  19:          public void Attach(DependencyObject associatedObject)

  20:          {

  21:              if (associatedObject == null) throw new ArgumentNullException("associatedObject");

22:

  23:              _AssociatedObject = (T)associatedObject;

  24:              Attached(_AssociatedObject);

  25:          }

26:

  27:          public virtual void Attached(T associatedObject)

  28:          {

  29:          }

30:

  31:          public void Detach()

  32:          {

  33:              if (_AssociatedObject != null)

  34:              {

  35:                  Detatching();

  36:                  _AssociatedObject = null;

  37:              }

  38:          }

39:

  40:          public virtual void Detatching()

  41:          {

  42:          }

43:

  44:      }

45:

  46:      public class VisualTapBehavior : BehaviourBase<UIElement>

  47:      {

48:

  49:          public static readonly DependencyProperty CommandProperty = DependencyProperty.Register("Command", typeof(ICommand), typeof(VisualTapBehavior), new PropertyMetadata(null));

  50:          public static readonly DependencyProperty CommandParameterProperty = DependencyProperty.Register("CommandParameter", typeof(object), typeof(VisualTapBehavior), new PropertyMetadata(null));

51:

  52:          private Storyboard _PointerDownStoryboard;

  53:          private Storyboard _PointerUpStoryboard;

54:

  55:          public Storyboard Storyboard { get; internal set; }

56:

  57:          public ICommand Command

  58:          {

  59:              get { return (ICommand)this.GetValue(CommandProperty); }

  60:              set

  61:              {

  62:                  this.SetValue(CommandProperty, value);

  63:              }

  64:          }

65:

  66:          public object CommandParameter

  67:          {

  68:              get { return this.GetValue(CommandParameterProperty); }

  69:              set

  70:              {

  71:                  this.SetValue(CommandParameterProperty, value);

  72:              }

  73:          }

74:

  75:          public override void Attached(UIElement associatedObject)

  76:          {

  77:              base.Attached(associatedObject);

78:

  79:              //Stupidly, these theme animations require the object to have a name :(

  80:              var fe = ((FrameworkElement)associatedObject);

  81:              var name = fe.Name;

  82:              if (String.IsNullOrEmpty(name))

  83:              {

  84:                  name = Guid.NewGuid().ToString();

  85:                  fe.Name = name;

  86:              }

87:

  88:              if (fe.Resources.ContainsKey("VisualTapDownAnimation"))

  89:                  _PointerDownStoryboard = (Storyboard)fe.Resources["VisualTapDownAnimation"];

  90:              else

  91:              {

  92:                  var pointerDownStoryboard = new Storyboard();

  93:                  var downAnimation = new PointerDownThemeAnimation();

  94:                  Storyboard.SetTargetName(downAnimation, name);

  95:                  pointerDownStoryboard.Children.Add(downAnimation);

  96:                  _PointerDownStoryboard = pointerDownStoryboard;

  97:                  fe.Resources.Add(new KeyValuePair<object, object>("VisualTapDownAnimation", pointerDownStoryboard));

  98:              }

99:

 100:              if (fe.Resources.ContainsKey("VisualTapUpAnimation"))

 101:                  _PointerUpStoryboard = (Storyboard)fe.Resources["VisualTapUpAnimation"];

 102:              else

 103:              {

 104:                  var pointerUpStoryboard = new Storyboard();

 105:                  var upAnimation = new PointerUpThemeAnimation();

 106:                  Storyboard.SetTargetName(upAnimation, name);

 107:                  pointerUpStoryboard.Children.Add(upAnimation);

 108:                  pointerUpStoryboard.Completed += PointerUpStoryboard_Completed;

 109:                  _PointerUpStoryboard = pointerUpStoryboard;

 110:                  ((FrameworkElement)associatedObject).Resources.Add(new KeyValuePair<object, object>("VisualTapUpAnimation", pointerUpStoryboard));

 111:              }

 112:

 113:              associatedObject.PointerPressed += AssociatedObject_PointerPressed;

 114:              associatedObject.PointerReleased += AssociatedObject_PointerReleased;

 115:          }

 116:

 117:          private async void PointerUpStoryboard_Completed(object sender, object e)

 118:          {

 119:              await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,

 120:                  () =>

 121:                  {

 122:                      var command = this.Command;

 123:                      var commandParameter = this.CommandParameter;

 124:                      if (command != null && command.CanExecute(commandParameter))

 125:                          command.Execute(commandParameter);

 126:                  });

 127:          }

 128:

 129:          public override void Detatching()

 130:          {

 131:              base.Detatching();

 132:

 133:              TypedAssociatedObject.PointerPressed -= this.AssociatedObject_PointerPressed;

 134:              TypedAssociatedObject.PointerReleased -= this.AssociatedObject_PointerReleased;

 135:

 136:              _PointerDownStoryboard = null;

 137:          }

 138:

 139:          private void AssociatedObject_PointerPressed(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)

 140:          {

 141:              ((FrameworkElement)sender).CapturePointer(e.Pointer);

 142:

 143:              var command = this.Command;

 144:              var commandParameter = this.CommandParameter;

 145:              if (command == null || command.CanExecute(CommandParameter))

 146:                  RunStoryboardIfNotNull(_PointerDownStoryboard);

 147:          }

 148:

 149:          private void AssociatedObject_PointerReleased(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)

 150:          {

 151:              ((FrameworkElement)sender).ReleasePointerCapture(e.Pointer);

 152:              RunStoryboardIfNotNull(_PointerUpStoryboard);

 153:          }

 154:

 155:          private void RunStoryboardIfNotNull(Storyboard storyboard)

 156:          {

 157:              if (storyboard != null)

 158:              {

 159:                  storyboard.Stop();

 160:                  storyboard.Begin();

 161:              }

 162:          }

 163:      }

Fantasy Name Generator for Windows Privacy Policy

2014-04-09T22:00:00.001+12:00

Fantasy Name Generator for Windows does not deliberately or explicitly collect any private data, such as your identity or location. Your internet connection is used only to serve adverts from the Microsoft Advertising system.

This policy and software behaviour is subject to change without notice.

Information about app usage and crashes are collected using the standard Windows Store Application reporting mechanisms.

Additional License Terms Section This app is supported by ads from Microsoft Advertising. Learn more about Microsoft’s privacy practices and your choices. Learn more link: https://choice.microsoft.com/AdvertisementChoice/

Advertising and Privacy This application may display adverts. The choice of advertising system(s) or source(s) is subject to change without notice. We currently use the Microsoft Advertising SDK. This system can use an anonymous id to help target and track ads better, if this feature is enabled in your operating system and not disabled within our application (see the Settings charm). We do not explicitly provide any additional personal details (such as location) to the advertising system, but do not make any specific promises relating to information gathered or used directly by that system at any time.
You may opt-out or configure settings relating to advertising at this link; http://choice.microsoft.com/en-US/opt-out

Your Consent
By using our services and application, you consent to our privacy policy and disclaimer.

Contacting Us If there are any questions regarding this privacy policy you may contact us using the information below;
email: yort@yortondotnet.com

Disclaimer
This program is provided "as is" without warranty of any kind, either express or implied, including but not limited to, the implied warranties of merchantability and fitness for a particular purpose.
The entire risk as to the quality and performance of the program is with you. Should the program prove defective, you assume the cost of all necessary servicing, repair and/or correction. In no event unless required by applicable law will any copyright holder, or any other party be liable to you for damages, including any general, special, incidental or consequential damages arising out of the use, misuse or inability to use the program (including but not limited to loss of use, data or profits), even if such holder or other party has been advised of the possibility of such damages.
By accepting this disclaimer you agree to use the software at your own risk and irrevocably waive all your rights to seek damages or relief of any nature from us arising out of or in connection with your use of the software.

Flupr for Windows – Privacy Policy

2014-03-02T22:04:00.000+13:00

What Information Do We Collect and How Do We Use It ? We collect information you provide to us for the purposes of submitting to the Yahoo Flickr photo sharing service. This includes but is not limited to; images for upload, titles, and descriptions. This information is collected by our application and submitted to Flickr, but is not sent to or stored on our own or third party servers, except for statistical analysis or possibly unintentionally as part of crash reports.
We also collect some information from the Yahoo Flickr photo sharing service relating to your account. This may include but is not limited to; your Flickr user name, id, avatar, existing sets, groups, tags, images, and contacts. This information is collected by our application and may be stored locally on your device, it is not submitted to our own or third party servers except possibly unintentionally when crash reports are submitted.
In the event any Flickr or other personal data is unintentionally captured in a crash report, this information will be used solely for the purpose of diagnosing and fixing the issue causing the crash.
We also collect statistics and information about our application usage, both 'globally' and anonymously per user. That is statistics and data relating to your usage of the application will be grouped together under a single anonymous identity, but we will not be able nor attempt to tie them to you as an individual, ensuring your privacy. This data includes but is not limited to; number of application launches, number of photos uploaded, crash information and details, feature usage counts, and number of times adverts could not be fulfilled. This information is used primarily for the purposes of improving the application, user experience and deciding which features to add or remove. However, we reserve the right to use some basic, anonymous or aggregate data for marketing and advertising purposes. This includes but is not limited to; total number of users, total number of uploads, total number of uses etc. This data may be hosted for us by a third party, and the host is subject to change without notice.
We reserve the right to delete or destroy any information gathered and stored by us or a third party on our behalf, without notice.

Do We Disclose Any Information To Outside Parties ? We do not sell, trade or otherwise transfer to outside parties your personally identifiable information. This does not include trusted third parties who assist us in operating our website, gathering an storing statistics, conducting our business or servicing you, so long as those parties agree to keep this information confidential. We may also release your information when we believe release is appropriate to comply with the law, enforce our service policies, or protect ours or others rights, property or safety. However, non-personally identifiable visitor information may be provided to other parties for marketing, advertising or other uses. We can also release your information when you allow us to do so.

Your Privacy - What We Won’t Do
We will not sell your personal data or contact information to any third party.
We will NOT use your images or unique content for marketing or advertising purposes without your consent.
We will NOT collect or store your Flickr account login details. We use the standard OAuth mechanism to connect to Flickr and obtain a token, which is then used for subsequent logins. Your user name and password are only ever submitted to Flickr, not to our application or services. You can revoke our application's access to your Flickr account at any time using the Flickr service.

Advertising and Privacy
This application may display adverts. The choice of advertising system(s) or source(s) is subject to change without notice.
We currently use the Microsoft Advertising SDK. This system can use an anonymous id to help target and track ads better, if this feature is enabled in your operating system and not disabled within our application (see the Settings charm). We do not explicitly provide any additional personal details (such as location) to the advertising system, but do not make any specific promises relating to information gathered or used directly by that system at any time.
You may opt-out or configure settings relating to advertising at this link; http://choice.microsoft.com/en-US/opt-out

Bing Maps
Some optional features may use the Bing Maps services. See the end user terms of use for the Bing Maps service here; http://www.microsoft.com/maps/assets/docs/terms.aspx

When using the geo-tagging feature we may also use your current location, as provided by your device, if you allow access. This used only to display your current location on the map, and tag the image at that location if it doesn’t already contain geo co-ordinates or if you manually choose to tag at that location. First use of this feature will prompt for access, and access can be granted or revoked via Windows settings at anytime.

Additional License Terms Section This app is supported by ads from Microsoft Advertising. Learn more about Microsoft’s privacy practices and your choices. Learn more link: https://choice.microsoft.com/AdvertisementChoice/

Your Consent
By using our services and application, you consent to our privacy policy and disclaimer.

Contacting Us If there are any questions regarding this privacy policy you may contact us using the information below;
email: yort@yortondotnet.com

Disclaimer
This program is provided "as is" without warranty of any kind, either express or implied, including but not limited to, the implied warranties of merchantability and fitness for a particular purpose.
The entire risk as to the quality and performance of the program is with you. Should the program prove defective, you assume the cost of all necessary servicing, repair and/or correction. In no event unless required by applicable law will any copyright holder, or any other party be liable to you for damages, including any general, special, incidental or consequential damages arising out of the use, misuse or inability to use the program (including but not limited to loss of use, data or profits), even if such holder or other party has been advised of the possibility of such damages.
By accepting this disclaimer you agree to use the software at your own risk and irrevocably waive all your rights to seek damages or relief of any nature from us arising out of or in connection with your use of the software.

Share Contact for Windows Phone 7

2012-03-10T17:09:00.000+13:00

Unlike other contact sharing applications for Windows Phone 7, Share Contact allows you to both (easily) send and receive contact details. Other apps allow you to send contact information or turn it into a QR code, but Share Contact is one of the few (or possibly the only app) that allows you to easily save contact data from an SMS or email message into your phone book. Like other apps you can share a contacts details via email, SMS or QR code. The receive function works best with data that was also sent by Share Contact, but can also handle data from a number of other popular contact sharing applications in the WP7 marketplace. Note that when you want to receive a contact’s details via QR code, you don’t need an app on WP7 at all – just use Bing Vision Search.

Finding a Contact

Finding a contact works much like the people hub in Windows Phone 7. You are presented with a list of contact which you can scroll through by flicking or panning vertically with your finger. Alternatively you can press one of the boxes with a letter in it to bring up a ‘jump list’ which allows you to quickly move to a particular location in the list if it’s very large. Finally, you can press the search button in the app bar at the bottom of the screen to display a search field, simply key part of a name into the search field and the list will be filtered to show only contacts that match your search criteria.

On the settings screen you can also choose to filter out contacts that don’t have certain types of information (i.e phone number or email). More on that later.

Sharing a Contact

Once you’ve found a contact, just tap on them once to bring up the share screen. On the first page of the share screen you’ll see options for which kinds of data you want to share, i.e business details, personal details, website etc. Check the box next to each kind of information you want to share. You can now either press one of the share option buttons at the bottom of the screen (SMS, Email or QR code). If the contact you’ve selected has multiple profiles linked together then the information from each profile will be merged together into a single set of information to be shared.

If you want to share information only from one profile for this contact, such as a specific Microsoft Exchange account then flick left or right with your finger to pan through the linked profiles for this contact. Each page will show the name of the account and then the contact details that account contains for this contact. When you find the account with the details you want to share, press one of the share buttons in the app bar at the bottom of the screen. The choices you made on the first screen for what kinds of data you want to share will still apply, so if you chose to only share business contact details and the profile you’ve selected contains both personal and business details, only the business data will be included.

Using Favourites

You can mark a contact as a favourite by performing a tap-and-hold on the contact in the main contact list, then tapping on the ‘favourite’ menu that pops-up. When you mark a contact as a favourite it moves to the favourites page and becomes an animated tile, switching between the contacts name and profile image. You can access the favourites list by swiping left or right with your finger while on the main screen showing the contact list.

If you tap on a favourite tile for a contact the share page for that contact is shown. Using favourites can be very convenient when you have contacts you often share, such as work colleagues.

Sharing Your Own Details

Often you want to pass your own details on to somebody. This couldn’t be easier. From the main screen with the contacts list displayed, just tap on the ‘share me’ button (which looks like a person with an arrow sticking out of them). If you’ve already setup your contact details then you’ll go straight to the share page for yourself. If you haven’t setup your details yet, you’ll be prompted to do so. You can add or edit information about yourself at any time on the settings screen, and if you have yourself in your phonebook as a contact you can even loaded your details automatically from that contact record. Unfortunately due to restrictions on what 3rd party applications can do, we can’t automatically read your phone number, name and email addresses etc. from the phone, so you need to setup this information at least once.

Receiving a Contact from SMS or Email

Receiving a contact from SMS or email is pretty much the same process, although slightly easier for SMS messages. First you need to open the SMS or email message and copy the text of the message. For an SMS message just tap-and-hold on the balloon for the message, then choose ‘copy’ from the menu that pops-up. For email messages, you need to tap once on a word inside the email message so the word highlights, then drag the arrows at the end of the highlight until the full message is highlighted. When all the text is highlighted, tap the copy icon (two pages in a circle) that will be displayed just above the selected text.

When you have copied the text, open Share Contact and flick left to go to the ‘Receive’ page. Tap in the large box display, and then press the ‘paste’ button just above the keyboard (looks like a clipboard in a circle). The text of your message will now be shown in the box you tapped in before. Now just tap the ‘save’ button (looks like a floppy disk in a circle) in the app bar at the bottom of the screen. This will bring up the standard WP7 Save Contact screen with all the field prepopulated for you. You can edit the data if you want, or else just choose to save the contact by pressing the save button at the bottom of the screen again.

Settings

The settings screen has two pages. The first page allows you to choose settings for how the application works and looks. The options include filtering out contacts that don’t have a particular type of contact information such as phone number, email address or physical address. These options are used in an ‘or’ fashion, so if you check phone number and email, then contacts that have either a phone number, an email address or both will be displayed.

You can also choose whether or not a link to Share Contact is automatically included in SMS and email messages sent from the application, to make it easier for people receiving the message to make it easier to find the app and download it themselves.

Finally, you can choose whether contacts are sorted by first or last name when displayed in the contact list.

If you swipe left or right on the settings screen, you’ll go to the ‘my details’ page which allows you to enter and edit your own contact details for later sharing. There is also a ‘load from contact’ button which will import your details from an existing contact record, if you have yourself loaded as a contact for some reason.

Technorati Tags: WP7,app,download,devices,smartphone,Windows Phone 7,Share Contact

Why No One Has The Smartphone Right Yet

2012-02-26T19:51:00.001+13:00

The number of iPhones sold per second now outnumbers babies born per second, Android is selling even faster, and Microsoft are winning awards and great user reviews everywhere for their Windows Phone 7 platform (although they have only a tiny market share right now). Given all that, my title for this post might seem a bit provocative, so let me explain.

Regardless of the success of an individual platform in terms of reviews, user approval or sales, there seems to be one area where smartphone manufacturers are failing many consumers (myself included). This failing is the paradox of choice. You see, if I decided I wanted to buy a new phone today, I could not decide which one to to get, and no matter what I decided I would still come away with some level of buyer’s remorse.

On the Apple platform, assuming you want an actual phone (rather than an iPod touch or iPad), you don’t really have any choice. All you can get is the iPhone, and all the models are pretty similar. Sure, there are different models, like the iPhone 3, 3GS, 4, 4S etc. but the choice is often between a new model and an older model or two models that are very similar and differ only in in minor hardware specs or the OS version. Basically, if you want an iPhone with a 4.3 inch screen then you’re out of luck. If you want one with a faster processor, a different type of camera sensor or megapixel rating, a better quality external speaker etc. then you have to look at another platform. You are forced to choose from a very narrow band of options from Apple. On the plus side, you don’t suffer so much from the paradox of choice because your options were limited in the first place. You can be confident you bought the iPhone that best suits you, even if it isn’t the perfect smartphone for you. Of course if you really need or want something Apple doesn’t offer, then your only choice is to go to one of the other platforms.

Android has the reverse problem. There are too many options to possibly evaluate them all, so you can’t know you bought the phone that best suits you. What’s more most manufacturers and carriers heavily customise the user interface of Android (to the point where two different android users can’t necessarily use each others phones for simple tasks like searching contacts). This adds another dimension of choice over and above the hardware. No matter what you buy, there will probably be something not quite right about it, and given you had all those other choices you didn’t explore you’ll no doubt get some quantity of buyer’s remorse, sooner if not later. This is especially true since the quality of Android phones can vary greatly, especially across price ranges.

Windows Phone 7 sits somewhere in the middle. The minimum spec for the devices has, so far, kept truly awful devices off the market. Like Apple and unlike Android, you don’t buy a WP7 device that just doesn’t run well because the hardware can’t cope. There’s also more variety and more brands of phone than you get from Apple, and fewer than you get from Android. Unfortunately, this isn’t the best of both worlds.

Yes, you have a choice with WP7, but that still means you have to go out and evaluate as many phones as you can before deciding on one. It turns out, evaluating a phone in a store is really hard (for any platform or manufacturer, although slightly better for Apple product if you’ve used one before). Even when you know the OS fairly well, it’s not until you’ve taken the phone home that you find out whether the camera works in low light, or how the manufacturers customisations work, or what specialised apps the manufacturer has released that only work on their phones, whether that reception on that phone is better or worse in the places you regularly visit (or if the new models antenna is flawed) etc. There really should be a business that allows you to rent a phone for a week under no obligation to buy (but for a small fee) and then sells it to you (perhaps less the rental fee) if you decide you do actually like that model, otherwise you return it for a different model to try.

In any case, not only is the evaluation hard but comparing two models of WP7 often leaves you with an impossible choice. For example, if I was going to buy a new phone today the first two models I would look at (assuming they were available in my region) would be the Nokia Lumia 900 and the HTC Titan II.

The Titan has a larger screen, which I really like for all non-phone call activities (i.e txting, apps, games, browsing). Larger screens do make phones a little uncomfortable to use for calls but I’m prepared to live with that. Some reviews I’ve seen online suggest the camera is better than that on the Lumia (at least for now, apparently Nokia are working on a software update to improve camera quality on the Lumia models). I also know that HTC produce a really simple but good Flashlight application that is only available on their devices, and the HTC Attentive phone app. There other other flashlights in the WP7 marketplace so I’m sure I can replace that easily, I just like the one I already have. The Attentive Phone app is harder to replace however. Third party app developers don’t have access to the API needed to create an app like this, so it has to come from the manufacturers and I don’t believe Nokia have built anything like this. Really, I think the features provided by Attentive Phone should be built into the OS (perhaps as options), but they aren’t.

So if I buy the Titan I get a big screen, probably a good camera, and HTC Attentive Phone all of which are good. On the other hand Nokia have their ‘clear black’ display, which is really nice even if the screen is smaller. They also have Nokia Maps and Nokia Drive which are far superior to the maps offering baked into the OS. As far as I know, HTC (nor any other manufacturer) has a competing offering in that space for now. There are (expensive) navigation apps available in the marketplace, so I could get something for the HTC, but the Nokia offering for maps seems like the best. The Nokia is also very nice to hold and look at (I’ve seen the 800, I presume the 900 is similar). While I haven’t seen the Titan II in person, my existing HTC device has some quality issues with buttons that rattle and cracked chrome surfaces and I think the Lumia is probably better in that regard.

The OS will be pretty much the same on both although not comparing the two phones side by side I can’t be sure of what differences I might find. My HTC has tethering and can send MMS message fine, while my friends Samsung WP7 device can’t do either even though we’re both running Mango (on his phone there is no setup for the MMS stuff, and no OS update yet for his phone to enable tethering support). On the other hand his (in-built OS) camera app has more scene modes, and more options for controlling the camera itself (exposure settings and the like). Does either the Lumia or the Titan support tethering ? My HD7 didn’t use to but a recent update added the feature. My bosses Lumia 800 didn’t when he first got it, and he hasn’t mentioned an upgrade having added it so does that mean if I buy the Lumia I loose tethering ? Does the 900 have it and the 800 doesn’t ?

Given all of this you might think it’s impossible to buy a smartphone and be happy with it. That’s clearly not the case. I am happy with my HD7, and I know users of all three platforms who are happy with their handsets. What I’m really saying is that despite the proliferation of choices, and the fanboi-ism around each platform, there is still a section of the consumer market that is not perfectly catered for by any of the major platforms and the situation isn’t necessarily getting better.

Microsoft and their handset partners could fix at least some of the WP7 platform problems by ensuring that (hardware and firmware allowing) all manufacturer specific apps were available for purchase on other handsets. Microsoft could even mandate this. For example, if I bought a Nokia handset I would get Nokia Drive and maps free because that’s what happens now, but if I buy another brand of handset I can still purchase and use those apps (even if at exorbitant prices).

This probably won’t happen because manufacturers and carriers will be afraid of losing their competitive advantage, but that’s not necessarily true. If I did decide to buy a Titan rather than a Lumia but I bought the Nokia apps, Nokia would still earn money from me they wouldn’t have got otherwise and I’d still be staying in touch with the Nokia brand. That might lead me to buy a Nokia again in the future, rather than just putting them out of mind because I’m now an HTC customer. Right now, whichever brand I go with leads me to pretty much ignore the other (if only to avoid further buyer’s remorse), and profits only one manufacturer. I would suggest it’s better to compete on hardware as much as possible while still profiting from your losses when a consumer chooses another brand of handset.

Technorati Tags: Smartphone,Device,Manufacturer,WP7,Android,Apple,iPhone

Windows Phone 7 – Syncing Email Over VPN

2012-02-19T11:25:00.001+13:00

At the moment the Exchange server we use at my office isn’t available over the internet in the way it needs to be in order to sync email, contacts, calendar etc. to my WP7 device. Even with the ‘Mango’ update to Windows Phone 7 VPN connectivity is not supported on the phone, so I can’t connect via VPN over the internet from the phone either. This means my work mail only syncs while I’m near the office and connected to the WiFi network. This is actually ok with me, and we’ll probably change the Exchange server configuration later anyway.

However, I recently discovered I can sync my phone to the Exchange server via a VPN if I use a PC as the middle man. For example, I can connect my phone (via cable) to my laptop, and open the VPN connection on the laptop. This will then allow the email app on the phone t connect to the Exchange server and sync.

I believe this needs the Zune software correctly installed on the PC (so that it opens automatically when the phone is connected), but it certainly seems to work fine if that is the case.

Technorati Tags: WP7,Windows Phone7,Sync,Email,Exchange,VPN

Windows Phone 7 Supports vCards

2012-02-19T11:18:00.001+13:00

This may not be news to everyone, but something I learned today is Windows Phone 7 supports vCards for receiving contact information.
To receive a contact via a vCard you can;

Email yourself a .vcf file (which can be exported from Outlook or many other contact management applications). Open the attachment in your WP7 email application and the OS will automatically open an ‘Add Contact’ page with the fields pre-populated.
Download a .vcf file from the internet. A great way to do this is via SkyDrive, but be warned (as with many file formats) you need to use the SkyDrive website to download the file not the app. The app only allows downloading files with a limited number of file extensions, and .vcf isn’t one of those.
Turn the contents of the vCard file into a QR code. This is sort of the more obvious way to do it, as there are several apps in the marketplace that allow sharing contacts this way. However, you can also use an online tool to convert the data (just try a Google search for ‘qr code generator’) into a qr code if you don’t want to go the app route. Just open the .vcf file with notepad, copy the text and then paste it into the web page to generate the QR code.

All of these are great ways of sharing contact info. Unfortunately the WP7 API for third party apps doesn’t allow sending apps sending emails with attachments, so you can’t email a contact out of your phone in VCF format (at least not easily).

Technorati Tags: WP7,Windows Phone 7,VCard,Contact,QR Code

Fixing Zune Sync Error c00d11e4 (800c000e) on Your HTC HD7 Windows Phone

2012-02-12T16:11:00.001+13:00

I fixed this over 6 months ago, but I forgot to blog about it then and only just remembered.

When I first got my HTC HD7 Windows Phone 7 device I discovered the Zune sync didn’t work for getting photo’s and video off the phone. I could get stuff onto it fine, music synced fine, and all the app stuff worked, just no pictures/video came off the phone.

Apparently I wasn’t alone, it appears a number of HTC users have had the same problem. I tried a number of Google searches for a solution but didn’t find any quick answers on how to fix it. Eventually I stumbled upon the post I linked above at the Microsoft Answers site and after digging through the posts I found the solution.

Apparently the problem is to do with file associations for images and video on the PC (nothing to do with the phone). I had jpg and other image files set to be opened with an old copy of Paint Shop Pro I bought years ago, not the default programs Windows normally has associated with these file types. Once I reset the file associations for the images and video, the sync starting working again.

I’ve since been able to reset Paint Shop Pro to be associated with those file types again, and the sync is still working. So, if you’re having this problem, try resetting your file associations for the afflicted media file types. A reboot before attempting to sync again may also be required (I can’t recall now).

As pointed out by ‘Ashedd’ on the relevant Microsoft Answers post, here’s the steps to reset your file associations;

WARNING: Altering your registry incorrectly can cause serious problems with your Windows operating system. If you are not confident of your ability to make these changes or recover from a serious software failure, get someone more experienced to help you or Google for other ways to reset your file associations.

Click Start , and then click All Programs.
Click Accessories, and then click Run.
Type regedit, and then click OK. If you are prompted for an administrator password or for a confirmation, type the password, or click Allow.
In the navigation pane, locate and then click the following registry subkey:
HKEY_CLASSES_ROOT\.jpg
In the right-hand pane, double-click (Default).
In the Value data box, enter jpegfile and then clickOK.
Exit Registry Editor.
Try to sync a photo\video taken with the phone.

Technorati Tags: WP7,Windows Phone 7,Smartphone,Zune,HTC,HD7,Sync,Error,Images,Media,Video

1 Tap Reminder for Windows Phone 7

2012-01-31T18:40:00.000+13:00

My second WP7 application, 1 Tap Reminder, is now available in the marketplace.
1 Tap Reminder is almost certainly the quickest and easiest way to set reminders on your Windows Phone 7 device. Set alarms for a certain period from now, or a specific time of day with as little as one tap.

So, how does it work ?

Really Quick Reminders

When you first open 1 Tap Reminder you’ll see the ‘one-tap timers’ screen where you can choose when you want a reminder set. Depending on your preferences you can use the full size tile screen which makes it easy to select a timer even while on the move but requires scrolling to see more timers, or the smaller tile size which allows more timers to be seen at once.

The two timers you use the most will automatically sort to the top left of the list, and the ‘Specific Time’ timer will always be the last entry in the list. This makes it easy to locate your favourite timers.
To set a timer quickly, just tap on it with your finger. Depending on your settings either;

Your phone will set the reminder and vibrate to confirm, then the app will exit (the default behaviour), or, your phone will switch to the ‘reminders’ page and show you the newly set reminder.

When the designated time arrives, your phone will show your reminder even if the app isn’t open. You’ll also have the option of snoozing the reminder (this is provided by the WP7 OS and I can’t change the snooze options, sorry).

Viewing and Cancelling Reminders

From the main screen you can swipe left or right to see the reminder page. This page shows you both reminders that have passed and reminders that are yet to occur. Reminders that have passed are shown with either a slightly darker or lighter background colour (depending on your theme) than reminders that haven’t occurred yet.
To cancel a reminder, just tap on it once then choose ok on the confirmation message box that appears.
Reminders are automatically removed 24 hours after they have past, so you don’t need to cancel old ones (unless you’re bored or suffering from OCD).

Setting Reminders with Text

Got too many reminders, or one set so far in the future you’re afraid you’ll forget what it’s for ? You can set custom text for your reminder nearly as easily as setting a quick reminder. Just tap and hold on the timer you want to set, and choose ‘set reminder’ from the menu that pops-up. This will display the “reminder details” screen.

On the reminder details page you can tap in the ‘reminder text’ field and key in your own text, or you can tap on one of the preset prompts to quickly set the text. Double tap on an item in the preset list to choose that text and set the reminder. Alternatively tap once on an item in the list, then tap in the text field to edit the text if you desire, and finally click the tick button at the bottom of the screen to set the reminder.
To cancel setting the reminder, tap the back button on your phone.

Setting a Reminder for a Specific Time of Day

When you choose the ‘Specific Time’ timer, regardless of whether you single tap or use the tap and hold menu, you will be shown a variation on the details screen. Like the normal details screen this allows you to set custom text for your reminder, but it also allows you to pick a specific date and time for the reminder to occur at.
You choose the time first. Tap on the time field to bring up the time picker and enter the time. If the time you choose is after the current time today, then the date field defaults to today. If the time you choose is before the current time today, the date field automatically changes to tomorrow. In either case, you can tap on the date field and choose a different date if you wish.
When you’ve set the date and time, and selected your text, tap the tick button at the bottom of the screen to set the reminder.

Pinning Timers

For truly one-tap reminders, you can pin timers to your start screen. Just tap and hold on a timer inside the app, then choose ‘pin to start’ from the menu that pops-up. A new tile will be created on your start screen for the timer. From that point on, you can set the timer just by clicking the tile on your phones main page, no need to open the app first.
This works for any timer, including custom timers for specific times of day and/or with text assigned, or for simple timers that are just a period of time.

Customising the Timers List (Paid Feature)

If you don’t like the default list of timers, you can change it. To remove a timer, just tap and hold on it and then choose ‘remove’ from the menu that pops-up.
To add a new timer, tap on the three dots at the lower right of the screen, then on the menu that slides up choose ‘add timer.’ This will bring up a new screen that allows you to enter the details of the timer you want to add.

On the add timer screen you first select the type of timer you want to create. You can choose between a timer for a ‘duration’, i.e 23 minutes from the time the timer is set, or you can create a timer for a specific time of day, i.e 3:00 p.m.
Next, enter either the number of hours and minutes for the timer (if you chose ‘duration’), or the time of day. The fields available will change to suit, depending on the type of timer selected.
Finally, you can optionally enter the default text for your timer. If you enter no text, the word ‘reminder’ will be used by default. If the text you enter happens to match an entry in the preset prompts list then the image associated with that text will be shown in some places where the reminder is displayed (such as the reminders page, and the back of pinned tiles).
To save your reminder, tap the tick button at the bottom of the screen. To cancel, tap the back button on your phone.

Customising Preset Prompts (Paid Feature)

On the detailed reminder screen you can remove a preset prompt by tapping and holding on it and then choosing ‘remove’ from the menu that pops-up.
You can add a new prompt by clicking the three dots at the lower right hand corner of the screen (while on the reminder details page) and then choosing ‘add preset text’ from the menu the slides up.
On the ‘add preset’ screen you can enter the text for your preset by tapping in the text field and keying in the value you want to use.
You can also tap on the green square to choose an (optional) image to associate with this preset. This image will be shown on the reminders page inside the app, and on the backs of timers you pin to your start screen.
When you’ve made your choices you save the preset by tapping the tick button at the bottom of the screen. To cancel, tap the back button on your phone.

Settings

The settings screen allows you to change the behaviour of the app and to reset the app data to the default values. You can scroll the screen up and down by flicking with your finger to see more options. To access this screen, tap the three dots in the lower right corner of the screen while on the main page.

Enable 1 tap reminder set

If this setting is on, tapping once on a timer sets the reminder immediately with the default text. If this setting is off, tapping once on a timer always shows the reminder details page.

Auto-exit on 1 tap reminder set

If this setting is on, setting a reminder via a single tap causes the phone to vibrate to confirm the reminder has been set, then automatically closes the app. If you don’t like this behaviour, turn this setting off and the app will move to the reminders page and show the newly set reminder instead of closing.

Auto-exit on detailed reminder set

This setting is the same as the previous one (Auto-exit on 1 tap reminder set) but applies to reminders set via the the reminder details page rather than the one-tap method.

Use small tiles

This setting changes the size of the tiles shown on the timer screen, small tiles mode show more timers at once and reduces the need for scrolling, but make the touch area for each timer smaller.

Add Timer

This button allows you to add a new timer, just like the ‘add timer’ menu option on the main screen.

Add Preset Text

This option allows you to add a new preset prompt to the list available on the detailed reminder screen, just like the ‘add preset text’ menu option on the reminder details screen.

Reset Buttons
These buttons reset the data named on each button to it’s default values.

Technorati Tags: WP7,1 Tap Reminder,Windows Phone 7,Mango,Application

Meal Timer

2012-01-17T21:10:00.001+13:00

Meal Timer is my first Windows Phone 7 application (requires Mango update for WP7). There are a number of apps in the WP7 Marketplace that are ‘kitchen timers’ and allow you to set reminders or alarms for particular time, but Meal Timer is unique (as far as I know) in that it allows multiple timers to be set so they all end at the same time. This means the application itself ensures your meat, vegetables, sauces and other meal components are all ready at the same time. Unlike most other kitchen timers that assume you are cooking immediately, you can schedule the meal to be ready at a particular time, and Meal Timer will set alarms so everything is ready at that time (or you can start cooking right away if you want).

So, how does it work ?
First, download the application from the Marketplace. Then open the application from your application list (or pin it to your start menu for a beautiful tile showing a tasty homemade hamburger, and open it via the tile).

When you first open Meal Timer you will see the main ‘panorama screen’ which will be set which will be scrolled to the ‘components’ page and looks like this;
To start, you need to add some items to cook. Do this by pressing the button at the bottom of the screen marked with a + symbol. This will bring up the ‘Add Component’ window.

Click in the ‘Name’ field and type the name of something you’re going to cook, i.e 'Chicken’. Note, you don’t have to add the items in any particular order, Meal Timer will sort the items into the correct cooking order based on time, later when we tell it we’re ready to start or schedule cooking.

With the item name entered, you now need to enter the cooking time. First, you need to go to the cooking time box. The easiest way to do this is to press the enter button on the on-screen keyboard. Otherwise, you can tap in the visible portion of the Cooking Time field (you can flick up on any part of the dark background area behind the text fields to scroll them up so it’s easier to see and tap on the Cooking Time field). Alternatively, you can press the back button on the phone itself to close the keyboard, then tap in the Cooking Time field, but pressing enter is the easiest thing to do.

Once you’re in the cooking time field, simple enter either a number of whole minutes, or a number of hours and minutes separated by a colon (:) character. For example, 75 and 1:15 both refer to 1 hour and fifteen minutes. When you’ve entered the time, either press enter on the on-screen keyboard or the button at the bottom of the screen marked with a plus to add this item and start entering another. If you’ve entered all the items you want to enter (or if this is the last item you intend to enter), you can press the button at the bottom of the screen marked with a tick (check mark). If you’ve changed your mind about entering the item currently shown on screen, press the back button on your phone to return to the main screen.

Back on the main screen the components list will now show all the items you’ve entered.
If you want to change the time you entered on one of these items, click on the red area representing the item. If you want to remove an item from the list entirely, click on the trash can icon on the right hand side of the item you want to delete.
You can scroll the list of meal components up and down by swiping with your finger.
To start or schedule cooking, press the button at the bottom of the screen marked with an arrow head (like the play button on a DVD player). This will bring up the Start Cooking dialog.

If you want to start cooking right away, click the Start Now check box to place a check mark in it. Alternatively leave the Start Now check box unchecked, select the time you want your meal to be ready at below it. Note, you can use the settings screen to change the default meal time. When you’ve made your choice, press the button at the bottom of the screen marked with a tick (check mark). If you’re not ready yet or have changed your mind, press the back button on your phone. When you do start or schedule cooking you will be returned to the main page and the meal components you entered earlier will move across to the timers page. You can move between the components and timers pages by swiping left or right on screen when the main page is shown.

The various components of the meal will be sorted by cooking time so the item that is going to take the longest to cook is started first, and so on. An ‘alarm’ will be set on your phone for the time each item needs to start cooking, and another alarm will be set for when all the items are ready. These alarms will go off even if you close the Meal Timer application.
If you leave Meal Timer running, the components on the timers page will turn read when they need to start cooking (as well as the alarm going off) and the system will start counting down the time left for that item. Each timer shows you the scheduled start time, the total cooking time for that item, and the time remaining (counting down while the timer is running).
Timers that are grey indicate they have not started yet. When a timer completes, it turns black for about a second and then disappears.
You can scroll the list of timers up and down by swiping with your finger.

And that’ about it ! There is a setting screen, which you can access from the main page by pressing the three little dots near the bottom right and then choosing ‘settings’ from the menu that pops up. The settings screen allows you to set the sound used for the alarm and the default meal time, as well as delete any data the application has saved, and there are also shortcuts to rate/review and buy the application in the WP7 Marketplace.
So, what if you want to schedule multiple courses for a single meal ? Easy, just perform the steps above once for each course and choose a different ‘Meal Ready at Time’ for each course on the Start Cooking screen. All the timers will mix in together on the timers page, but all the items for each course (scheduled together) will be ready at the same time. Simple !
If you have any suggestions, problems or queries please contact me via yort@yortondotnet.com.

Visit Meal Timer on Facebook.

Technorati Tags: meal timer,windows phone 7,wp7,application,mango

DataViews and Filter Expressions

2011-06-30T11:06:00.001+12:00

Yesterday I helped a colleague with a problem involving a DataView that would not find any rows when given a valid filter expression that should have returned rows. It took a little while to figure the problem out, so I thought I’d post the solution in case anyone else is stuck with the same issue.

In our case we had a DataTable (as part of a DataSet) that contained rows. Using the Debug Visualiser for the DataSet we could view the rows and see the data we expected. We had a column called BranchId and we wanted to find rows with a specific value in this column. If we wrote our own loop (we’re working in .Net 2.0 so no LINQ etc.) to iterate all the rows, request the value of the BranchId column and check it against the value we were searching for (17 in the first case) we found the row no problem. However, if we created a DataView with a filter expression of “[BranchId] = 17” now rows were returned.

The usual culprit here is ‘RowState’, where you must tell the DataView whether to include added rows, deleted rows, or to look at the modified or original versions of the rows. However, our code was correctly telling the DataView which row states to check, and the row state for the rows in question matched, so this was not the problem. Interestingly if we called AcceptChanges on the DataSet then the view would work fine, but we couldn’t do this because we needed to retain the current row state value for later in our algorithm, and AcceptChanges resets the row state.

In the end it turned out the problem was caused by a failure to call ‘EndEdit’ on the row. Specifically, the BranchId value for these rows had been programmatically set via code earlier in the application and EndEdit hadn’t been called on the row afterwards. This meant the proposed value was 17, but the current and original values were‘unset’ (note, not actually null as requesting the original value threw an exception saying the value didn’t exist, even though nulls were allowed). Calling EndEdit on the row moved the value from ‘Proposed’ to the current value without affecting the RowState, and then the DataView filter worked fine.

Of course this all makes perfect sense when you think about it, and of course you should call EndEdit to commit changes to a DataRow when you’ve finished making them. The confusing issue in this case was that ONLY DataView was checking the ‘current’ value of the field. Everything else (the Debugger Visualiser and other debug tools, and any code we wrote to check the column value without specifying which value to check) was checking the proposed value by default. This made it appear like the DataView or filter expression was at fault, and there was no help, guidance or clear hint that the issue was caused by the same field having two different values simultaneously. Also, since most of our edits occur through controls like the DataGrid, EndEdit usually gets called for us by the control. It was only because we had (unusually) set the DataSet value programmatically that we needed to manually call EndEdit ourselves. Interestingly, there also doesn’t appear to be anyway to tell the DataView to check the proposed value rather than the current (committed) value.

So, moral of the story (and a good thing to remember anyway), always call EndEdit on your DataRows after you’ve programmatically made changes to them (and you want to keep/commit those changes in memory).

Technorati Tags: .Net,C#,DataSet,DataView,Expression,Filter,RowState,EndEdit,AcceptChanges

Windows 8 for software developers: the Longhorn dream reborn?

2011-06-24T15:55:00.000+12:00

I really wish there would be a public anouncement from Microsoft themselves clarifying a few things, but at least this puts some of the recent rumours/leaks in a positive light (rather than all the drama and doomsaying that has been going on);

Windows 8 for software developers: the Longhorn dream reborn?

Why Apple Enthusiasts Are Wrong About Windows 8 - Techland - TIME.com

2011-06-07T17:06:00.000+12:00

Why Apple Enthusiasts Are Wrong About Windows 8 - Techland - TIME.com

Will Microsoft Own the Web (Again) ?

2011-06-07T09:58:00.001+12:00

Contentious title, I know, but that’s just to get you here. If you’re reading this, it worked.

With the recent news about Windows 8 from Microsoft, like many, I’ve been pondering their future. Since I work for a software development company heavily invested in Microsoft tools and technologies, my future is tied to theirs so this makes sense. It’s hard to know what Microsoft’s strategy is, or if they have one at all. Sometimes it looks like they’re doing new cool things (WP7), although uptake by the market doesn’t always follow. Other times it looks like the right hand isn’t talking to the left, or the whole company is in panic mode. Much has been written about how Microsoft is behind it’s competitors, or no longer relevant, how Ballmer is (allegedly) driving it under and so on. There have also been the debacles over the question of the future Silverlight and the use of the admittedly idiotic term “Native HTML” all of which have caused laughter from some sections of the industry. All this may or may not be true at present, but I’m wondering if there isn’t a secret plan that’s being missed by most. I wonder if perhaps those laughing should stop and think about this a little bit longer.

Microsoft could be said to have owned the web at one stage, Netscape/Mozilla created the first browser but Microsoft came out with IE and basically crushed them. Let’s not forget that Microsoft is generally pretty good at playing catch-up even when it’s later to the game, it is good and experienced at being the underdog. We can argue about which product was actually better, or whether the business practices employed by Microsoft were fair and so on, but in the end they had far more of the browser market than any other. Of course, while IE is still widely used today, other browsers are growing faster and have stolen a significant portion of that market share.

Combine that with the up take in portable devices, mostly Smartphones and tablets like the iPhone, iPad, and Android phones and tablets, and Microsoft seems to be fighting a losing battle. Are Windows 8 and IE 9 part of a plan to turn that around ? That might sound ridiculous, obviously Microsoft are going to release new products, obviously they’re supposed to be better than what came before, and obviously Microsoft hopes those products will save them. What I’m asking is are Windows 8 and IE 9 the first steps in a plan to create the web client platform of choice ?

Hardware acceleration in the browser (IE9), a (supposedly, depending on your personal taste) cool and striking new UI for Windows based on the already much lauded WP7 interface, and an OS designed to run across a variety of platforms and form factors ? HTML5 and JScript as the development tools of choice for Windows 8? What if “Native HTML" is supposed to mean “Native and HTML” or something similar ? Taking HTML5 and JScript seriously opens up a lot of applications to running on Windows 8 and being sold through the new Windows 8 app store that wouldn’t have been if it was native only. If Windows 8 actually provided additional capabilities for web applications, things that couldn’t be done on other platforms, then web developers (at least some of them) would get excited about that. All of a sudden we have a class of (good/excellent) web applications that either only work, or work best on Windows. What if the plan is to produce the killer client OS for using the web ?

You may be terrified by this concept, after all, many see the web as a place free of dominance by a single client platform and want it to remain that way. Or you might just hate the idea of Microsoft being the winner here. You may scoff. Who knows if Microsoft can actually pull this off (no doubt many would argue they can’t)… but what if Microsoft turned Windows into the iOS of the web ? What if you could get web and internet experiences like no other, but only on the Windows platform and that platform ran on your smartphone, your tablet, your laptop, your TV ?

What if having the fastest or best standards support or whatever in a browser doesn’t matter because the web is no longer separate to your OS, constrained inside the browser ? Is this Microsoft’s answer to ChromeOS, albeit with a different view… instead of the browser being the operating system shell, the OS is a bigger, better browser ? What if the point here is not to kill non-web applications or move away from them, but to actually enable web based applications to compete with non-web applications on performance, beauty, offline support and general user experience ? What if Microsoft made Windows the coolest platform for consuming the web and internet (on any device) as Apple made the iPhone coolest smartphone ?

Ok, so Microsoft have been building the internet and the web into Windows in various ways for a while, this isn’t exactly a new concept. Security is also a problem that gets bigger the more you integrate the internet and web to the OS. Microsoft may or may not pull it off, and if they do it’s likely to be Windows 10 before we see the full fruits of this (possible) plan (if any). Just for a moment though, throw out any bias you might have and consider what the world would be like if Microsoft managed this feat. What would the world be like if no one wanted to access the web unless they were using Windows ? What if Microsoft owned the web again ?

Technorati Tags: Microsoft,Windows,Windows 8,Silverlight,HTML5,JScript,OS,Future

Mobile Opportunity: Windows 8: The Beginning of the End of Windows

2011-06-03T12:53:00.000+12:00

Check out the following blog post by Michael Mace on Windows 8 and the future of Microsoft. It is an an excellent article with an interesting and well thought out analysis of both the possible success and failure Windows 8 represents for Microsoft. There's even a warning for traditional web companies, the likes of Google and Facebook, should everything come together in Microsoft's favour.

Mobile Opportunity: Windows 8: The Beginning of the End of Windows

500+ features coming to a Win 7 "Mango" phone tomorrow? | ZDNet

2011-05-24T14:06:00.000+12:00

500+ features coming to a Win 7 "Mango" phone tomorrow? | ZDNet

Windows Phone 7: A Better Keyboard - Microsoft Research

2011-05-02T09:44:00.000+12:00

Windows Phone 7: A Better Keyboard - Microsoft Research

Windows Forms : Beware the Tab Control

2011-04-28T14:41:00.001+12:00

I discovered an interesting memory leak in one of my Windows Forms applications today. The cause and symptom are entirely obvious once you think about it, but it’s easy not to notice when you’re writing the code initially.

In this particular case I had a tab control with several tabs on it, and some of those tabs needed to be visible or invisible based on either the state of the application or configuration settings. Unfortunately the .NET control for Windows Forms has neither enabled or visible properties for individual tabs, so the common solution is to remove ‘invisible’ tab pages from the tab control (or not add them in the first place).

In my case the form and each tab page had been constructed and laid out with the VS designer, so all the controls and tab pages were created in the VS generated InitializeComponent method. As a result, my form start-up code then checked the state/configuration and removed the unnecessary tabs rather than just not creating them in the first place.

That’s all good… works as expected. The problem is that when I removed the tab pages I didn’t explicitly dispose them. You don’t normally dispose tab pages, or any control, since the form normally does this for you when it’s own Dispose method is called. However, the form only does this for controls it can find, via it’s Controls property (recursively through the control hierarchy). Since I’d removed the tab page from the tab control, the form never found it to dispose.

To make matters worse, some controls (in this case my own custom controls, but I believe at least the Microsoft provided DataGridView control does the same thing) connect to events on external objects, and disconnect on dispose. Since dispose was never called, they never disconnected from those event handlers and so an external reference to them survived which in turn caused the garbage collector to leave them alone. Viola, memory leak !

It is of course a well known issue in Windows Forms that whenever you dynamically add and remove controls from a parent control you must explicitly dispose them, it was just that in this case I’d written the code many years ago and either hadn’t known that myself at the time or hadn’t realised what I was doing. As a result, I ended up with a leak.

So, if you’re removing tab pages from a tab control make sure to dispose them. Just ensure you do this at the right time. If there is any possibility that you might want to re-add the control back into the tab, you either can’t dispose it until the parent control (or more likely form) is disposed. Either that or you’ll need to create and populate (with child controls) a new instance of the tab page to add back into the tab control. Otherwise, if you add back in the old disposed instance, you’ll get errors about disposed objects being accessed.

Technorati Tags: Windows Forms,.NET,Tab,Tab Control,Memory Leak,Dispose

Hello World, cut four ways

2011-04-05T10:34:00.000+12:00

Hello World, cut four ways

Windows Phone 7 Connectivity Issue

2011-03-26T10:28:00.001+13:00

It would appear that with WP7 devices you are often, at least with free wireless hotspots while out and about, better off disabling your Wi-Fi connection if you actually want to be able to connect to the internet. As far as I can tell, if you are connected to a Wi-Fi network with a weak signal, the phone doesn’t automatically fall back to one of the other connection methods (i.e 3G) on a failed/timed out network request. This means if you’re connected to a network via a bad Wi-Fi connection most or all network operations will fail until you manually disconnect.

That’s the bad news. The even worse news is that WP7 doesn’t seem to have any way to manually disconnect from a Wi-Fi network. You can delete the Wi-Fi entry, which means you are disconnected from it AND the phone won’t reconnect next time that network is in range, or you can disable the Wi-Fi feature entirely. If you do the latter, then you have to remember to turn it back on later when you want to use a good Wi-Fi network (like your home or office one).

This can lead to frustrating experiences. Earlier in the week I was in ‘store A’ which is next door to ‘store B’. Store B I have previously visited, has free Wi-Fi which I’d connected to and because my phone could see this from store A it automatically reconnected. Of course I wasn’t actually in store B, I didn’t realise I was connected to their network, and the connection was flaky because the Wi-Fi isn’t boosted and there were concrete walls and what not between the two stores. The end result was that everything I tried to do on my phone involving the internet failed… until I realised there was a Wi-Fi connection. Once I finally realised why I was having connectivity problems I tried to disconnect. Problem was, I want my phone to reconnect to that Wi-Fi the next time I visit store B, I just don’t want to be connected to it right now. That means if I delete the Wi-Fi network I have to manually reconnect next time I visit store B… not what I want. The only other thing I can figure out how to do is to turn off the Wi-Fi altogether, which I did.

The good news is that once I did that, my phone reverted to the 3G connection and I could access the internet again. The bad news is I then forgot to turn the Wi-Fi back on when I left so I used more of my monthly data plan than I intended because it was a day or two later before I realised the Wi-Fi was still off.

None of this is ideal. At the very least I should be able to manually disconnect from a Wi-Fi network without ‘deleting’ it. At best, and this is what I expected to happen, the OS should revert to the next most desirable (based on cost and speed) network when it finds the currently preferred network isn’t working as expected. Microsoft have people much smarter than me, and I’m sure at least one of them can invent some sort of heuristic algorithm to decide when to change connections and which connection to pick next.

As it stands, many ‘consumers’ would be confused by their phone not working in some places (not understanding the whole weak Wi-Fi signal issue), and technical users will be frustrated by the inability to just disconnect this one time.

Technorati Tags: WP7,Windows Phone7,Network,Connectivity,Cellphone