@appzung/react-native-code-push 5.7.1

package/windows/CodePush/Properties/CodePush.rd.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    This file contains Runtime Directives, specifications about types your application accesses
+    through reflection and other dynamic code patterns. Runtime Directives are used to control the
+    .NET Native optimizer and ensure that it does not remove code accessed by your library. If your
+    library does not do any reflection, then you generally do not need to edit this file. However,
+    if your library reflects over types, especially types passed to it or derived from its types,
+    then you should write Runtime Directives.
+
+    The most common use of reflection in libraries is to discover information about types passed
+    to the library. Runtime Directives have three ways to express requirements on types passed to
+    your library.
+
+    1.  Parameter, GenericParameter, TypeParameter, TypeEnumerableParameter
+        Use these directives to reflect over types passed as a parameter.
+
+    2.  SubTypes
+        Use a SubTypes directive to reflect over types derived from another type.
+
+    3.  AttributeImplies
+        Use an AttributeImplies directive to indicate that your library needs to reflect over
+        types or methods decorated with an attribute.
+
+    For more information on writing Runtime Directives for libraries, please visit
+    http://go.microsoft.com/fwlink/?LinkID=391919
+-->
+<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
+  <Library Name="CodePush">
+
+  	<!-- add directives for your library here -->
+
+  </Library>
+</Directives>

package/windows/CodePush/UpdateManager.cs

