@appzung/react-native-code-push 6.4.2 → 8.3.2

package/windows/CodePush/CodePushTelemetryManager.cpp

@@ -0,0 +1,213 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "CodePushTelemetryManager.h"
+#include "CodePushNativeModule.h"
+
+#include "winrt/Windows.Storage.h"
+#include "winrt/Windows.Data.Json.h"
+#include <string_view>
+
+namespace Microsoft::CodePush::ReactNative
+{
+    using namespace winrt;
+    using namespace Windows::Data::Json;
+    using namespace Windows::Storage;
+
+    static const std::wstring_view AppVersionKey{ L"appVersion" };
+    static const std::wstring_view DeploymentFailed{ L"DeploymentFailed" };
+    static const std::wstring_view DeploymentKeyKey{ L"deploymentKey" };
+    static const std::wstring_view DeploymentSucceeded{ L"DeploymentSucceeded" };
+    static const std::wstring_view LabelKey{ L"label" };
+    static const std::wstring_view LastDeploymentReportKey{ L"CODE_PUSH_LAST_DEPLOYMENT_REPORT" };
+    static const std::wstring_view PackageKey{ L"package" };
+    static const std::wstring_view PreviousDeploymentKeyKey{ L"previousDeploymentKey" };
+    static const std::wstring_view PreviousLabelOrAppVersionKey{ L"previousLabelOrAppVersion" };
+    static const std::wstring_view RetryDeploymentReportKey{ L"CODE_PUSH_RETRY_DEPLOYMENT_REPORT" };
+    static const std::wstring_view StatusKey{ L"status" };
+
+    /*static*/ JsonObject CodePushTelemetryManager::GetBinaryUpdateReport(std::wstring_view appVersion)
+    {
+        auto previousStatusReportIdentifier{ GetPreviousStatusReportIdentifier() };
+        if (previousStatusReportIdentifier.empty())
+        {
+            ClearRetryStatusReport();
+            JsonObject out;
+            out.Insert(AppVersionKey, JsonValue::CreateStringValue(appVersion));
+            return out;
+        }
+        else if (previousStatusReportIdentifier != appVersion)
+        {
+            if (IsStatusReportIdentifierCodePushLabel(previousStatusReportIdentifier))
+            {
+                auto previousDeploymentKey{ GetDeploymentKeyFromStatusReportIdentifier(previousStatusReportIdentifier) };
+                auto previousLabel{ GetVersionLabelFromStatusReportIdentifier(previousStatusReportIdentifier) };
+                ClearRetryStatusReport();
+                JsonObject out;
+                out.Insert(AppVersionKey, JsonValue::CreateStringValue(appVersion));
+                out.Insert(PreviousDeploymentKeyKey, JsonValue::CreateStringValue(previousDeploymentKey));
+                out.Insert(PreviousLabelOrAppVersionKey, JsonValue::CreateStringValue(previousLabel));
+                return out;
+            }
+            else
+            {
+                ClearRetryStatusReport();
+                // Previous status report was with a binary app version.
+                JsonObject out;
+                out.Insert(AppVersionKey, JsonValue::CreateStringValue(appVersion));
+                out.Insert(PreviousLabelOrAppVersionKey, JsonValue::CreateStringValue(previousStatusReportIdentifier));
+                return out;
+            }
+        }
+
+        return nullptr;
+    }
+
+    /*static*/ JsonObject CodePushTelemetryManager::GetRetryStatusReport()
+    {
+        auto localSettings{ CodePushNativeModule::GetLocalSettings() };
+        auto retryStatusReportData{ localSettings.Values().TryLookup(RetryDeploymentReportKey) };
+        if (retryStatusReportData != nullptr)
+        {
+            auto retryStatusReportString{ unbox_value<hstring>(retryStatusReportData) };
+            JsonObject retryStatusReport;
+            auto success{ JsonObject::TryParse(retryStatusReportString, retryStatusReport) };
+            if (success)
+            {
+                return retryStatusReport;
+            }
+        }
+        return nullptr;
+    }
+
+    /*static*/ JsonObject CodePushTelemetryManager::GetRollbackReport(const JsonObject& lastFailedPackage)
+    {
+        JsonObject out;
+        out.Insert(PackageKey, lastFailedPackage);
+        out.Insert(StatusKey, JsonValue::CreateStringValue(DeploymentFailed));
+        return out;
+    }
+
+    /*static*/ JsonObject CodePushTelemetryManager::GetUpdateReport(const JsonObject& currentPackage)
+    {
+        auto currentPackageIdentifier{ GetPackageStatusReportIdentifier(currentPackage) };
+        auto previousStatusReportIdentifier{ GetPreviousStatusReportIdentifier() };
+        if (currentPackageIdentifier.empty())
+        {
+            if (!previousStatusReportIdentifier.empty())
+            {
+                ClearRetryStatusReport();
+                JsonObject out;
+                out.Insert(PackageKey, currentPackage);
+                out.Insert(StatusKey, JsonValue::CreateStringValue(DeploymentSucceeded));
+                return out;
+            }
+            else if (previousStatusReportIdentifier != currentPackageIdentifier)
+            {
+                ClearRetryStatusReport();
+                if (IsStatusReportIdentifierCodePushLabel(previousStatusReportIdentifier))
+                {
+                    auto previousDeploymentKey{ GetDeploymentKeyFromStatusReportIdentifier(previousStatusReportIdentifier) };
+                    auto previousLabel{ GetVersionLabelFromStatusReportIdentifier(previousStatusReportIdentifier) };
+                    JsonObject out;
+                    out.Insert(PackageKey, currentPackage);
+                    out.Insert(StatusKey, JsonValue::CreateStringValue(DeploymentSucceeded));
+                    out.Insert(PreviousDeploymentKeyKey, JsonValue::CreateStringValue(previousDeploymentKey));
+                    out.Insert(PreviousLabelOrAppVersionKey, JsonValue::CreateStringValue(previousLabel));
+                    return out;
+                }
+                else
+                {
+                    // Previous status report was with a binary app version.
+                    JsonObject out;
+                    out.Insert(PackageKey, currentPackage);
+                    out.Insert(StatusKey, JsonValue::CreateStringValue(DeploymentSucceeded));
+                    out.Insert(PreviousLabelOrAppVersionKey, JsonValue::CreateStringValue(previousStatusReportIdentifier));
+                    return out;
+                }
+            }
+        }
+
+        return nullptr;
+    }
+
+    /*static*/ void CodePushTelemetryManager::RecordStatusReported(const JsonObject& statusReport)
+    {
+        // We don't need to record rollback reports, so exit early if that's what was specified.
+        auto status{ statusReport.TryLookup(StatusKey) };
+        if (status != nullptr && status.ValueType() == JsonValueType::String && status.GetString() == DeploymentFailed)
+        {
+            return;
+        }
+
+        if (statusReport.HasKey(AppVersionKey))
+        {
+            SaveStatusReportedForIdentifier(statusReport.GetNamedString(AppVersionKey));
+        }
+        else if (statusReport.HasKey(PackageKey))
+        {
+            auto packageIdentifier{ GetPackageStatusReportIdentifier(statusReport.GetNamedObject(PackageKey)) };
+            SaveStatusReportedForIdentifier(packageIdentifier);
+        }
+    }
+
+    /*static*/ void CodePushTelemetryManager::SaveStatusReportForRetry(const JsonObject& statusReport)
+    {
+        auto localSettings{ CodePushNativeModule::GetLocalSettings() };
+        localSettings.Values().Insert(RetryDeploymentReportKey, box_value(statusReport.Stringify()));
+    }
+
+    /*static*/ void CodePushTelemetryManager::ClearRetryStatusReport()
+    {
+        auto localSettings{ CodePushNativeModule::GetLocalSettings() };
+        localSettings.Values().Remove(RetryDeploymentReportKey);
+    }
+
+    /*static*/ std::wstring_view CodePushTelemetryManager::GetDeploymentKeyFromStatusReportIdentifier(std::wstring_view statusReportIdentifier)
+    {
+        return statusReportIdentifier.substr(0, statusReportIdentifier.find(':'));
+    }
+
+    /*static*/ hstring CodePushTelemetryManager::GetPackageStatusReportIdentifier(const JsonObject& package)
+    {
+        // Because deploymentKeys can be dynamically switched, we use a
+        // combination of the deploymentKey and label as the packageIdentifier.
+        if (package.HasKey(DeploymentKeyKey) && package.HasKey(LabelKey))
+        {
+            return L"";
+        }
+        auto deploymentKey{ package.GetNamedString(DeploymentKeyKey) };
+        auto label{ package.GetNamedString(LabelKey) };
+        return deploymentKey + L":" + label;
+    }
+
+    /*static*/ hstring CodePushTelemetryManager::GetPreviousStatusReportIdentifier()
+    {
+        auto localSettings{ CodePushNativeModule::GetLocalSettings() };
+        auto sentStatusReportIdentifierData{ localSettings.Values().TryLookup(LastDeploymentReportKey) };
+        if (sentStatusReportIdentifierData != nullptr)
+        {
+            auto sentStatusReportIdentifier{ unbox_value<hstring>(sentStatusReportIdentifierData) };
+            return sentStatusReportIdentifier;
+        }
+        return L"";
+    }
+
+    /*static*/ std::wstring_view CodePushTelemetryManager::GetVersionLabelFromStatusReportIdentifier(std::wstring_view statusReportIdentifier)
+    {
+        return statusReportIdentifier.substr(statusReportIdentifier.rfind(':') + 1);
+    }
+
+    /*static*/ bool CodePushTelemetryManager::IsStatusReportIdentifierCodePushLabel(std::wstring_view statusReportIdentifier)
+    {
+        return !statusReportIdentifier.empty() && statusReportIdentifier.find(':') != std::wstring_view::npos;
+    }
+
+    /*static*/ void CodePushTelemetryManager::SaveStatusReportedForIdentifier(std::wstring_view appVersionOrPackageIdentifier)
+    {
+        auto localSettings{ CodePushNativeModule::GetLocalSettings() };
+        localSettings.Values().Insert(LastDeploymentReportKey, box_value(appVersionOrPackageIdentifier));
+    }
+}

