@srcpush/react-native-code-push 1.0.0

package/windows-legacy/CodePush.Net46/UpdateManager.cs

@@ -0,0 +1,330 @@
+using CodePush.Net46.Adapters.Http;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PCLStorage;
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+namespace CodePush.ReactNative
+{
+    internal class UpdateManager
+    {
+        #region Internal methods
+
+        internal async Task ClearUpdatesAsync()
+        {
+            await (await UpdateUtils.GetCodePushFolderAsync().ConfigureAwait(false)).DeleteAsync().ConfigureAwait(false);
+        }
+
+        internal async Task DownloadPackageAsync(JObject updatePackage, string expectedBundleFileName, Progress<HttpProgress> downloadProgress)
+        {
+            // Using its hash, get the folder where the new update will be saved
+            var codePushFolder = await UpdateUtils.GetCodePushFolderAsync().ConfigureAwait(false);
+            var newUpdateHash = (string)updatePackage[CodePushConstants.PackageHashKey];
+            var newUpdateFolder = await GetPackageFolderAsync(newUpdateHash, false).ConfigureAwait(false);
+            if (newUpdateFolder != null)
+            {
+                // This removes any stale data in newUpdateFolder that could have been left
+                // uncleared due to a crash or error during the download or install process.
+                await newUpdateFolder.DeleteAsync().ConfigureAwait(false);
+            }
+
+            newUpdateFolder = await GetPackageFolderAsync(newUpdateHash, true).ConfigureAwait(false);
+            var newUpdateMetadataFile = await newUpdateFolder.CreateFileAsync(CodePushConstants.PackageFileName, CreationCollisionOption.ReplaceExisting).ConfigureAwait(false);
+            var downloadUrlString = (string)updatePackage[CodePushConstants.DownloadUrlKey];
+            var downloadFile = await GetDownloadFileAsync().ConfigureAwait(false);
+
+            await UpdateUtils.DownloadBundleAsync(downloadUrlString, downloadFile.Path, downloadProgress);
+
+            try
+            {
+                // Unzip the downloaded file and then delete the zip
+                var unzippedFolder = await CreateUnzippedFolderAsync().ConfigureAwait(false);
+                /**
+                 * TODO:
+                 *  1) ZipFile.ExtractToDirectory is not reliable and throws exception if:
+                 *      - path is too long (> 250 chars)
+                 *
+                 *  2) Un-zipping is quite long operation. Does it make sense for async?
+                 *  await UpdateUtils.UnzipBundleAsync(downloadFile.Path, unzippedFolder.Path);
+                 *
+                 *  Possible implementation
+                 *
+                 *  internal async static Task UnzipBundleAsync(string zipFileName, string targetDir)
+                 *  {
+                 *    await Task.Run(() =>
+                 *      {
+                 *        ZipFile.ExtractToDirectory(zipFileName, targetDir)
+                 *        return Task.CompletedTask;
+                 *      });
+                 *  }
+                */
+                ZipFile.ExtractToDirectory(downloadFile.Path, unzippedFolder.Path);
+                await downloadFile.DeleteAsync().ConfigureAwait(false);
+
+                // Merge contents with current update based on the manifest
+                IFile diffManifestFile = null;
+                try
+                {
+                    diffManifestFile = await unzippedFolder.GetFileAsync(CodePushConstants.DiffManifestFileName).ConfigureAwait(false);
+                }
+                catch (FileNotFoundException)
+                {
+                    //file may not be present in folder just skip it
+                }
+                if (diffManifestFile != null)
+                {
+                    var currentPackageFolder = await GetCurrentPackageFolderAsync().ConfigureAwait(false);
+                    if (currentPackageFolder == null)
+                    {
+                        throw new InvalidDataException("Received a diff update, but there is no current version to diff against.");
+                    }
+
+                    await UpdateUtils.CopyNecessaryFilesFromCurrentPackageAsync(diffManifestFile, currentPackageFolder, newUpdateFolder).ConfigureAwait(false);
+                    await diffManifestFile.DeleteAsync().ConfigureAwait(false);
+                }
+
+                await FileUtils.MergeFoldersAsync(unzippedFolder, newUpdateFolder).ConfigureAwait(false);
+                await unzippedFolder.DeleteAsync().ConfigureAwait(false);
+
+                // For zip updates, we need to find the relative path to the jsBundle and save it in the
+                // metadata so that we can find and run it easily the next time.
+                var relativeBundlePath = await UpdateUtils.FindJSBundleInUpdateContentsAsync(newUpdateFolder, expectedBundleFileName).ConfigureAwait(false);
+                if (relativeBundlePath == null)
+                {
+                    throw new InvalidDataException("Update is invalid - A JS bundle file named \"" + expectedBundleFileName + "\" could not be found within the downloaded contents. Please check that you are releasing your CodePush updates using the exact same JS bundle file name that was shipped with your app's binary.");
+                }
+                else
+                {
+                    if (diffManifestFile != null)
+                    {
+                        // TODO verify hash for diff update
+                        // CodePushUpdateUtils.verifyHashForDiffUpdate(newUpdateFolderPath, newUpdateHash);
+                    }
+
+                    updatePackage[CodePushConstants.RelativeBundlePathKey] = relativeBundlePath;
+                }
+            }
+            catch (InvalidDataException)
+            {
+                // Downloaded file is not a zip, assume it is a jsbundle
+                await downloadFile.RenameAsync(expectedBundleFileName).ConfigureAwait(false);
+                await downloadFile.MoveAsync(newUpdateFolder.Path, NameCollisionOption.ReplaceExisting).ConfigureAwait(false);
+            }
+
+            // Save metadata to the folder
+            await newUpdateMetadataFile.WriteAllTextAsync(JsonConvert.SerializeObject(updatePackage)).ConfigureAwait(false);
+        }
+
+        internal async Task<JObject> GetCurrentPackageAsync()
+        {
+            var packageHash = await GetCurrentPackageHashAsync().ConfigureAwait(false);
+            return packageHash == null ? null : await GetPackageAsync(packageHash).ConfigureAwait(false);
+        }
+
+        internal async Task<IFile> GetCurrentPackageBundleAsync(string bundleFileName)
+        {
+            var packageFolder = await GetCurrentPackageFolderAsync().ConfigureAwait(false);
+            if (packageFolder == null)
+            {
+                return null;
+            }
+
+            var currentPackage = await GetCurrentPackageAsync().ConfigureAwait(false);
+            var relativeBundlePath = (string)currentPackage[CodePushConstants.RelativeBundlePathKey];
+
+            return relativeBundlePath == null
+                ? await packageFolder.GetFileAsync(bundleFileName).ConfigureAwait(false)
+                : await packageFolder.GetFileAsync(relativeBundlePath).ConfigureAwait(false);
+        }
+
+        internal async Task<string> GetCurrentPackageHashAsync()
+        {
+            var info = await GetCurrentPackageInfoAsync().ConfigureAwait(false);
+            var currentPackageShortHash = (string)info[CodePushConstants.CurrentPackageKey];
+            if (currentPackageShortHash == null)
+            {
+                return null;
+            }
+
+            var currentPackageMetadata = await GetPackageAsync(currentPackageShortHash).ConfigureAwait(false);
+            return currentPackageMetadata == null ? null : (string)currentPackageMetadata[CodePushConstants.PackageHashKey];
+        }
+
+        internal async Task<JObject> GetPackageAsync(string packageHash)
+        {
+            var packageFolder = await GetPackageFolderAsync(packageHash, false).ConfigureAwait(false);
+            if (packageFolder == null)
+            {
+                return null;
+            }
+
+            try
+            {
+                var packageFile = await packageFolder.GetFileAsync(CodePushConstants.PackageFileName).ConfigureAwait(false);
+                return await CodePushUtils.GetJObjectFromFileAsync(packageFile).ConfigureAwait(false);
+            }
+            catch (IOException)
+            {
+                return null;
+            }
+        }
+
+        internal async Task<IFolder> GetPackageFolderAsync(string packageHash, bool createIfNotExists)
+        {
+            var codePushFolder = await UpdateUtils.GetCodePushFolderAsync().ConfigureAwait(false);
+            try
+            {
+                packageHash = ShortenPackageHash(packageHash);
+                return createIfNotExists
+                    ? await codePushFolder.CreateFolderAsync(packageHash, CreationCollisionOption.OpenIfExists).ConfigureAwait(false)
+                    : await codePushFolder.GetFolderAsync(packageHash).ConfigureAwait(false);
+            }
+            catch (FileNotFoundException)
+            {
+                return null;
+            }
+            catch (DirectoryNotFoundException)
+            {
+                return null;
+            }
+        }
+
+        internal async Task<JObject> GetPreviousPackageAsync()
+        {
+            var packageHash = await GetPreviousPackageHashAsync().ConfigureAwait(false);
+            return packageHash == null ? null : await GetPackageAsync(packageHash).ConfigureAwait(false);
+        }
+
+        internal async Task<string> GetPreviousPackageHashAsync()
+        {
+            var info = await GetCurrentPackageInfoAsync().ConfigureAwait(false);
+            var previousPackageShortHash = (string)info[CodePushConstants.PreviousPackageKey];
+            if (previousPackageShortHash == null)
+            {
+                return null;
+            }
+
+            var previousPackageMetadata = await GetPackageAsync(previousPackageShortHash).ConfigureAwait(false);
+            return previousPackageMetadata == null ? null : (string)previousPackageMetadata[CodePushConstants.PackageHashKey];
+        }
+
+        internal async Task InstallPackageAsync(JObject updatePackage, bool currentUpdateIsPending)
+        {
+            var packageHash = (string)updatePackage[CodePushConstants.PackageHashKey];
+            var info = await GetCurrentPackageInfoAsync().ConfigureAwait(false);
+            if (currentUpdateIsPending)
+            {
+                // Don't back up current update to the "previous" position because
+                // it is an unverified update which should not be rolled back to.
+                var currentPackageFolder = await GetCurrentPackageFolderAsync().ConfigureAwait(false);
+                if (currentPackageFolder != null)
+                {
+                    await currentPackageFolder.DeleteAsync().ConfigureAwait(false);
+                }
+            }
+            else
+            {
+                var previousPackageHash = await GetPreviousPackageHashAsync().ConfigureAwait(false);
+                if (previousPackageHash != null && !previousPackageHash.Equals(packageHash))
+                {
+                    var previousPackageFolder = await GetPackageFolderAsync(previousPackageHash, false).ConfigureAwait(false);
+                    if (previousPackageFolder != null)
+                    {
+                        await previousPackageFolder.DeleteAsync().ConfigureAwait(false);
+                    }
+                }
+
+                info[CodePushConstants.PreviousPackageKey] = info[CodePushConstants.CurrentPackageKey];
+            }
+
+            info[CodePushConstants.CurrentPackageKey] = packageHash;
+            await UpdateCurrentPackageInfoAsync(info).ConfigureAwait(false);
+        }
+
+        internal async Task RollbackPackageAsync()
+        {
+            var info = await GetCurrentPackageInfoAsync().ConfigureAwait(false);
+            var currentPackageFolder = await GetCurrentPackageFolderAsync().ConfigureAwait(false);
+            if (currentPackageFolder != null)
+            {
+                await currentPackageFolder.DeleteAsync().ConfigureAwait(false);
+            }
+
+            info[CodePushConstants.CurrentPackageKey] = info[CodePushConstants.PreviousPackageKey];
+            info[CodePushConstants.PreviousPackageKey] = null;
+            await UpdateCurrentPackageInfoAsync(info).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Private methods
+
+        private async Task<IFolder> GetCurrentPackageFolderAsync()
+        {
+            var info = await GetCurrentPackageInfoAsync().ConfigureAwait(false);
+            if (info == null)
+            {
+                return null;
+            }
+            var packageHash = (string)info[CodePushConstants.CurrentPackageKey];
+            return packageHash == null ? null : await GetPackageFolderAsync(packageHash, false).ConfigureAwait(false);
+        }
+
+        private async Task<JObject> GetCurrentPackageInfoAsync()
+        {
+            var statusFile = await GetStatusFileAsync().ConfigureAwait(false);
+            var info = await CodePushUtils.GetJObjectFromFileAsync(statusFile).ConfigureAwait(false);
+
+            if (info != null)
+            {
+                return info;
+            }
+
+            // info file has been corrupted - re-create it
+            await statusFile.DeleteAsync().ConfigureAwait(false);
+            statusFile = await GetStatusFileAsync().ConfigureAwait(false);
+            return await CodePushUtils.GetJObjectFromFileAsync(statusFile).ConfigureAwait(false);
+        }
+
+        private async Task<IFile> GetDownloadFileAsync()
+        {
+            var codePushFolder = await UpdateUtils.GetCodePushFolderAsync().ConfigureAwait(false);
+            return await codePushFolder.CreateFileAsync(CodePushConstants.DownloadFileName, CreationCollisionOption.OpenIfExists).ConfigureAwait(false);
+        }
+
+        private async Task<IFile> GetStatusFileAsync()
+        {
+            var codePushFolder = await UpdateUtils.GetCodePushFolderAsync().ConfigureAwait(false);
+            return await codePushFolder.CreateFileAsync(CodePushConstants.StatusFileName, CreationCollisionOption.OpenIfExists).ConfigureAwait(false);
+        }
+
+        private async Task<IFolder> CreateUnzippedFolderAsync()
+        {
+            var codePushFolder = await UpdateUtils.GetCodePushFolderAsync().ConfigureAwait(false);
+            var isUnzippedFolderExists = await codePushFolder.CheckExistsAsync(CodePushConstants.UnzippedFolderName).ConfigureAwait(false);
+
+            if (isUnzippedFolderExists != ExistenceCheckResult.NotFound)
+            {
+                await codePushFolder.GetFolderAsync(CodePushConstants.UnzippedFolderName).ContinueWith((existingFolder) => existingFolder.Result.DeleteAsync());
+            }
+
+            return await codePushFolder.CreateFolderAsync(CodePushConstants.UnzippedFolderName, CreationCollisionOption.OpenIfExists).ConfigureAwait(false);
+        }
+
+        private string ShortenPackageHash(string longPackageHash)
+        {
+            return longPackageHash.Substring(0, 8);
+        }
+
+        private async Task UpdateCurrentPackageInfoAsync(JObject packageInfo)
+        {
+            var file = await GetStatusFileAsync().ConfigureAwait(false);
+            await file.WriteAllTextAsync(JsonConvert.SerializeObject(packageInfo)).ConfigureAwait(false);
+        }
+        #endregion
+    }
+}

package/windows-legacy/CodePush.Net46/UpdateUtils.cs

@@ -0,0 +1,70 @@
+using CodePush.Net46.Adapters.Http;
+using Newtonsoft.Json.Linq;
+using PCLStorage;
+using System;
+using System.IO;
+using System.Net;
+using System.Threading.Tasks;
+
+namespace CodePush.ReactNative
+{
+    internal class UpdateUtils
+    {
+        internal async static Task CopyNecessaryFilesFromCurrentPackageAsync(IFile diffManifestFile, IFolder currentPackageFolder, IFolder newPackageFolder)
+        {
+            await FileUtils.MergeFoldersAsync(currentPackageFolder, newPackageFolder).ConfigureAwait(false);
+            JObject diffManifest = await CodePushUtils.GetJObjectFromFileAsync(diffManifestFile).ConfigureAwait(false);
+            var deletedFiles = (JArray)diffManifest["deletedFiles"];
+            foreach (string fileNameToDelete in deletedFiles)
+            {
+                var fileToDelete = await newPackageFolder.GetFileAsync(fileNameToDelete).ConfigureAwait(false);
+                await fileToDelete.DeleteAsync().ConfigureAwait(false);
+            }
+        }
+
+        internal async static Task<string> FindJSBundleInUpdateContentsAsync(IFolder updateFolder, string expectedFileName)
+        {
+            foreach (IFile file in await updateFolder.GetFilesAsync().ConfigureAwait(false))
+            {
+                string fileName = file.Name;
+                if (fileName.Equals(expectedFileName))
+                {
+                    return fileName;
+                }
+            }
+
+            foreach (IFolder folder in await updateFolder.GetFoldersAsync().ConfigureAwait(false))
+            {
+                string mainBundlePathInSubFolder = await FindJSBundleInUpdateContentsAsync(folder, expectedFileName).ConfigureAwait(false);
+                if (mainBundlePathInSubFolder != null)
+                {
+                    return Path.Combine(folder.Name, mainBundlePathInSubFolder);
+                }
+            }
+
+            return null;
+        }
+
+        internal async static Task DownloadBundleAsync(string url, string fileName, IProgress<HttpProgress> downloadProgress)
+        {
+            var uri = new Uri(url);
+            var client = new WebClient();
+            client.DownloadProgressChanged += (s, e) =>
+            {
+                downloadProgress.Report(new HttpProgress
+                {
+                    BytesReceived = (ulong)e.BytesReceived,            //conversion long to ulong is safe
+                    TotalBytesToReceive = (ulong)e.TotalBytesToReceive //because size can't be negative
+                });
+            };
+
+            await client.DownloadFileTaskAsync(uri, fileName);
+        }
+
+        internal static async Task<IFolder> GetCodePushFolderAsync()
+        {
+            var pathToCodePush = Path.Combine(CodePushUtils.GetFileBundlePrefix(), CodePushConstants.CodePushFolderPrefix);
+            return await FileSystem.Current.LocalStorage.CreateFolderAsync(pathToCodePush, CreationCollisionOption.OpenIfExists).ConfigureAwait(false);
+        }
+    }
+}

package/windows-legacy/CodePush.Net46/packages.config

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net452" />
+  <package id="PCLStorage" version="1.0.2" targetFramework="net46" />
+</packages>

package/windows-legacy/CodePush.Net46.Test/ApplicationDataContainerTest.cs

@@ -0,0 +1,105 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using CodePush.Net46.Adapters.Storage;
+using System.Threading.Tasks;
+
+namespace CodePush.Net46.Test
+{
+    [TestClass]
+    public class ApplicationDataContainerTest
+    {
+        readonly static string key1 = "key1";
+        readonly static string key2 = "key2";
+        readonly static string key3 = "key3";
+
+        readonly static string val1 = "string data1";
+        readonly static string val2 = "string data2";
+        readonly static string val3 = "string data1";
+
+        [TestMethod]
+        public void TestInMemmorySet()
+        {
+            var settings = new ApplicationDataContainer();
+
+            settings.Values[key1] = val1;
+            settings.Values[key2] = val2;
+            settings.Values[key3] = val3;
+
+            Assert.AreEqual(settings.Values[key1], val1);
+            Assert.AreEqual(settings.Values[key2], val2);
+            Assert.AreEqual(settings.Values[key3], val3);
+
+            settings.DeleteAsync().Wait();
+        }
+
+        [TestMethod]
+        public void TestInMemmoryReset()
+        {
+            var settings = new ApplicationDataContainer();
+
+            settings.Values[key1] = val1;
+            settings.Values[key1] = val2;
+            settings.Values[key1] = val3;
+
+            Assert.AreEqual(settings.Values[key1], val3);
+
+            settings.DeleteAsync().Wait();
+        }
+
+        [TestMethod]
+        public void TestInMemmoryRemove()
+        {
+            var settings = new ApplicationDataContainer();
+
+            settings.Values[key1] = val1;
+            settings.Values[key2] = val2;
+            settings.Values[key3] = val3;
+
+            settings.Values.Remove(key2);
+
+            Assert.AreEqual(settings.Values[key1], val1);
+            Assert.IsNull(settings.Values[key2]);
+            Assert.AreEqual(settings.Values[key3], val3);
+
+            settings.DeleteAsync().Wait();
+        }
+
+        [TestMethod]
+        public void TestPersistentSet()
+        {
+            var settings = new ApplicationDataContainer();
+
+            settings.Values[key1] = val1;
+            settings.Values[key2] = val2;
+            settings.Values[key3] = val3;
+
+            settings = new ApplicationDataContainer();
+
+            Assert.AreEqual(settings.Values[key1], val1);
+            Assert.AreEqual(settings.Values[key2], val2);
+            Assert.AreEqual(settings.Values[key3], val3);
+
+            settings.DeleteAsync().Wait();
+        }
+
+        [TestMethod]
+        public void TestPersistentRemove()
+        {
+            var settings = new ApplicationDataContainer();
+
+            settings.Values[key1] = val1;
+            settings.Values[key2] = val2;
+            settings.Values[key3] = val3;
+
+            settings.Values.Remove(key2);
+
+            settings = new ApplicationDataContainer();
+
+            Assert.AreEqual(settings.Values[key1], val1);
+            Assert.IsNull(settings.Values[key2]);
+            Assert.AreEqual(settings.Values[key3], val3);
+
+            settings.DeleteAsync().Wait();
+        }
+    }
+}

package/windows-legacy/CodePush.Net46.Test/CodePush.Net46.Test.csproj

@@ -0,0 +1,137 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{BBB48F0B-AF6F-4A14-AFA4-306D3FB0B7CF}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>CodePush.Net46.Test</RootNamespace>
+    <AssemblyName>CodePush.Net46.Test</AssemblyName>
+    <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages</ReferencePath>
+    <IsCodedUITest>False</IsCodedUITest>
+    <TestProjectType>UnitTest</TestProjectType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=13.0.1.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\Examples\CodePushDemoApp\windows\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System" />
+  </ItemGroup>
+  <Choose>
+    <When Condition="('$(VisualStudioVersion)' == '10.0' or '$(VisualStudioVersion)' == '') and '$(TargetFrameworkVersion)' == 'v3.5'">
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+      </ItemGroup>
+    </When>
+    <Otherwise>
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework">
+          <Private>False</Private>
+        </Reference>
+      </ItemGroup>
+    </Otherwise>
+  </Choose>
+  <ItemGroup>
+    <Compile Include="ApplicationDataContainerTest.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TelemetryManagerTest.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CodePush.Net46\CodePush.Net46.csproj">
+      <Project>{4dfe3f9f-5e15-4f17-8fd4-33ff0519348e}</Project>
+      <Name>CodePush.Net46</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Choose>
+    <When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.CodedUITestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITest.Common, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITest.Extension, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITesting, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+      </ItemGroup>
+    </When>
+  </Choose>
+  <Import Project="$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets" Condition="Exists('$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets')" />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>