@@ -0,0 +1,305 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Threading;
+using System.Threading.Tasks;
+using Windows.Storage;
+using Windows.Storage.Streams;
+using Windows.Web.Http;
+
+namespace CodePush.ReactNative
+{
+    internal class UpdateManager
+    {
+        #region Internal methods
+
+        internal async Task ClearUpdatesAsync()
+        {
+            await (await GetCodePushFolderAsync().ConfigureAwait(false)).DeleteAsync().AsTask().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
+            StorageFolder codePushFolder = await GetCodePushFolderAsync().ConfigureAwait(false);
+            var newUpdateHash = (string)updatePackage[CodePushConstants.PackageHashKey];
+            StorageFolder 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().AsTask().ConfigureAwait(false);
+            }
+
+            newUpdateFolder = await GetPackageFolderAsync(newUpdateHash, true).ConfigureAwait(false);
+            StorageFile newUpdateMetadataFile = await newUpdateFolder.CreateFileAsync(CodePushConstants.PackageFileName).AsTask().ConfigureAwait(false);
+            var downloadUrlString = (string)updatePackage[CodePushConstants.DownloadUrlKey];
+            StorageFile downloadFile = await GetDownloadFileAsync().ConfigureAwait(false);
+            var downloadUri = new Uri(downloadUrlString);
+
+            // Download the file and send progress event asynchronously
+            var request = new HttpRequestMessage(HttpMethod.Get, downloadUri);
+            var client = new HttpClient();
+            var cancellationTokenSource = new CancellationTokenSource();
+            using (HttpResponseMessage response = await client.SendRequestAsync(request).AsTask(cancellationTokenSource.Token, downloadProgress).ConfigureAwait(false))
+            using (IInputStream inputStream = await response.Content.ReadAsInputStreamAsync().AsTask().ConfigureAwait(false))
+            using (IRandomAccessStream downloadFileStream = await downloadFile.OpenAsync(FileAccessMode.ReadWrite).AsTask().ConfigureAwait(false))
+            {
+                await RandomAccessStream.CopyAsync(inputStream, downloadFileStream).AsTask().ConfigureAwait(false);
+            }
+
+            try
+            {
+                // Unzip the downloaded file and then delete the zip
+                StorageFolder unzippedFolder = await CreateUnzippedFolderAsync().ConfigureAwait(false);
+                ZipFile.ExtractToDirectory(downloadFile.Path, unzippedFolder.Path);
+                await downloadFile.DeleteAsync().AsTask().ConfigureAwait(false);
+
+                // Merge contents with current update based on the manifest
+                StorageFile diffManifestFile = (StorageFile)await unzippedFolder.TryGetItemAsync(CodePushConstants.DiffManifestFileName).AsTask().ConfigureAwait(false);
+                if (diffManifestFile != null)
+                {
+                    StorageFolder 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().AsTask().ConfigureAwait(false);
+                }
+
+                await FileUtils.MergeFoldersAsync(unzippedFolder, newUpdateFolder).ConfigureAwait(false);
+                await unzippedFolder.DeleteAsync().AsTask().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.
+                string 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).AsTask().ConfigureAwait(false);
+                await downloadFile.MoveAsync(newUpdateFolder).AsTask().ConfigureAwait(false);
+            }
+            /*TODO: ZipFile.ExtractToDirectory is not reliable and throws exceptions if:
+            - path is too long
+            it needs to be handled
+            */
+
+            // Save metadata to the folder
+            await FileIO.WriteTextAsync(newUpdateMetadataFile, JsonConvert.SerializeObject(updatePackage)).AsTask().ConfigureAwait(false);
+        }
+
+        internal async Task<JObject> GetCurrentPackageAsync()
+        {
+            string packageHash = await GetCurrentPackageHashAsync().ConfigureAwait(false);
+            return packageHash == null ? null : await GetPackageAsync(packageHash).ConfigureAwait(false);
+        }
+
+        internal async Task<StorageFile> GetCurrentPackageBundleAsync(string bundleFileName)
+        {
+            StorageFolder packageFolder = await GetCurrentPackageFolderAsync().ConfigureAwait(false);
+            if (packageFolder == null)
+            {
+                return null;
+            }
+
+            JObject currentPackage = await GetCurrentPackageAsync().ConfigureAwait(false);
+            var relativeBundlePath = (string)currentPackage[CodePushConstants.RelativeBundlePathKey];
+
+            return relativeBundlePath == null
+                ? await packageFolder.GetFileAsync(bundleFileName).AsTask().ConfigureAwait(false)
+                : await packageFolder.GetFileAsync(relativeBundlePath).AsTask().ConfigureAwait(false);
+        }
+
+        internal async Task<string> GetCurrentPackageHashAsync()
+        {
+            JObject info = await GetCurrentPackageInfoAsync().ConfigureAwait(false);
+            string currentPackageShortHash = (string)info[CodePushConstants.CurrentPackageKey];
+            if (currentPackageShortHash == null)
+            {
+                return null;
+            }
+
+            JObject currentPackageMetadata = await GetPackageAsync(currentPackageShortHash).ConfigureAwait(false);
+            return currentPackageMetadata == null ? null : (string)currentPackageMetadata[CodePushConstants.PackageHashKey];
+        }
+
+        internal async Task<JObject> GetPackageAsync(string packageHash)
+        {
+            StorageFolder packageFolder = await GetPackageFolderAsync(packageHash, false).ConfigureAwait(false);
+            if (packageFolder == null)
+            {
+                return null;
+            }
+
+            try
+            {
+                StorageFile packageFile = await packageFolder.GetFileAsync(CodePushConstants.PackageFileName).AsTask().ConfigureAwait(false);
+                return await CodePushUtils.GetJObjectFromFileAsync(packageFile).ConfigureAwait(false);
+            }
+            catch (IOException)
+            {
+                return null;
+            }
+        }
+
+        internal async Task<StorageFolder> GetPackageFolderAsync(string packageHash, bool createIfNotExists)
+        {
+            StorageFolder codePushFolder = await GetCodePushFolderAsync().ConfigureAwait(false);
+            try
+            {
+                packageHash = ShortenPackageHash(packageHash);
+                return createIfNotExists
+                    ? await codePushFolder.CreateFolderAsync(packageHash, CreationCollisionOption.OpenIfExists).AsTask().ConfigureAwait(false)
+                    : await codePushFolder.GetFolderAsync(packageHash).AsTask().ConfigureAwait(false);
+            }
+            catch (FileNotFoundException)
+            {
+                return null;
+            }
+        }
+
+        internal async Task<JObject> GetPreviousPackageAsync()
+        {
+            string packageHash = await GetPreviousPackageHashAsync().ConfigureAwait(false);
+            return packageHash == null ? null : await GetPackageAsync(packageHash).ConfigureAwait(false);
+        }
+
+        internal async Task<string> GetPreviousPackageHashAsync()
+        {
+            JObject info = await GetCurrentPackageInfoAsync().ConfigureAwait(false);
+            string previousPackageShortHash = (string)info[CodePushConstants.PreviousPackageKey];
+            if (previousPackageShortHash == null)
+            {
+                return null;
+            }
+
+            JObject 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];
+            JObject 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.
+                StorageFolder currentPackageFolder = await GetCurrentPackageFolderAsync().ConfigureAwait(false);
+                if (currentPackageFolder != null)
+                {
+                    await currentPackageFolder.DeleteAsync().AsTask().ConfigureAwait(false);
+                }
+            }
+            else
+            {
+                string previousPackageHash = await GetPreviousPackageHashAsync().ConfigureAwait(false);
+                if (previousPackageHash != null && !previousPackageHash.Equals(packageHash))
+                {
+                    StorageFolder previousPackageFolder = await GetPackageFolderAsync(previousPackageHash, false).ConfigureAwait(false);
+                    if (previousPackageFolder != null)
+                    {
+                        await previousPackageFolder.DeleteAsync().AsTask().ConfigureAwait(false);
+                    }
+                }
+
+                info[CodePushConstants.PreviousPackageKey] = info[CodePushConstants.CurrentPackageKey];
+            }
+
+            info[CodePushConstants.CurrentPackageKey] = packageHash;
+            await UpdateCurrentPackageInfoAsync(info).ConfigureAwait(false);
+        }
+
+        internal async Task RollbackPackageAsync()
+        {
+            JObject info = await GetCurrentPackageInfoAsync().ConfigureAwait(false);
+            StorageFolder currentPackageFolder = await GetCurrentPackageFolderAsync().ConfigureAwait(false);
+            if (currentPackageFolder != null)
+            {
+                await currentPackageFolder.DeleteAsync().AsTask().ConfigureAwait(false);
+            }
+
+            info[CodePushConstants.CurrentPackageKey] = info[CodePushConstants.PreviousPackageKey];
+            info[CodePushConstants.PreviousPackageKey] = null;
+            await UpdateCurrentPackageInfoAsync(info).ConfigureAwait(false);
+        }
+
+        #endregion
+
+        #region Private methods
+
+        private async Task<StorageFolder> GetCodePushFolderAsync()
+        {
+            return await ApplicationData.Current.LocalFolder.CreateFolderAsync(CodePushConstants.CodePushFolderPrefix, CreationCollisionOption.OpenIfExists).AsTask().ConfigureAwait(false);
+        }
+
+        private async Task<StorageFolder> GetCurrentPackageFolderAsync()
+        {
+            JObject info = await GetCurrentPackageInfoAsync().ConfigureAwait(false);
+            var packageHash = (string)info[CodePushConstants.CurrentPackageKey];
+            return packageHash == null ? null : await GetPackageFolderAsync(packageHash, false).ConfigureAwait(false);
+        }
+
+        private async Task<JObject> GetCurrentPackageInfoAsync()
+        {
+            StorageFile statusFile = await GetStatusFileAsync().ConfigureAwait(false);
+            return await CodePushUtils.GetJObjectFromFileAsync(statusFile).ConfigureAwait(false);
+        }
+
+        private async Task<StorageFile> GetDownloadFileAsync()
+        {
+            var codePushFolder = await GetCodePushFolderAsync().ConfigureAwait(false);
+            return await codePushFolder.CreateFileAsync(CodePushConstants.DownloadFileName, CreationCollisionOption.OpenIfExists).AsTask().ConfigureAwait(false);
+        }
+
+        private async Task<StorageFile> GetStatusFileAsync()
+        {
+            StorageFolder codePushFolder = await GetCodePushFolderAsync().ConfigureAwait(false);
+            return await codePushFolder.CreateFileAsync(CodePushConstants.StatusFileName, CreationCollisionOption.OpenIfExists).AsTask().ConfigureAwait(false);
+        }
+
+        private async Task<StorageFolder> CreateUnzippedFolderAsync()
+        {
+            StorageFolder codePushFolder = await GetCodePushFolderAsync().ConfigureAwait(false);
+            var unzippedFolder = await codePushFolder.TryGetItemAsync(CodePushConstants.UnzippedFolderName).AsTask().ConfigureAwait(false);
+
+            if (unzippedFolder != null)
+            {
+                await unzippedFolder.DeleteAsync();
+            }
+
+            return await codePushFolder.CreateFolderAsync(CodePushConstants.UnzippedFolderName, CreationCollisionOption.OpenIfExists).AsTask().ConfigureAwait(false);
+        }
+
+        private string ShortenPackageHash(string longPackageHash)
+        {
+            return longPackageHash.Substring(0, 8);
+        }
+
+        private async Task UpdateCurrentPackageInfoAsync(JObject packageInfo)
+        {
+            await FileIO.WriteTextAsync(await GetStatusFileAsync().ConfigureAwait(false), JsonConvert.SerializeObject(packageInfo)).AsTask().ConfigureAwait(false);
+        }
+
+        #endregion
+    }
+}