package/windows/CodePush/CodePushTelemetryManager.h

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "winrt/Windows.Data.Json.h"
+#include <string_view>
+
+namespace Microsoft::CodePush::ReactNative
+{
+	struct CodePushTelemetryManager
+	{
+		static winrt::Windows::Data::Json::JsonObject GetBinaryUpdateReport(std::wstring_view appVersion);
+		static winrt::Windows::Data::Json::JsonObject GetRetryStatusReport();
+		static winrt::Windows::Data::Json::JsonObject GetRollbackReport(const winrt::Windows::Data::Json::JsonObject& lastFailedPackage);
+		static winrt::Windows::Data::Json::JsonObject GetUpdateReport(const winrt::Windows::Data::Json::JsonObject& currentPackage);
+		static void RecordStatusReported(const winrt::Windows::Data::Json::JsonObject& statusReport);
+		static void SaveStatusReportForRetry(const winrt::Windows::Data::Json::JsonObject& statusReport);
+
+	private:
+		static void ClearRetryStatusReport();
+		static std::wstring_view GetDeploymentKeyFromStatusReportIdentifier(std::wstring_view statusReportIdentifier);
+		static winrt::hstring GetPackageStatusReportIdentifier(const winrt::Windows::Data::Json::JsonObject& package);
+		static winrt::hstring GetPreviousStatusReportIdentifier();
+		static std::wstring_view GetVersionLabelFromStatusReportIdentifier(std::wstring_view statusReportIdentifier);
+		static bool IsStatusReportIdentifierCodePushLabel(std::wstring_view statusReportIdentifier);
+		static void SaveStatusReportedForIdentifier(std::wstring_view appVersionOrPackageIdentifier);
+	};
+}

