@swyng/react-native-code-push 1.0.0

package/expo.js

@@ -0,0 +1,347 @@
+const {
+  withAppDelegate,
+  withInfoPlist,
+  withStringsXml,
+  withAppBuildGradle,
+  withMainApplication, // Using the safer, higher-level helper
+  WarningAggregator,
+} = require('@expo/config-plugins');
+const fs = require('fs');
+const path = require('path');
+
+//================ iOS (Unchanged) ================
+function addImportIOS(content) {
+  const lines = content.split('\n');
+  const importIndices = lines
+    .map((line, idx) => (line.trim().startsWith('import ') || line.trim().startsWith('#import ') ? idx : -1))
+    .filter(idx => idx !== -1);
+  if (content.includes('import CodePush') || content.includes('#import <CodePush/CodePush.h>')) {
+    return content;
+  }
+  const codePushImport = 'import CodePush';
+  if (importIndices.length > 0) {
+    const lastImportIdx = importIndices[importIndices.length - 1];
+    lines.splice(lastImportIdx + 1, 0, codePushImport);
+    return lines.join('\n');
+  } else {
+    const swiftClassRegex = /class\s+AppDelegate\s*:\s*RCTAppDelegate\s*\{/m;
+    if (swiftClassRegex.test(content)) {
+        return content.replace(swiftClassRegex, `$&\n${codePushImport}`);
+    }
+    return codePushImport + '\n' + content;
+  }
+}
+
+function ensureBundleURLMethodIOS(content) {
+  const methodRegexOld = /-\s*\(NSURL\s*\*\s*\)\s*bundleURL\s*\{[^}]*\}/s;
+  const methodRegexSwift = /override func bundleURL\(\) -> URL\? \{[^}]*\}/s;
+  const newMethodBodyObjC = `- (NSURL *)bundleURL
+{
+#if DEBUG
+  return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@".expo/.virtual-metro-entry"];
+#else
+  return [CodePush bundleURL];
+#endif
+}`;
+  const newMethodBodySwift = `override func bundleURL() -> URL? {
+#if DEBUG
+  return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: ".expo/.virtual-metro-entry")
+#else
+  return CodePush.bundleURL()
+#endif
+}`;
+
+  if (methodRegexSwift.test(content)) {
+    return content.replace(methodRegexSwift, newMethodBodySwift);
+  } else if (methodRegexOld.test(content)) {
+    return content.replace(methodRegexOld, newMethodBodyObjC);
+  } else {
+    const appDelegateEndRegexObjC = /\@end/m;
+    const appDelegateEndRegexSwift = /\}\s*$/m;
+    if (appDelegateEndRegexObjC.test(content)) {
+        return content.replace(appDelegateEndRegexObjC, `\n${newMethodBodyObjC}\n\n@end`);
+    } else if (appDelegateEndRegexSwift.test(content)) {
+        const lastBraceIndex = content.lastIndexOf('}');
+        if (lastBraceIndex !== -1) {
+            return content.substring(0, lastBraceIndex) + `\n  ${newMethodBodySwift}\n` + content.substring(lastBraceIndex);
+        }
+    }
+  }
+  WarningAggregator.addWarningIOS('codepush-plugin', 'Could not find a suitable place to insert bundleURL() method in AppDelegate.');
+  return content;
+}
+
+const withCodePushAppDelegate = (config) => {
+  return withAppDelegate(config, (config) => {
+    let content = config.modResults.contents;
+    content = addImportIOS(content);
+    content = ensureBundleURLMethodIOS(content);
+    config.modResults.contents = content;
+    return config;
+  });
+};
+
+const withCodePushInfoPlist = (config, options = {}) => {
+  return withInfoPlist(config, (config) => {
+    if (options.ios && options.ios.CodePushDeploymentKey) {
+      config.modResults.CodePushDeploymentKey = options.ios.CodePushDeploymentKey;
+    }
+    if (options.ios && options.ios.CodePushServerURL) {
+      config.modResults.CodePushServerURL = options.ios.CodePushServerURL;
+    }
+    return config;
+  });
+};
+
+//================ Android (Refactored to use withMainApplication) ================
+
+const withAndroidMainApplication = (config) => {
+  return withMainApplication(config, (modConfig) => {
+    // Check for Kotlin
+    if (modConfig.modResults.language !== 'kt') {
+      WarningAggregator.addWarningAndroid(
+        'codepush-plugin',
+        `The CodePush plugin is skipping modifications to 'MainApplication' because it is not a Kotlin file. Your project must be configured to use Kotlin for Android.`
+      );
+      return modConfig;
+    }
+
+    let content = modConfig.modResults.contents;
+    const packageName = config.android.package;
+
+    // --- 1. Add Imports ---
+    const requiredImports = [
+      'import com.swyngpush.codepush.react.CodePush',
+      `import ${packageName}.R`,
+      'import android.util.Log',
+    ];
+    // Simple import adder
+    const lines = content.split('\n');
+    let lastImportIndex = -1;
+    const existingImports = new Set();
+    lines.forEach((line, index) => {
+      if (line.trim().startsWith('import ')) {
+        lastImportIndex = index;
+        existingImports.add(line.trim());
+      }
+    });
+    const importsToAdd = requiredImports.filter(imp => !existingImports.has(imp));
+    if (importsToAdd.length > 0) {
+      lines.splice(lastImportIndex + 1, 0, ...importsToAdd);
+    }
+    content = lines.join('\n');
+
+    // --- 2. Modify onCreate method ---
+    const onCreateRegex = /(override fun onCreate\(\)\s*\{)([\s\S]*?)(\n\s*\})/m;
+    const onCreateInjection = `
+    // CodePush: Initialize instance on app startup.
+    try {
+        Log.d("CodePushDebug", "Attempting to pre-initialize CodePush in onCreate...");
+        val deploymentKey = getString(R.string.CodePushDeploymentKey);
+        val isDebugMode = BuildConfig.DEBUG; 
+        CodePush.getInstance(deploymentKey, this, isDebugMode);
+        Log.d("CodePushDebug", "CodePush.getInstance() called in onCreate()");
+    } catch (e: Exception) {
+        Log.e("CodePushDebug", "Error pre-initializing CodePush in onCreate: " + e.message, e);
+    }
+`;
+    if (onCreateRegex.test(content) && !content.includes('CodePush.getInstance(deploymentKey, this, isDebugMode)')) {
+      content = content.replace(onCreateRegex, (match, onCreateStart, onCreateContent, onCreateEnd) => {
+        const soLoaderInitLineRegex = /^\s*SoLoader\.init\(this,.*\)/m;
+        const superOnCreateLineRegex = /^\s*super\.onCreate\(\)/m;
+
+        if (soLoaderInitLineRegex.test(onCreateContent)) {
+          // Found SoLoader.init(), insert after it
+          const modifiedContent = onCreateContent.replace(soLoaderInitLineRegex, `$&${onCreateInjection}`);
+          return `${onCreateStart}${modifiedContent}${onCreateEnd}`;
+        } else if (superOnCreateLineRegex.test(onCreateContent)) {
+          // SoLoader.init() not found, insert after super.onCreate()
+          const modifiedContent = onCreateContent.replace(superOnCreateLineRegex, `$&${onCreateInjection}`);
+          WarningAggregator.addWarningAndroid('codepush-plugin', 'SoLoader.init() not found in onCreate(). Placing CodePush initialization after super.onCreate().');
+          return `${onCreateStart}${modifiedContent}${onCreateEnd}`;
+        } else {
+          // Neither found, inject at the start of the method
+          WarningAggregator.addWarningAndroid('codepush-plugin', 'Could not find super.onCreate() or SoLoader.init() in onCreate(). CodePush initialization may be misplaced.');
+          return `${onCreateStart}${onCreateInjection}${onCreateContent}${onCreateEnd}`;
+        }
+      });
+    }
+
+    // --- 3. Modify getPackages method ---
+    const getPackagesRegex = /override fun getPackages\(\): List<ReactPackage>\s*\{/m;
+    const originalPackagesLineRegex = /val\s+packages\s*=\s*PackageList\(this\)\.packages/m;
+    const mutablePackagesLine = "val packages: MutableList<ReactPackage> = PackageList(this).packages.toMutableList()";
+    const packagesInjection = `
+        try {
+            val codePushInstance = CodePush.getInstance(getString(R.string.CodePushDeploymentKey), this@MainApplication, BuildConfig.DEBUG);
+            if (!packages.contains(codePushInstance)) {
+                packages.add(codePushInstance);
+                Log.d("CodePushDebug", "CodePush instance added to packages.");
+            } else {
+                Log.d("CodePushDebug", "CodePush instance was already present in packages list; not adding again.");
+            }
+        } catch (e: Exception) {
+            Log.e("CodePushDebug", "Error adding CodePush to packages list: " + e.message, e);
+        }
+`;
+    if (getPackagesRegex.test(content) && !content.includes('CodePush.getInstance(getString(R.string.CodePushDeploymentKey)')) {
+      if (originalPackagesLineRegex.test(content)) {
+        content = content.replace(originalPackagesLineRegex, mutablePackagesLine);
+        content = content.replace(/(\n\s*return\s+packages)/m, `\n${packagesInjection}$1`);
+      } else {
+        WarningAggregator.addWarningAndroid('codepush-plugin', 'Could not find standard packages list initialization in getPackages(). CodePush package not registered.');
+      }
+    }
+
+    // --- 4. Wire up CodePush bundle file ---
+    if (!content.includes("CodePush.getJSBundleFile()")) {
+      const getJSBundleFileMethodString = `
+      override fun getJSBundleFile(): String {
+          return CodePush.getJSBundleFile()
+      }`;
+      const reactNativeHostAnchors = [
+        /(override\s+fun\s+getJSMainModuleName\(\):\s*String\s*=\s*[^\n]+)\s*\n/m,
+        /(override\s+fun\s+getUseDeveloperSupport\(\):\s*Boolean\s*=\s*BuildConfig\.DEBUG)\s*\n/m,
+        /(override\s+val\s+isHermesEnabled:\s*Boolean\s*=\s*BuildConfig\.IS_HERMES_ENABLED)\s*\n/m,
+        /(override\s+val\s+isNewArchEnabled:\s*Boolean\s*=\s*BuildConfig\.IS_NEW_ARCHITECTURE_ENABLED)\s*\n/m,
+      ];
+      const reactNativeHostAnchor = reactNativeHostAnchors.find(anchor => anchor.test(content));
+
+      if (reactNativeHostAnchor) {
+        // RN <= 0.81 and Expo SDK 54 still configure the bundle via ReactNativeHost.
+        // Expo wraps the host, but ReactNativeHostWrapper delegates getJSBundleFile() to the wrapped host.
+        content = content.replace(reactNativeHostAnchor, `$1\n${getJSBundleFileMethodString}\n`);
+      } else {
+        // RN 0.82+: uses ReactHost via getDefaultReactHost() — pass jsBundleFilePath parameter
+        // Match the closing parenthesis of the getDefaultReactHost() call
+        const reactHostCallRegex = /(getDefaultReactHost\([\s\S]*?packageList\s*=[\s\S]*?\})([\s\S]*?\))/m;
+        if (reactHostCallRegex.test(content)) {
+          content = content.replace(reactHostCallRegex, (match, beforeClose, closing) => {
+            // Check if jsBundleFilePath is already set
+            if (match.includes('jsBundleFilePath')) return match;
+            // Insert the parameter before the closing parentheses
+            return `${beforeClose},\n      jsBundleFilePath = CodePush.getJSBundleFile()${closing}`;
+          });
+        } else {
+          WarningAggregator.addWarningAndroid(
+            'codepush-plugin',
+            'Could not detect a supported React host configuration in MainApplication. CodePush bundle file path not configured.'
+          );
+        }
+      }
+    }
+
+    modConfig.modResults.contents = content;
+    return modConfig;
+  });
+};
+
+const withAndroidGradle = (config) => {
+  return withAppBuildGradle(config, (modConfig) => {
+    if (modConfig.modResults.language === 'groovy') {
+      let content = modConfig.modResults.contents;
+      
+      // This part adds the codepush.gradle apply line and is correct.
+      const codePushApplyLine = 'apply from: "../../node_modules/@code-push-next/react-native-code-push/android/codepush.gradle"';
+      if (!content.includes(codePushApplyLine)) {
+        content += `\n${codePushApplyLine}\n`;
+      }
+
+      const debugConfigFieldLine = 'buildConfigField "boolean", "DEBUG", "true"';
+      const releaseConfigFieldLine = 'buildConfigField "boolean", "DEBUG", "false"';
+      const indent = '            ';
+
+      /**
+       * A robust function to add a configuration field to a specific build type.
+       * It operates on the entire gradle content to ensure context is never lost.
+       * @param {string} gradleContent The entire content of the build.gradle file.
+       * @param {string} buildType The name of the build type (e.g., "debug").
+       * @param {string} field The configuration line to add.
+       * @returns {string} The modified gradle content.
+       */
+      const addFieldToBuildType = (gradleContent, buildType, field) => {
+        // Regex to find a specific buildType block that is inside the buildTypes block
+        const buildTypeRegex = new RegExp(`(buildTypes\\s*\\{[\\s\\S]*?${buildType}\\s*\\{)([\\s\\S]*?)(\\n\\s*\\})`, 'm');
+        
+        if (buildTypeRegex.test(gradleContent)) {
+          // The build type block (e.g., debug {}) already exists.
+          return gradleContent.replace(buildTypeRegex, (match, startBlock, innerContent, endBlock) => {
+            if (innerContent.includes(field.trim())) {
+              return match; // Field already exists, no changes needed.
+            }
+            // Add the field to the existing block.
+            const newInnerContent = innerContent.trim() ? `${innerContent.trim()}\n${indent}${field.trim()}` : `\n${indent}${field.trim()}`;
+            return `${startBlock}${newInnerContent}\n        ${endBlock}`;
+          });
+        } else {
+          // The build type block does not exist, so we need to add it.
+          const buildTypesRegex = /(buildTypes\s*\{)([\s\S]*?)(\n\s*\})/m;
+          if (buildTypesRegex.test(gradleContent)) {
+             // The buildTypes block exists, so add the new build type to it.
+             return gradleContent.replace(buildTypesRegex, (match, startBlock, innerContent, endBlock) => {
+               const newBlock = `\n        ${buildType} {\n${indent}${field.trim()}\n        }`;
+               return `${startBlock}${innerContent.trim()}${newBlock}${endBlock}`;
+             });
+          } else {
+            // The buildTypes block itself doesn't exist, a rare edge case.
+            // Expo projects should always have a buildTypes block.
+            WarningAggregator.addWarningAndroid('codepush-plugin', `Could not find buildTypes { ... } block in app/build.gradle to add the '${buildType}' configuration.`);
+            return gradleContent;
+          }
+        }
+      };
+
+      // Apply the modifications for debug and release builds sequentially.
+      // Each function call operates on the full, updated content, preventing nesting errors.
+      content = addFieldToBuildType(content, 'debug', debugConfigFieldLine);
+      content = addFieldToBuildType(content, 'release', releaseConfigFieldLine);
+      
+      modConfig.modResults.contents = content;
+    } else {
+      WarningAggregator.addWarningAndroid('codepush-plugin', 'Cannot apply build.gradle modifications because it is not a groovy file.');
+    }
+    return modConfig;
+  });
+};
+
+const withAndroidStrings = (config, options) => {
+  return withStringsXml(config, (config) => {
+    if (!config.modResults.resources) config.modResults.resources = {};
+    if (!config.modResults.resources.string) config.modResults.resources.string = [];
+    const strings = config.modResults.resources.string;
+
+    const setString = (name, value) => {
+      const existing = strings.find(s => s.$.name === name);
+      if (existing) {
+        existing._ = value;
+      } else {
+        strings.push({$: { name, translatable: 'false' }, _: value });
+      }
+    };
+    if (options.android?.CodePushDeploymentKey) {
+      setString('CodePushDeploymentKey', options.android.CodePushDeploymentKey);
+    }
+    if (options.android?.CodePushServerURL) {
+      setString('CodePushServerUrl', options.android.CodePushServerURL);
+    }
+    return config;
+  });
+};
+
+// --- CORRECTED EXPORT BLOCK ---
+module.exports = (config, options = {}) => {
+  if (!options) options = {};
+  
+  if (options.ios) {
+    config = withCodePushAppDelegate(config, options);
+    config = withCodePushInfoPlist(config, options);
+  }
+  
+  if (options.android) {
+    config = withAndroidStrings(config, options); 
+    // Correctly call the wrapper functions we defined
+    config = withAndroidMainApplication(config);
+    config = withAndroidGradle(config); 
+  }
+  return config;
+};