package/windows/CodePush/UpdateUtils.cs

@@ -0,0 +1,46 @@
+using Newtonsoft.Json.Linq;
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Windows.Storage;
+
+namespace CodePush.ReactNative
+{
+    internal class UpdateUtils
+    {
+        internal async static Task CopyNecessaryFilesFromCurrentPackageAsync(StorageFile diffManifestFile, StorageFolder currentPackageFolder, StorageFolder 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)
+            {
+                StorageFile fileToDelete = await newPackageFolder.GetFileAsync(fileNameToDelete.Replace("/", "\\")).AsTask().ConfigureAwait(false);
+                await fileToDelete.DeleteAsync().AsTask().ConfigureAwait(false);
+            }
+        }
+
+        internal async static Task<string> FindJSBundleInUpdateContentsAsync(StorageFolder updateFolder, string expectedFileName)
+        {
+            foreach (StorageFile file in await updateFolder.GetFilesAsync().AsTask().ConfigureAwait(false))
+            {
+                string fileName = file.Name;
+                if (fileName.Equals(expectedFileName))
+                {
+                    return fileName;
+                }
+            }
+
+            foreach (StorageFolder folder in await updateFolder.GetFoldersAsync().AsTask().ConfigureAwait(false))
+            {
+                string mainBundlePathInSubFolder = await FindJSBundleInUpdateContentsAsync(folder, expectedFileName).ConfigureAwait(false);
+                if (mainBundlePathInSubFolder != null)
+                {
+                    return Path.Combine(folder.Name, mainBundlePathInSubFolder);
+                }
+            }
+
+            return null;
+        }
+    }
+}