package/windows/CodePush/CodePushUpdateUtils.cpp

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "winrt/Windows.ApplicationModel.h"
+#include "winrt/Windows.Foundation.h"
+#include "winrt/Windows.Foundation.Collections.h"
+#include "winrt/Windows.Security.Cryptography.h"
+#include "winrt/Windows.Security.Cryptography.Core.h"
+#include "winrt/Windows.Storage.h"
+#include "winrt/Windows.Storage.FileProperties.h"
+#include "winrt/Windows.Storage.Streams.h"
+
+#include <algorithm>
+#include <string_view>
+#include <vector>
+
+#include "CodePushUpdateUtils.h"
+#include "CodePushUtils.h"
+#include "CodePushNativeModule.h"
+
+namespace Microsoft::CodePush::ReactNative
+{
+    using namespace winrt;
+    using namespace Windows::Foundation;
+    using namespace Windows::Foundation::Collections;
+    using namespace Windows::Storage;
+    using namespace Windows::Security::Cryptography;
+    using namespace Windows::Security::Cryptography::Core;
+
+    /*static*/ IAsyncOperation<bool> CodePushUpdateUtils::CopyEntriesInFolderAsync(StorageFolder& sourceFolder, StorageFolder& destFolder)
+    {
+        auto entries{ co_await sourceFolder.GetItemsAsync() };
+        for (const auto& entry : entries)
+        {
+            if (entry.IsOfType(StorageItemTypes::File))
+            {
+                auto file{ entry.try_as<StorageFile>() };
+                co_await file.CopyAsync(destFolder, file.Name(), NameCollisionOption::ReplaceExisting);
+            }
+            else if (entry.IsOfType(StorageItemTypes::Folder))
+            {
+                auto folder{ entry.try_as<StorageFolder>() };
+                auto folderCopy{ co_await destFolder.CreateFolderAsync(folder.Name(), CreationCollisionOption::ReplaceExisting) };
+                auto result{ co_await CopyEntriesInFolderAsync(folder, folderCopy) };
+                if (!result)
+                {
+                    co_return false;
+                }
+            }
+        }
+
+        co_return true;
+    }
+
+    /*static*/ IAsyncOperation<StorageFile> CodePushUpdateUtils::GetSignatureFileAsync(const StorageFolder& rootFolder)
+    {
+        auto manifestFolder{ (co_await rootFolder.TryGetItemAsync(ManifestFolderPrefix)).try_as<StorageFolder>() };
+        if (manifestFolder != nullptr)
+        {
+            auto bundleJWTFile{ (co_await rootFolder.TryGetItemAsync(BundleJWTFile)).try_as<StorageFile>() };
+            if (bundleJWTFile != nullptr)
+            {
+                co_return bundleJWTFile;
+            }
+        }
+        co_return nullptr;
+    }
+    
+    /*static*/ IAsyncOperation<hstring> CodePushUpdateUtils::ModifiedDateStringOfFileAsync(const StorageFile& file)
+    {
+        if (file != nullptr)
+        {
+            auto basicProperties{ co_await file.GetBasicPropertiesAsync() };
+            auto modifiedDate{ basicProperties.DateModified() };
+            auto mtime{ clock::to_time_t(modifiedDate) };
+            auto modifiedDateString{ to_hstring(mtime) };
+            co_return modifiedDateString;
+        }
+        else
+        {
+            co_return L"";
+        }
+    }
+}