package/ios/CodePush/Base64/Base64/MF_Base64Additions.h

@@ -0,0 +1,34 @@
+//
+//  MF_Base64Additions.h
+//  Base64 -- RFC 4648 compatible implementation
+//  see http://www.ietf.org/rfc/rfc4648.txt for more details
+//
+//  Designed to be compiled with Automatic Reference Counting
+//
+//  Created by Dave Poirier on 2012-06-14.
+//  Public Domain
+//  Hosted at https://github.com/ekscrypto/Base64
+//
+
+#import <Foundation/Foundation.h>
+
+@interface NSString (Base64Addition)
++(NSString *)stringFromBase64String:(NSString *)base64String;
++(NSString *)stringFromBase64UrlEncodedString:(NSString *)base64UrlEncodedString;
+-(NSString *)base64String;
+-(NSString *)base64UrlEncodedString;
+@end
+
+@interface NSData (Base64Addition)
++(NSData *)dataWithBase64String:(NSString *)base64String;
++(NSData *)dataWithBase64UrlEncodedString:(NSString *)base64UrlEncodedString;
+-(NSString *)base64String;
+-(NSString *)base64UrlEncodedString;
+@end
+
+@interface MF_Base64Codec : NSObject 
++(NSData *)dataFromBase64String:(NSString *)base64String;
++(NSString *)base64StringFromData:(NSData *)data;
++(NSString *)base64UrlEncodedStringFromBase64String:(NSString *)base64String;
++(NSString *)base64StringFromBase64UrlEncodedString:(NSString *)base64UrlEncodedString;
+@end

