title: Why Could My Application Trial Not be Working in the Marketplace
body: <p>I recently have released a small application with a trial to the Windows Phone Marketplace, but my application is not working as expected. I have followed <a href="http://code.msdn.microsoft.com/Trial-Experience-Sample-c58f21af" rel="nofollow">http://code.msdn.microsoft.com/Trial-Experience-Sample-c58f21af</a> when making my trial, so that I can call the current 'LicenseInformation' state and block a feature or not depending on the current application's license state. According to the sample application, <code>The LicenseMode property returns a value from the LicenseModes enum (Full, MissingOrRevoked, or Trial) so that your app code needs to check only a single value. There’s also a convenient Boolean IsFull property. Whenever the license mode has changed, or it is likely to have changed, TrialExperienceHelper raises its LicenseChanged event and your app code can handle that event to query LicenseMode or IsFull again. Then, your app can control the availability of features, ads, and your Buy UI as needed.</code></p>
  
  <p>In my application I have a click event in which I would like to perform an action based on the current LicenseInformation state and upon a count (the count being the number of times an image is saved with particular aspects applied). </p>
  
  <p><code>Settings.SavedCount.Value</code> records the number of times the save button is clicked, and if the count is above 100 and the application is in trial mode I would like to ask the user if they would like to upgrade, otherwise if the count is less than 100 while the application is in trial mode or if the license is in full mode then the user is allowed to continue with the save process (hopefully that makes logical sense).</p>
  
  <pre><code>void saveButton_Click(object sender, EventArgs e)
  {
      Settings.SavedCount.Value += 1;        
  
      if (TrialViewModel.LicenseModeString == "Trial" &amp;&amp; Settings.SavedCount.Value &gt; 100)
      {
          MessageBoxResult result = MessageBox.Show("You have saved over 100 items! Would you like to continue?", "Congratulations!", MeesageBoxButton.OKCancel);
  
          switch (result)
          {
              case MessageBoxResult.OK:
                  //A command takes a parameter so pass null
                  TrialViewModel.BuyCommand.Execute(null);
                  break;
              case MessageBoxResult.Cancel:
                  editPagePivotControl.SelectedIndex = 0;
                  break;                  
          }
      }
      else if ((TrialViewModel.LicenseModeString == "Trial" &amp;&amp; Settings.SavedCount.Value &lt;= 100) || (TrialViewModel.LicenseModeString == "Full")
          {
              PerformSaveAsync();
          }
      }
  }
  </code></pre>
  
  <p>When testing in Debug mode and with the sample implementation from the msdn website, the Trial and Full implementations worked properly, and then when in Release mode the license was listed as MissingOrRevoked which I assumed would be called correctly in the marketplace. What is ACTUALLY occuring when i have downloaded the app in the marketplace under both trial and full modes is that the <code>PerformSaveAsync()</code> method is never being called (which ultimately saves the new image and disables the button) and I can use the new image elsewhere. I am having trouble figuring out what the issue may be?</p>
  
  <p>EDIT** In researching I came across <a href="http://msdn.microsoft.com/en-us/library/aa691310(v=vs.71).aspx" rel="nofollow">http://msdn.microsoft.com/en-us/library/aa691310(v=vs.71).aspx</a> which states that <code>The operation x &amp;&amp; y corresponds to the operation x &amp; y, except that y is evaluated only if x is true.</code> and `•The operation x || y corresponds to the operation x | y, except that y is evaluated only if x is false/' . Would this be the cause of the issues? If so, how should they be fixed?</p>
  
  <p>Edit 2** Addtion of TrialViewModel and TrialExperienceHelper.cs for additional info</p>
  
  <p>TrialViewModel</p>
  
  <pre><code>TrialViewModel
  
  #region fields
  private RelayCommand buyCommand;
  #endregion fields
  
  #region constructors
  public TrialViewModel()
  {
      // Subscribe to the helper class's static LicenseChanged event so that we can re-query its LicenseMode property when it changes.
      TrialExperienceHelper.LicenseChanged += TrialExperienceHelper_LicenseChanged;
  }
  #endregion constructors
  
  #region properties        
  /// &lt;summary&gt;
  /// You can bind the Command property of a Button to BuyCommand. When the Button is clicked, BuyCommand will be
  /// invoked. The Button will be enabled as long as BuyCommand can execute.
  /// &lt;/summary&gt;
  public RelayCommand BuyCommand
  {
      get
      {
          if (this.buyCommand == null)
          {
              // The RelayCommand is constructed with two parameters - the action to perform on invocation,
              // and the condition under which the command can execute. It's important to call RaiseCanExecuteChanged
              // on a command whenever its can-execute condition might have changed. Here, we do that in the TrialExperienceHelper_LicenseChanged
              // event handler.
              this.buyCommand = new RelayCommand(
                  param =&gt; TrialExperienceHelper.Buy(),
                  param =&gt; TrialExperienceHelper.LicenseMode == TrialExperienceHelper.LicenseModes.Trial);
          }
          return this.buyCommand;
      }
  }
  
  public string LicenseModeString
  {
      get
      {
          return TrialExperienceHelper.LicenseMode.ToString()/* + ' ' + AppResources.ModeString*/;
      }
  }
  #endregion properties
  
  #region event handlers
  // Handle TrialExperienceHelper's LicenseChanged event by raising property changed notifications on the
  // properties and commands that 
  internal void TrialExperienceHelper_LicenseChanged()
  {
      this.RaisePropertyChanged("LicenseModeString");
      this.BuyCommand.RaiseCanExecuteChanged();
  }
  #endregion event handlers
  </code></pre>
  
  <p>TrialExperienceHelper.cs</p>
  
  <pre><code>#region enums
      /// &lt;summary&gt;
      /// The LicenseModes enumeration describes the mode of a license.
      /// &lt;/summary&gt;
      public enum LicenseModes
      {
          Full,
          MissingOrRevoked,
          Trial
      }
      #endregion enums
  
      #region fields
  #if DEBUG
      // Determines how a debug build behaves on launch. This field is set to LicenseModes.Full after simulating a purchase.
      // Calling the Buy method (or navigating away from the app and back) will simulate a purchase.
      internal static LicenseModes simulatedLicMode = LicenseModes.Trial;
  #endif // DEBUG
      private static bool isActiveCache;
      private static bool isTrialCache;
      #endregion fields
  
      #region constructors
      // The static constructor effectively initializes the cache of the state of the license when the app is launched. It also attaches
      // a handler so that we can refresh the cache whenever the license has (potentially) changed.
      static TrialExperienceHelper()
      {
          TrialExperienceHelper.RefreshCache();
          PhoneApplicationService.Current.Activated += (object sender, ActivatedEventArgs e) =&gt; TrialExperienceHelper.
  #if DEBUG
              // In debug configuration, when the user returns to the application we will simulate a purchase.
  OnSimulatedPurchase();
  #else // DEBUG
              // In release configuration, when the user returns to the application we will refresh the cache.
  RefreshCache();
  #endif // DEBUG
      }
      #endregion constructors
  
      #region properties
      /// &lt;summary&gt;
      /// The LicenseMode property combines the active and trial states of the license into a single
      /// enumerated value. In debug configuration, the simulated value is returned. In release configuration,
      /// if the license is active then it is either trial or full. If the license is not active then
      /// it is either missing or revoked.
      /// &lt;/summary&gt;
      public static LicenseModes LicenseMode
      {
          get
          {
  #if DEBUG
              return simulatedLicMode;
  #else // DEBUG
              if (TrialExperienceHelper.isActiveCache)
              {
                  return TrialExperienceHelper.isTrialCache ? LicenseModes.Trial : LicenseModes.Full;
              }
              else // License is inactive.
              {
                  return LicenseModes.MissingOrRevoked;
              }
  #endif // DEBUG
          }
      }
  
      /// &lt;summary&gt;
      /// The IsFull property provides a convenient way of checking whether the license is full or not.
      /// &lt;/summary&gt;
      public static bool IsFull
      {
          get
          {
              return (TrialExperienceHelper.LicenseMode == LicenseModes.Full);
          }
      }
      #endregion properties
  
      #region methods
      /// &lt;summary&gt;
      /// The Buy method can be called when the license state is trial. the user is given the opportunity
      /// to buy the app after which, in all configurations, the Activated event is raised, which we handle.
      /// &lt;/summary&gt;
      public static void Buy()
      {
          MarketplaceDetailTask marketplaceDetailTask = new MarketplaceDetailTask();
          marketplaceDetailTask.ContentType = MarketplaceContentType.Applications;
          marketplaceDetailTask.Show();
      }
  
      /// &lt;summary&gt;
      /// This method can be called at any time to refresh the values stored in the cache. We re-query the application object
      /// for the current state of the license and cache the fresh values. We also raise the LicenseChanged event.
      /// &lt;/summary&gt;
      public static void RefreshCache()
      {
          TrialExperienceHelper.isActiveCache = CurrentApp.LicenseInformation.IsActive;
          TrialExperienceHelper.isTrialCache = CurrentApp.LicenseInformation.IsTrial;
          TrialExperienceHelper.RaiseLicenseChanged();
      }
  
      private static void RaiseLicenseChanged()
      {
          if (TrialExperienceHelper.LicenseChanged != null)
          {
              TrialExperienceHelper.LicenseChanged();
          }
      }
  
  #if DEBUG
      private static void OnSimulatedPurchase()
      {
          TrialExperienceHelper.simulatedLicMode = LicenseModes.Full;
          TrialExperienceHelper.RaiseLicenseChanged();
      }
  #endif // DEBUG
      #endregion methods
  
      #region events
      /// &lt;summary&gt;
      /// The static LicenseChanged event is raised whenever the value of the LicenseMode property has (potentially) changed.
      /// &lt;/summary&gt;
      public static event LicenseChangedEventHandler LicenseChanged;
      #endregion events
  </code></pre>