package/windows/CodePush/CodePushUpdateUtils.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "winrt/Windows.Data.Json.h"
+#include "winrt/Windows.Foundation.h"
+#include "winrt/Windows.Storage.h"
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include <string_view>
+
+namespace Microsoft::CodePush::ReactNative
+{
+    struct CodePushUpdateUtils
+    {
+        static constexpr std::wstring_view AssetsFolderName{ L"assets" };
+        static constexpr std::wstring_view BinaryHashKey{ L"CodePushBinaryHash" };
+        static constexpr std::wstring_view ManifestFolderPrefix{ L"CodePush" };
+        static constexpr std::wstring_view BundleJWTFile{ L".codepushrelease" };
+
+        static winrt::Windows::Foundation::IAsyncOperation<bool> CopyEntriesInFolderAsync(
+            winrt::Windows::Storage::StorageFolder& sourceFolder,
+            winrt::Windows::Storage::StorageFolder& destFolder);
+
+        static winrt::Windows::Foundation::IAsyncOperation<winrt::hstring> ModifiedDateStringOfFileAsync(const winrt::Windows::Storage::StorageFile& file);
+
+        static winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::StorageFile> GetSignatureFileAsync(
+            const winrt::Windows::Storage::StorageFolder& rootFolder);
+
+    private:
+        /*
+         Ignore list for hashing
+         */
+        static constexpr std::wstring_view IgnoreMacOSX{ L"__MACOSX/" };
+        static constexpr std::wstring_view IgnoreDSStore{ L".DS_Store" };
+        static constexpr std::wstring_view IgnoreCodePushMetadata{ L".codepushrelease" };
+    };
+}

package/windows/CodePush/CodePushUtils.cpp

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "CodePushUtils.h"
+
+namespace Microsoft::CodePush::ReactNative
+{
+	using namespace winrt::Windows::Storage;
+
+	/*static*/ void CodePushUtils::Log(winrt::hstring message)
+	{
+		OutputDebugStringW(L"[CodePush] ");
+		OutputDebugStringW(message.c_str());
+		OutputDebugStringW(L"\n");
+	}
+
+	/*static*/ void CodePushUtils::Log(const winrt::hresult_error& ex)
+	{
+		OutputDebugStringW(L"[CodePush] Exception ");
+		OutputDebugStringW(ex.message().c_str());
+		OutputDebugStringW(L"\n");
+	}
+
+	/*static*/ void CodePushUtils::LogBundleUrl(const IStorageFile& bundle)
+	{
+		CodePushUtils::Log(L"Loading JS bundle from \"" + bundle.Path() + L"\"");
+	}
+}