package/ios/CodePush/Base64/Base64/MF_Base64Additions.m

@@ -0,0 +1,252 @@
+//
+//  MF_Base64Additions.m
+//  Base64 -- RFC 4648 compatible implementation
+//  see http://www.ietf.org/rfc/rfc4648.txt for more details
+//
+//  Designed to be compiled with Automatic Reference Counting
+//
+//  Created by Dave Poirier on 2012-06-14.
+//  Public Domain
+//  Hosted at https://github.com/ekscrypto/Base64
+//
+
+#import "MF_Base64Additions.h"
+
+@implementation MF_Base64Codec
+
++(NSString *)base64StringFromBase64UrlEncodedString:(NSString *)base64UrlEncodedString
+{
+    NSString *s = base64UrlEncodedString;
+    s = [s stringByReplacingOccurrencesOfString:@"-" withString:@"+"];
+    s = [s stringByReplacingOccurrencesOfString:@"_" withString:@"/"];
+    switch (s.length % 4) {
+        case 2:
+            s = [s stringByAppendingString:@"=="];
+            break;
+        case 3:
+            s = [s stringByAppendingString:@"="];
+            break;
+        default:
+            break;
+    }
+    return s;
+}
+
++(NSString *)base64UrlEncodedStringFromBase64String:(NSString *)base64String
+{
+    NSString *s = base64String;
+    s = [s stringByReplacingOccurrencesOfString:@"=" withString:@""];
+    s = [s stringByReplacingOccurrencesOfString:@"+" withString:@"-"];
+    s = [s stringByReplacingOccurrencesOfString:@"/" withString:@"_"];
+    return s;
+}
+
++(NSData *)dataFromBase64String:(NSString *)encoding
+{
+    NSData *data = nil;
+    unsigned char *decodedBytes = NULL;
+    @try {
+#define __ 255
+        static char decodingTable[256] = {
+            __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x00 - 0x0F
+            __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x10 - 0x1F
+            __,__,__,__, __,__,__,__, __,__,__,62, __,__,__,63,  // 0x20 - 0x2F
+            52,53,54,55, 56,57,58,59, 60,61,__,__, __, 0,__,__,  // 0x30 - 0x3F
+            __, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,  // 0x40 - 0x4F
+            15,16,17,18, 19,20,21,22, 23,24,25,__, __,__,__,__,  // 0x50 - 0x5F
+            __,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,  // 0x60 - 0x6F
+            41,42,43,44, 45,46,47,48, 49,50,51,__, __,__,__,__,  // 0x70 - 0x7F
+            __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x80 - 0x8F
+            __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x90 - 0x9F
+            __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xA0 - 0xAF
+            __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xB0 - 0xBF
+            __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xC0 - 0xCF
+            __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xD0 - 0xDF
+            __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xE0 - 0xEF
+            __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xF0 - 0xFF
+        };
+        encoding = [encoding stringByReplacingOccurrencesOfString:@"=" withString:@""];
+        NSData *encodedData = [encoding dataUsingEncoding:NSASCIIStringEncoding];
+        unsigned char *encodedBytes = (unsigned char *)[encodedData bytes];
+        
+        NSUInteger encodedLength = [encodedData length];
+        if( encodedLength >= (NSUIntegerMax - 3) ) return nil; // NSUInteger overflow check
+        NSUInteger encodedBlocks = (encodedLength+3) >> 2;
+        NSUInteger expectedDataLength = encodedBlocks * 3;
+        
+        unsigned char decodingBlock[4];
+        
+        decodedBytes = malloc(expectedDataLength);
+        if( decodedBytes != NULL ) {
+            
+            NSUInteger i = 0;
+            NSUInteger j = 0;
+            NSUInteger k = 0;
+            unsigned char c;
+            while( i < encodedLength ) {
+                c = decodingTable[encodedBytes[i]];
+                i++;
+                if( c != __ ) {
+                    decodingBlock[j] = c;
+                    j++;
+                    if( j == 4 ) {
+                        decodedBytes[k] = (decodingBlock[0] << 2) | (decodingBlock[1] >> 4);                
+                        decodedBytes[k+1] = (decodingBlock[1] << 4) | (decodingBlock[2] >> 2);
+                        decodedBytes[k+2] = (decodingBlock[2] << 6) | (decodingBlock[3]);
+                        j = 0;
+                        k += 3;
+                    }
+                }
+            }
+            
+            // Process left over bytes, if any
+            if( j == 3 ) {
+                decodedBytes[k] = (decodingBlock[0] << 2) | (decodingBlock[1] >> 4);                
+                decodedBytes[k+1] = (decodingBlock[1] << 4) | (decodingBlock[2] >> 2);
+                k += 2;
+            } else if( j == 2 ) {
+                decodedBytes[k] = (decodingBlock[0] << 2) | (decodingBlock[1] >> 4);                
+                k += 1;
+            }
+            data = [[NSData alloc] initWithBytes:decodedBytes length:k];
+        }
+    }
+    @catch (NSException *exception) {
+        data = nil;
+        NSLog(@"WARNING: error occured while decoding base 32 string: %@", exception);
+    }
+    @finally {
+        if( decodedBytes != NULL ) {
+            free( decodedBytes );
+        }
+    }
+    return data;
+}
++(NSString *)base64StringFromData:(NSData *)data
+{
+    NSString *encoding = nil;
+    unsigned char *encodingBytes = NULL;
+    @try {
+        static char encodingTable[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        static NSUInteger paddingTable[] = {0,2,1};
+        //                 Table 1: The Base 64 Alphabet
+        //        
+        //    Value Encoding  Value Encoding  Value Encoding  Value Encoding
+        //        0 A            17 R            34 i            51 z
+        //        1 B            18 S            35 j            52 0
+        //        2 C            19 T            36 k            53 1
+        //        3 D            20 U            37 l            54 2
+        //        4 E            21 V            38 m            55 3
+        //        5 F            22 W            39 n            56 4
+        //        6 G            23 X            40 o            57 5
+        //        7 H            24 Y            41 p            58 6
+        //        8 I            25 Z            42 q            59 7
+        //        9 J            26 a            43 r            60 8
+        //       10 K            27 b            44 s            61 9
+        //       11 L            28 c            45 t            62 +
+        //       12 M            29 d            46 u            63 /
+        //       13 N            30 e            47 v
+        //       14 O            31 f            48 w         (pad) =
+        //       15 P            32 g            49 x
+        //       16 Q            33 h            50 y
+        
+        NSUInteger dataLength = [data length];
+        NSUInteger encodedBlocks = dataLength / 3;
+        if( (encodedBlocks + 1) >= (NSUIntegerMax / 4) ) return nil; // NSUInteger overflow check
+        NSUInteger padding = paddingTable[dataLength % 3];
+        if( padding > 0 ) encodedBlocks++;
+        NSUInteger encodedLength = encodedBlocks * 4;
+        
+        encodingBytes = malloc(encodedLength);
+        if( encodingBytes != NULL ) {
+            NSUInteger rawBytesToProcess = dataLength;
+            NSUInteger rawBaseIndex = 0;
+            NSUInteger encodingBaseIndex = 0;
+            unsigned char *rawBytes = (unsigned char *)[data bytes];
+            unsigned char rawByte1, rawByte2, rawByte3;
+            while( rawBytesToProcess >= 3 ) {
+                rawByte1 = rawBytes[rawBaseIndex];
+                rawByte2 = rawBytes[rawBaseIndex+1];
+                rawByte3 = rawBytes[rawBaseIndex+2];
+                encodingBytes[encodingBaseIndex] = encodingTable[((rawByte1 >> 2) & 0x3F)];
+                encodingBytes[encodingBaseIndex+1] = encodingTable[((rawByte1 << 4) & 0x30) | ((rawByte2 >> 4) & 0x0F) ];
+                encodingBytes[encodingBaseIndex+2] = encodingTable[((rawByte2 << 2) & 0x3C) | ((rawByte3 >> 6) & 0x03) ];
+                encodingBytes[encodingBaseIndex+3] = encodingTable[(rawByte3 & 0x3F)];
+                
+                rawBaseIndex += 3;
+                encodingBaseIndex += 4;
+                rawBytesToProcess -= 3;
+            }
+            rawByte2 = 0;
+            switch (dataLength-rawBaseIndex) {
+                case 2:
+                    rawByte2 = rawBytes[rawBaseIndex+1];
+                case 1:
+                    rawByte1 = rawBytes[rawBaseIndex];
+                    encodingBytes[encodingBaseIndex] = encodingTable[((rawByte1 >> 2) & 0x3F)];
+                    encodingBytes[encodingBaseIndex+1] = encodingTable[((rawByte1 << 4) & 0x30) | ((rawByte2 >> 4) & 0x0F) ];
+                    encodingBytes[encodingBaseIndex+2] = encodingTable[((rawByte2 << 2) & 0x3C) ];
+                    // we can skip rawByte3 since we have a partial block it would always be 0
+                    break;
+            }
+            // compute location from where to begin inserting padding, it may overwrite some bytes from the partial block encoding
+            // if their value was 0 (cases 1-2).
+            encodingBaseIndex = encodedLength - padding;
+            while( padding-- > 0 ) {
+                encodingBytes[encodingBaseIndex++] = '=';
+            }
+            encoding = [[NSString alloc] initWithBytes:encodingBytes length:encodedLength encoding:NSASCIIStringEncoding];
+        }
+    }
+    @catch (NSException *exception) {
+        encoding = nil;
+        NSLog(@"WARNING: error occured while tring to encode base 32 data: %@", exception);
+    }
+    @finally {
+        if( encodingBytes != NULL ) {
+            free( encodingBytes );
+        }
+    }
+    return encoding;
+}
+@end
+
+@implementation NSString (Base64Addition)
+-(NSString *)base64String
+{
+    NSData *utf8encoding = [self dataUsingEncoding:NSUTF8StringEncoding];
+    return [MF_Base64Codec base64StringFromData:utf8encoding];
+}
+-(NSString *)base64UrlEncodedString
+{
+    return [MF_Base64Codec base64UrlEncodedStringFromBase64String:[self base64String]];
+}
++(NSString *)stringFromBase64String:(NSString *)base64String
+{
+    NSData *utf8encoding = [MF_Base64Codec dataFromBase64String:base64String];
+    return [[NSString alloc] initWithData:utf8encoding encoding:NSUTF8StringEncoding];
+}
++(NSString *)stringFromBase64UrlEncodedString:(NSString *)base64UrlEncodedString
+{
+    return [self stringFromBase64String:[MF_Base64Codec base64StringFromBase64UrlEncodedString:base64UrlEncodedString]];
+}
+@end
+
+@implementation NSData (Base64Addition)
++(NSData *)dataWithBase64String:(NSString *)base64String
+{
+    return [MF_Base64Codec dataFromBase64String:base64String];
+}
++(NSData *)dataWithBase64UrlEncodedString:(NSString *)base64UrlEncodedString
+{
+    return [self dataWithBase64String:[MF_Base64Codec base64StringFromBase64UrlEncodedString:base64UrlEncodedString]];
+}
+-(NSString *)base64String
+{
+    return [MF_Base64Codec base64StringFromData:self];
+}
+-(NSString *)base64UrlEncodedString
+{
+    return [MF_Base64Codec base64UrlEncodedStringFromBase64String:[self base64String]];
+}
+@end

package/ios/CodePush/Base64/README.md

@@ -0,0 +1,47 @@
+[![CI Status](https://travis-ci.org/ekscrypto/Base64.svg?branch=master)](https://github.com/ekscrypto/Base64)
+
+Base64 Additions for Objective-C on Mac OS X and iOS
+=======
+
+
+Usage
+----
+Open the Xcode project file, and drag MF_Base64Additions.m/.h into your project.
+
+In files where you want to use Base64 encoding/decoding, simply include the header file and use one of the provided NSData or NSString additions.
+    
+Example use:
+    #import "MF_Base64Additions.h"
+    
+    NSString *helloWorld = @"Hello World";
+    NSString *helloInBase64 = [helloWorld base64String];
+    NSString *helloDecoded = [NSString stringFromBase64String:helloInBase64];
+
+
+
+
+Performance
+----
+* Encoding: Approximately 4 to 5 times faster than using the equivalent SecTransform.
+* Encoding: 30% faster than https://github.com/l4u/NSData-Base64
+* Decoding: 5% faster than using the equivalent SecTransform.
+* Decoding: 5% faster than https://github.com/l4u/NSData-Base64
+
+
+
+Requirements
+-----
+* Compile with Automatic Reference Counting
+* Compatible with Mac OSX 10.6+ and iOS 4.0+
+
+
+
+Implementation
+----
+* Implemented as per RFC 4648, see http://www.ietf.org/rfc/rfc4648.txt for more details.
+
+
+
+Licensing
+----
+* Public Domain