package/windows/CodePush.Net46/Adapters/Http/HttpProgress.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace CodePush.Net46.Adapters.Http
+{
+    public enum HttpProgressStage
+    {
+        None = 0,
+        DetectingProxy = 10,
+        ResolvingName = 20,
+        ConnectingToServer = 30,
+        NegotiatingSsl = 40,
+        SendingHeaders = 50,
+        SendingContent = 60,
+        WaitingForResponse = 70,
+        ReceivingHeaders = 80,
+        ReceivingContent = 90
+    }
+
+    public struct HttpProgress
+    {
+        public UInt64 BytesReceived;
+        public UInt64 BytesSent;
+        public UInt32 Retries;
+        public HttpProgressStage Stage;
+        public UInt64? TotalBytesToReceive;
+        public UInt64? TotalBytesToSend;
+    }
+}

package/windows/CodePush.Net46/Adapters/Storage/ApplicationDataContainer.cs

@@ -0,0 +1,106 @@
+using CodePush.ReactNative;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using PCLStorage;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CodePush.Net46.Adapters.Storage
+{
+    public enum ApplicationDataCreateDisposition
+    {
+        Always = 0,
+        Existing = 1
+    }
+
+    public class DictionaryWithDefault<TKey, TValue> : Dictionary<TKey, TValue>
+    {
+        TValue _default;
+        public TValue DefaultValue
+        {
+            get { return _default; }
+            set { _default = value; }
+        }
+        public DictionaryWithDefault() : base() { }
+        public DictionaryWithDefault(TValue defaultValue) : base()
+        {
+            _default = defaultValue;
+        }
+        public new TValue this[TKey key]
+        {
+            get
+            {
+                TValue t;
+                return base.TryGetValue(key, out t) ? t : _default;
+            }
+            set
+            {
+                base[key] = value;
+                DataChanged(this, null);
+            }
+        }
+
+        public new bool Remove(TKey key)
+        {
+            var found = base.Remove(key);
+            if (found)
+                DataChanged(this, null);
+
+            return found;
+        }
+
+        public event EventHandler DataChanged;
+
+    }
+
+    // A naive implementation of Windows.Storage.ApplicationDataContainer
+    public class ApplicationDataContainer
+    {
+        public DictionaryWithDefault<string, string> Values;
+        private readonly SemaphoreSlim mutex = new SemaphoreSlim(1, 1);
+
+        const string STORAGE_NAME = "AppStorage.data";
+        string storageFileName = null;
+
+        public ApplicationDataContainer(string name = STORAGE_NAME)
+        {
+            storageFileName = name;
+            var storageFile = FileSystem.Current.LocalStorage.CreateFileAsync(storageFileName, CreationCollisionOption.OpenIfExists).Result;
+            var data = CodePushUtils.GetJObjectFromFileAsync(storageFile).Result;
+
+            if (data != null)
+            {
+                Values = data.ToObject<DictionaryWithDefault<string, string>>();
+            }
+            else
+            {
+                Values = new DictionaryWithDefault<string, string>();
+            }
+
+            Values.DataChanged += async (s, e) => await SaveAsync();
+        }
+
+        ~ApplicationDataContainer()
+        {
+            mutex.Dispose();
+        }
+
+        async Task SaveAsync()
+        {
+            await mutex.WaitAsync().ConfigureAwait(false);
+            var jobject = JObject.FromObject(Values);
+            var storageFile = await FileSystem.Current.LocalStorage.CreateFileAsync(storageFileName, CreationCollisionOption.OpenIfExists).ConfigureAwait(false);
+            await storageFile.WriteAllTextAsync(JsonConvert.SerializeObject(jobject)).ConfigureAwait(false);
+            mutex.Release();
+        }
+
+        public async Task DeleteAsync()
+        {
+            Values.Clear();
+            var storageFile = await FileSystem.Current.LocalStorage.CreateFileAsync(storageFileName, CreationCollisionOption.OpenIfExists).ConfigureAwait(false);
+            await storageFile.DeleteAsync().ConfigureAwait(false);
+        }
+    }
+}