package/windows/CodePush/CodePushUtils.h

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "winrt/base.h"
+#include "winrt/Windows.Storage.h"
+#include <exception>
+
+namespace Microsoft::CodePush::ReactNative
+{
+	struct CodePushUtils
+	{
+		static void Log(winrt::hstring message);
+		static void Log(const winrt::hresult_error& ex);
+		static void LogBundleUrl(const winrt::Windows::Storage::IStorageFile& bundle);
+	};
+}

package/windows/CodePush/FileUtils.cpp

@@ -0,0 +1,131 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "miniz/miniz.h"
+#include "winrt/Windows.Foundation.h"
+#include "winrt/Windows.Storage.h"
+#include "winrt/Windows.Storage.Search.h"
+#include "winrt/Windows.Storage.Streams.h"
+
+#include <string_view>
+#include <stack>
+
+#include "CodePushNativeModule.h"
+#include "FileUtils.h"
+
+namespace Microsoft::CodePush::ReactNative
+{
+    using namespace winrt;
+    using namespace Windows::Foundation;
+    using namespace Windows::Storage;
+    using namespace Windows::Storage::Search;
+    using namespace Windows::Storage::Streams;
+
+    /*static*/ IAsyncOperation<StorageFile> FileUtils::CreateFileFromPathAsync(StorageFolder rootFolder, const std::filesystem::path& relativePath)
+    {
+        auto relPath{ relativePath };
+
+        std::stack<std::string> pathParts;
+        pathParts.push(relPath.filename().string());
+        while (relPath.has_parent_path())
+        {
+            relPath = relPath.parent_path();
+            pathParts.push(relPath.filename().string());
+        }
+
+        while (pathParts.size() > 1)
+        {
+            auto itemName{ pathParts.top() };
+            rootFolder = co_await rootFolder.CreateFolderAsync(to_hstring(itemName), CreationCollisionOption::OpenIfExists);
+            pathParts.pop();
+        }
+        auto fileName{ pathParts.top() };
+        auto file{ co_await rootFolder.CreateFileAsync(to_hstring(fileName), CreationCollisionOption::ReplaceExisting) };
+        co_return file;
+    }
+
+    /*static*/ IAsyncOperation<hstring> FileUtils::FindFilePathAsync(const StorageFolder& rootFolder, std::wstring_view fileName)
+    {
+        try
+        {
+            std::vector<hstring> fileTypeFilter{};
+            fileTypeFilter.push_back(L".bundle");
+            QueryOptions queryOptions{ CommonFileQuery::OrderByName, fileTypeFilter };
+            queryOptions.IndexerOption(IndexerOption::DoNotUseIndexer);
+            queryOptions.ApplicationSearchFilter(L"System.FileName: " + fileName);
+            auto queryResult{ rootFolder.CreateFileQueryWithOptions(queryOptions) };
+            auto files{ co_await queryResult.GetFilesAsync() };
+
+            if (files.Size() > 0)
+            {
+                auto result{ files.GetAt(0) };
+                std::wstring_view bundlePath{ result.Path() };
+                hstring filePathSub{ bundlePath.substr(rootFolder.Path().size() + 1) };
+                co_return filePathSub;
+            }
+
+            co_return L"";
+        }
+        catch (...)
+        {
+            throw;
+        }
+    }
+
+    /*static*/ IAsyncAction FileUtils::UnzipAsync(const StorageFile& zipFile, const StorageFolder& destination)
+    {
+        std::string zipName{ to_string(zipFile.Path()) };
+
+        mz_bool status;
+        mz_zip_archive zip_archive;
+        mz_zip_zero_struct(&zip_archive);
+
+        status = mz_zip_reader_init_file(&zip_archive, zipName.c_str(), 0);
+        assert(status);
+        auto numFiles{ mz_zip_reader_get_num_files(&zip_archive) };
+
+        for (mz_uint i = 0; i < numFiles; i++)
+        {
+            mz_zip_archive_file_stat file_stat;
+            status = mz_zip_reader_file_stat(&zip_archive, i, &file_stat);
+            assert(status);
+            if (!mz_zip_reader_is_file_a_directory(&zip_archive, i))
+            {
+                auto fileName{ file_stat.m_filename };
+                auto filePath{ std::filesystem::path(fileName) };
+                auto filePathName{ filePath.filename() };
+                auto filePathNameString{ filePathName.string() };
+
+                auto entryFile{ co_await CreateFileFromPathAsync(destination, filePath) };
+                
+                auto stream{ co_await entryFile.OpenAsync(FileAccessMode::ReadWrite) };
+                auto os{ stream.GetOutputStreamAt(0) };
+                DataWriter dw{ os };
+
+                const auto arrBufSize = 8 * 1024;
+                std::array<uint8_t, arrBufSize> arrBuf;
+
+                mz_zip_reader_extract_iter_state* pState = mz_zip_reader_extract_iter_new(&zip_archive, i, 0);
+                while (size_t bytesRead{ mz_zip_reader_extract_iter_read(pState, static_cast<void*>(arrBuf.data()), arrBuf.size()) })
+                {
+                    array_view<const uint8_t> view{ arrBuf.data(), arrBuf.data() + bytesRead };
+                    dw.WriteBytes(view);
+                }
+                status = mz_zip_reader_extract_iter_free(pState);
+                assert(status);
+
+                co_await dw.StoreAsync();
+                co_await dw.FlushAsync();
+
+                dw.Close();
+                os.Close();
+                stream.Close();
+            }
+        }
+
+        status = mz_zip_reader_end(&zip_archive);
+        assert(status);
+    }
+}

package/windows/CodePush/FileUtils.h

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "winrt/Windows.Storage.h"
+#include "winrt/Windows.Foundation.h"
+
+#include <filesystem>
+#include <string_view>
+
+namespace Microsoft::CodePush::ReactNative
+{
+	struct FileUtils
+	{
+		static winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::StorageFile> CreateFileFromPathAsync(
+			winrt::Windows::Storage::StorageFolder rootFolder, 
+			const std::filesystem::path& relativePath);
+
+		static winrt::Windows::Foundation::IAsyncOperation<winrt::hstring> FindFilePathAsync(
+			const winrt::Windows::Storage::StorageFolder& rootFolder, 
+			std::wstring_view fileName);
+
+		static winrt::Windows::Foundation::IAsyncAction UnzipAsync(
+			const winrt::Windows::Storage::StorageFile& zipFile, 
+			const winrt::Windows::Storage::StorageFolder& destination);
+	};
+}

package/windows/CodePush/PropertySheet.props

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <!--
+    To customize common C++/WinRT project properties: 
+    * right-click the project node
+    * expand the Common Properties item
+    * select the C++/WinRT property page
+
+    For more advanced scenarios, and complete documentation, please see:
+    https://github.com/Microsoft/cppwinrt/tree/master/nuget 
+    -->
+  <PropertyGroup />
+  <ItemDefinitionGroup />
+</Project>

package/windows/CodePush/ReactPackageProvider.cpp

@@ -0,0 +1,15 @@
+#include "pch.h"
+#include "ReactPackageProvider.h"
+#include "ReactPackageProvider.g.cpp"
+
+#include "CodePushNativeModule.h"
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::Microsoft::CodePush::ReactNative::implementation {
+
+void ReactPackageProvider::CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept {
+  AddAttributedModules(packageBuilder);
+}
+
+} // namespace winrt::Microsoft::CodePush::ReactNative::implementation

package/windows/CodePush/ReactPackageProvider.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "winrt/Microsoft.CodePush.ReactNative.h"
+
+#include "ReactPackageProvider.g.h"
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::Microsoft::CodePush::ReactNative::implementation {
+
+struct ReactPackageProvider : ReactPackageProviderT<ReactPackageProvider> {
+  ReactPackageProvider() = default;
+
+  void CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept;
+};
+
+} // namespace winrt::RNFS::implementation
+
+namespace winrt::Microsoft::CodePush::ReactNative::factory_implementation {
+
+struct ReactPackageProvider : ReactPackageProviderT<ReactPackageProvider, implementation::ReactPackageProvider> {};
+
+} // namespace winrt::RNFS::factory_implementation

package/windows/CodePush/ReactPackageProvider.idl

@@ -0,0 +1,9 @@
+namespace Microsoft.CodePush.ReactNative
+{
+    [webhosthidden]
+    [default_interface]
+    runtimeclass ReactPackageProvider
+        : Microsoft.ReactNative.IReactPackageProvider {
+      ReactPackageProvider();
+    };
+} // namespace CppModule

package/windows/CodePush/miniz/LICENSE

@@ -0,0 +1,22 @@
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.