package/windows/CodePush.Net46/CodePush.Net46.csproj

@@ -0,0 +1,103 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{4DFE3F9F-5E15-4F17-8FD4-33FF0519348E}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>CodePush.Net46</RootNamespace>
+    <AssemblyName>CodePush.Net46</AssemblyName>
+    <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </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>
+  <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>
+  <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>$(SolutionDir)\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="PCLStorage, Version=1.0.2.0, Culture=neutral, PublicKeyToken=286fe515a2c35b64, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>$(SolutionDir)\packages\PCLStorage.1.0.2\lib\net45\PCLStorage.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="PCLStorage.Abstractions, Version=1.0.2.0, Culture=neutral, PublicKeyToken=286fe515a2c35b64, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>$(SolutionDir)\packages\PCLStorage.1.0.2\lib\net45\PCLStorage.Abstractions.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.IO.Compression" />
+    <Reference Include="System.IO.Compression.FileSystem" />
+    <Reference Include="System.Management" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Adapters\Http\HttpProgress.cs" />
+    <Compile Include="Adapters\Storage\ApplicationDataContainer.cs" />
+    <Compile Include="CodePushUtils.cs" />
+    <Compile Include="FileUtils.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UpdateManager.cs" />
+    <Compile Include="UpdateUtils.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\react-native-windows\ReactWindows\ReactNative.Net46\ReactNative.Net46.csproj">
+      <Project>{22cbff9c-fe36-43e8-a246-266c7635e662}</Project>
+      <Name>ReactNative.Net46</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="..\CodePush.Shared\CodePush.Shared.projitems" Label="Shared" />
+  <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>