@appcircle/react-native-code-push 0.0.1-alpha.1

package/android/src/main/java/com/microsoft/codepush/react/FileUtils.java

@@ -0,0 +1,203 @@
+package com.microsoft.codepush.react;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+public class FileUtils {
+
+    private static final int WRITE_BUFFER_SIZE = 1024 * 8;
+
+    public static void copyDirectoryContents(String sourceDirectoryPath, String destinationDirectoryPath) throws IOException {
+        File sourceDir = new File(sourceDirectoryPath);
+        File destDir = new File(destinationDirectoryPath);
+        if (!destDir.exists()) {
+            destDir.mkdir();
+        }
+
+        for (File sourceFile : sourceDir.listFiles()) {
+            if (sourceFile.isDirectory()) {
+                copyDirectoryContents(
+                        CodePushUtils.appendPathComponent(sourceDirectoryPath, sourceFile.getName()),
+                        CodePushUtils.appendPathComponent(destinationDirectoryPath, sourceFile.getName()));
+            } else {
+                File destFile = new File(destDir, sourceFile.getName());
+                FileInputStream fromFileStream = null;
+                BufferedInputStream fromBufferedStream = null;
+                FileOutputStream destStream = null;
+                byte[] buffer = new byte[WRITE_BUFFER_SIZE];
+                try {
+                    fromFileStream = new FileInputStream(sourceFile);
+                    fromBufferedStream = new BufferedInputStream(fromFileStream);
+                    destStream = new FileOutputStream(destFile);
+                    int bytesRead;
+                    while ((bytesRead = fromBufferedStream.read(buffer)) > 0) {
+                        destStream.write(buffer, 0, bytesRead);
+                    }
+                } finally {
+                    try {
+                        if (fromFileStream != null) fromFileStream.close();
+                        if (fromBufferedStream != null) fromBufferedStream.close();
+                        if (destStream != null) destStream.close();
+                    } catch (IOException e) {
+                        throw new CodePushUnknownException("Error closing IO resources.", e);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void deleteDirectoryAtPath(String directoryPath) {
+        if (directoryPath == null) {
+            CodePushUtils.log("deleteDirectoryAtPath attempted with null directoryPath");
+            return;
+        }
+        File file = new File(directoryPath);
+        if (file.exists()) {
+            deleteFileOrFolderSilently(file);
+        }
+    }
+
+    public static void deleteFileAtPathSilently(String path) {
+        deleteFileOrFolderSilently(new File(path));
+    }
+
+    public static void deleteFileOrFolderSilently(File file) {
+        if (file.isDirectory()) {
+            File[] files = file.listFiles();
+            for (File fileEntry : files) {
+                if (fileEntry.isDirectory()) {
+                    deleteFileOrFolderSilently(fileEntry);
+                } else {
+                    fileEntry.delete();
+                }
+            }
+        }
+
+        if (!file.delete()) {
+            CodePushUtils.log("Error deleting file " + file.getName());
+        }
+    }
+
+    public static boolean fileAtPathExists(String filePath) {
+        return new File(filePath).exists();
+    }
+
+    public static void moveFile(File fileToMove, String newFolderPath, String newFileName) {
+        File newFolder = new File(newFolderPath);
+        if (!newFolder.exists()) {
+            newFolder.mkdirs();
+        }
+
+        File newFilePath = new File(newFolderPath, newFileName);
+        if (!fileToMove.renameTo(newFilePath)) {
+            throw new CodePushUnknownException("Unable to move file from " +
+                    fileToMove.getAbsolutePath() + " to " + newFilePath.getAbsolutePath() + ".");
+        }
+    }
+
+    public static String readFileToString(String filePath) throws IOException {
+        FileInputStream fin = null;
+        BufferedReader reader = null;
+        try {
+            File fl = new File(filePath);
+            fin = new FileInputStream(fl);
+            reader = new BufferedReader(new InputStreamReader(fin));
+            StringBuilder sb = new StringBuilder();
+            String line = null;
+            while ((line = reader.readLine()) != null) {
+                sb.append(line).append("\n");
+            }
+
+            return sb.toString();
+        } finally {
+            if (reader != null) reader.close();
+            if (fin != null) fin.close();
+        }
+    }
+
+    private static String validateFileName(String fileName, File destinationFolder) throws IOException {
+        String destinationFolderCanonicalPath = destinationFolder.getCanonicalPath() + File.separator;
+
+        File file = new File(destinationFolderCanonicalPath, fileName);
+        String canonicalPath = file.getCanonicalPath();
+
+        if (!canonicalPath.startsWith(destinationFolderCanonicalPath)) {
+            throw new IllegalStateException("File is outside extraction target directory.");
+        }
+
+        return canonicalPath;
+    }
+
+    public static void unzipFile(File zipFile, String destination) throws IOException {
+        FileInputStream fileStream = null;
+        BufferedInputStream bufferedStream = null;
+        ZipInputStream zipStream = null;
+        try {
+            fileStream = new FileInputStream(zipFile);
+            bufferedStream = new BufferedInputStream(fileStream);
+            zipStream = new ZipInputStream(bufferedStream);
+            ZipEntry entry;
+
+            File destinationFolder = new File(destination);
+            if (destinationFolder.exists()) {
+                deleteFileOrFolderSilently(destinationFolder);
+            }
+
+            destinationFolder.mkdirs();
+
+            byte[] buffer = new byte[WRITE_BUFFER_SIZE];
+            while ((entry = zipStream.getNextEntry()) != null) {
+                String fileName = validateFileName(entry.getName(), destinationFolder);
+                File file = new File(fileName);
+                if (entry.isDirectory()) {
+                    file.mkdirs();
+                } else {
+                    File parent = file.getParentFile();
+                    if (!parent.exists()) {
+                        parent.mkdirs();
+                    }
+
+                    FileOutputStream fout = new FileOutputStream(file);
+                    try {
+                        int numBytesRead;
+                        while ((numBytesRead = zipStream.read(buffer)) != -1) {
+                            fout.write(buffer, 0, numBytesRead);
+                        }
+                    } finally {
+                        fout.close();
+                    }
+                }
+                long time = entry.getTime();
+                if (time > 0) {
+                    file.setLastModified(time);
+                }
+            }
+        } finally {
+            try {
+                if (zipStream != null) zipStream.close();
+                if (bufferedStream != null) bufferedStream.close();
+                if (fileStream != null) fileStream.close();
+            } catch (IOException e) {
+                throw new CodePushUnknownException("Error closing IO resources.", e);
+            }
+        }
+    }
+
+    public static void writeStringToFile(String content, String filePath) throws IOException {
+        PrintWriter out = null;
+        try {
+            out = new PrintWriter(filePath);
+            out.print(content);
+        } finally {
+            if (out != null) out.close();
+        }
+    }
+}

package/android/src/main/java/com/microsoft/codepush/react/ReactHostHolder.java

@@ -0,0 +1,11 @@
+package com.microsoft.codepush.react;
+
+import com.facebook.react.ReactHost;
+import com.facebook.react.runtime.ReactHostDelegate;
+
+/**
+ * Provides access to a {@link ReactHostDelegate}
+ */
+public interface ReactHostHolder {
+    ReactHost getReactHost();
+}

package/android/src/main/java/com/microsoft/codepush/react/ReactInstanceHolder.java

@@ -0,0 +1,20 @@
+package com.microsoft.codepush.react;
+
+import com.facebook.react.ReactInstanceManager;
+
+/**
+ * Provides access to a {@link ReactInstanceManager}.
+ *
+ * ReactNativeHost already implements this interface, if you make use of that react-native
+ * component (just add `implements ReactInstanceHolder`).
+ */
+public interface ReactInstanceHolder {
+
+  /**
+   * Get the current {@link ReactInstanceManager} instance. May return null.
+   */
+  ReactInstanceManager getReactInstanceManager();
+
+
+
+}

package/android/src/main/java/com/microsoft/codepush/react/SettingsManager.java

@@ -0,0 +1,173 @@
+package com.microsoft.codepush.react;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class SettingsManager {
+
+    private SharedPreferences mSettings;
+
+    public SettingsManager(Context applicationContext) {
+        mSettings = applicationContext.getSharedPreferences(CodePushConstants.CODE_PUSH_PREFERENCES, 0);
+    }
+
+    public JSONArray getFailedUpdates() {
+        String failedUpdatesString = mSettings.getString(CodePushConstants.FAILED_UPDATES_KEY, null);
+        if (failedUpdatesString == null) {
+            return new JSONArray();
+        }
+
+        try {
+            return new JSONArray(failedUpdatesString);
+        } catch (JSONException e) {
+            // Unrecognized data format, clear and replace with expected format.
+            JSONArray emptyArray = new JSONArray();
+            mSettings.edit().putString(CodePushConstants.FAILED_UPDATES_KEY, emptyArray.toString()).commit();
+            return emptyArray;
+        }
+    }
+
+    public JSONObject getPendingUpdate() {
+        String pendingUpdateString = mSettings.getString(CodePushConstants.PENDING_UPDATE_KEY, null);
+        if (pendingUpdateString == null) {
+            return null;
+        }
+
+        try {
+            return new JSONObject(pendingUpdateString);
+        } catch (JSONException e) {
+            // Should not happen.
+            CodePushUtils.log("Unable to parse pending update metadata " + pendingUpdateString +
+                    " stored in SharedPreferences");
+            return null;
+        }
+    }
+
+
+    public boolean isFailedHash(String packageHash) {
+        JSONArray failedUpdates = getFailedUpdates();
+        if (packageHash != null) {
+            for (int i = 0; i < failedUpdates.length(); i++) {
+                try {
+                    JSONObject failedPackage = failedUpdates.getJSONObject(i);
+                    String failedPackageHash = failedPackage.getString(CodePushConstants.PACKAGE_HASH_KEY);
+                    if (packageHash.equals(failedPackageHash)) {
+                        return true;
+                    }
+                } catch (JSONException e) {
+                    throw new CodePushUnknownException("Unable to read failedUpdates data stored in SharedPreferences.", e);
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public boolean isPendingUpdate(String packageHash) {
+        JSONObject pendingUpdate = getPendingUpdate();
+
+        try {
+            return pendingUpdate != null &&
+                    !pendingUpdate.getBoolean(CodePushConstants.PENDING_UPDATE_IS_LOADING_KEY) &&
+                    (packageHash == null || pendingUpdate.getString(CodePushConstants.PENDING_UPDATE_HASH_KEY).equals(packageHash));
+        } catch (JSONException e) {
+            throw new CodePushUnknownException("Unable to read pending update metadata in isPendingUpdate.", e);
+        }
+    }
+
+    public void removeFailedUpdates() {
+        mSettings.edit().remove(CodePushConstants.FAILED_UPDATES_KEY).commit();
+    }
+
+    public void removePendingUpdate() {
+        mSettings.edit().remove(CodePushConstants.PENDING_UPDATE_KEY).commit();
+    }
+
+    public void saveFailedUpdate(JSONObject failedPackage) {
+        try {
+            if (isFailedHash(failedPackage.getString(CodePushConstants.PACKAGE_HASH_KEY))) {
+                // Do not need to add the package if it is already in the failedUpdates.
+                return;
+            }
+        } catch (JSONException e) {
+            throw new CodePushUnknownException("Unable to read package hash from package.", e);
+        }
+
+        String failedUpdatesString = mSettings.getString(CodePushConstants.FAILED_UPDATES_KEY, null);
+        JSONArray failedUpdates;
+        if (failedUpdatesString == null) {
+            failedUpdates = new JSONArray();
+        } else {
+            try {
+                failedUpdates = new JSONArray(failedUpdatesString);
+            } catch (JSONException e) {
+                // Should not happen.
+                throw new CodePushMalformedDataException("Unable to parse failed updates information " +
+                        failedUpdatesString + " stored in SharedPreferences", e);
+            }
+        }
+
+        failedUpdates.put(failedPackage);
+        mSettings.edit().putString(CodePushConstants.FAILED_UPDATES_KEY, failedUpdates.toString()).commit();
+    }
+
+    public JSONObject getLatestRollbackInfo() {
+        String latestRollbackInfoString = mSettings.getString(CodePushConstants.LATEST_ROLLBACK_INFO_KEY, null);
+        if (latestRollbackInfoString == null) {
+            return null;
+        }
+
+        try {
+            return new JSONObject(latestRollbackInfoString);
+        } catch (JSONException e) {
+            // Should not happen.
+            CodePushUtils.log("Unable to parse latest rollback metadata " + latestRollbackInfoString +
+                    " stored in SharedPreferences");
+            return null;
+        }
+    }
+
+    public void setLatestRollbackInfo(String packageHash) {
+        JSONObject latestRollbackInfo = getLatestRollbackInfo();
+        int count = 0;
+
+        if (latestRollbackInfo != null) {
+            try {
+                String latestRollbackPackageHash = latestRollbackInfo.getString(CodePushConstants.LATEST_ROLLBACK_PACKAGE_HASH_KEY);
+                if (latestRollbackPackageHash.equals(packageHash)) {
+                    count = latestRollbackInfo.getInt(CodePushConstants.LATEST_ROLLBACK_COUNT_KEY);
+                }
+            } catch (JSONException e) {
+                CodePushUtils.log("Unable to parse latest rollback info.");
+            }
+        } else {
+            latestRollbackInfo = new JSONObject();
+        }
+
+        try {
+            latestRollbackInfo.put(CodePushConstants.LATEST_ROLLBACK_PACKAGE_HASH_KEY, packageHash);
+            latestRollbackInfo.put(CodePushConstants.LATEST_ROLLBACK_TIME_KEY, System.currentTimeMillis());
+            latestRollbackInfo.put(CodePushConstants.LATEST_ROLLBACK_COUNT_KEY, count + 1);
+            mSettings.edit().putString(CodePushConstants.LATEST_ROLLBACK_INFO_KEY, latestRollbackInfo.toString()).commit();
+        } catch (JSONException e) {
+            throw new CodePushUnknownException("Unable to save latest rollback info.", e);
+        }
+    }
+
+    public void savePendingUpdate(String packageHash, boolean isLoading) {
+        JSONObject pendingUpdate = new JSONObject();
+        try {
+            pendingUpdate.put(CodePushConstants.PENDING_UPDATE_HASH_KEY, packageHash);
+            pendingUpdate.put(CodePushConstants.PENDING_UPDATE_IS_LOADING_KEY, isLoading);
+            mSettings.edit().putString(CodePushConstants.PENDING_UPDATE_KEY, pendingUpdate.toString()).commit();
+        } catch (JSONException e) {
+            // Should not happen.
+            throw new CodePushUnknownException("Unable to save pending update.", e);
+        }
+    }
+
+}

package/android/src/main/java/com/microsoft/codepush/react/TLSSocketFactory.java

@@ -0,0 +1,72 @@
+package com.microsoft.codepush.react;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+public class TLSSocketFactory extends SSLSocketFactory {
+
+    private SSLSocketFactory delegate;
+
+    public TLSSocketFactory() throws KeyManagementException, NoSuchAlgorithmException {
+        SSLContext context = SSLContext.getInstance("TLS");
+        context.init(null, null, null);
+        delegate = context.getSocketFactory();
+    }
+
+    @Override
+    public String[] getDefaultCipherSuites() {
+        return delegate.getDefaultCipherSuites();
+    }
+
+    @Override
+    public String[] getSupportedCipherSuites() {
+        return delegate.getSupportedCipherSuites();
+    }
+
+    @Override
+    public Socket createSocket() throws IOException {
+        return enableTLSOnSocket(delegate.createSocket());
+    }
+
+    @Override
+    public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
+        return enableTLSOnSocket(delegate.createSocket(s, host, port, autoClose));
+    }
+
+    @Override
+    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
+        return enableTLSOnSocket(delegate.createSocket(host, port));
+    }
+
+    @Override
+    public Socket createSocket(String host, int port, InetAddress localHost, int localPort)
+            throws IOException, UnknownHostException {
+        return enableTLSOnSocket(delegate.createSocket(host, port, localHost, localPort));
+    }
+
+    @Override
+    public Socket createSocket(InetAddress host, int port) throws IOException {
+        return enableTLSOnSocket(delegate.createSocket(host, port));
+    }
+
+    @Override
+    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)
+            throws IOException {
+        return enableTLSOnSocket(delegate.createSocket(address, port, localAddress, localPort));
+    }
+
+    private Socket enableTLSOnSocket(Socket socket) {
+        if (socket != null && (socket instanceof SSLSocket)) {
+            ((SSLSocket) socket).setEnabledProtocols(new String[] { "TLSv1.1", "TLSv1.2" });
+        }
+        return socket;
+    }
+}

package/docs/api-android.md

@@ -0,0 +1,81 @@
+### Resource Configuration 
+
+Since `autolinking` uses `react-native.config.js` to link plugins, constructors are specified in that file. But you can override custom variables to manage the CodePush plugin by placing these values in string resources.
+
+* __Public Key__ - used for bundle verification in the Code Signing Feature. Please refer to [Code Signing](setup-android.md#code-signing-setup) section for more details about the Code Signing Feature.
+    To set the public key, you should add the content of the public key to `strings.xml` with name `CodePushPublicKey`. CodePush automatically gets this property and enables the Code Signing feature. For example:
+    ```xml
+    <string moduleConfig="true" name="CodePushPublicKey">your-public-key</string>
+    ```
+
+* __Server Url__ - used for specifying CodePush Server Url.
+    The Default value: "https://codepush.appcenter.ms/" is overridden by adding your path to `strings.xml` with name `CodePushServerUrl`. CodePush automatically gets this property and will use this path to send requests. For example:
+    ```xml
+    <string moduleConfig="true" name="CodePushServerUrl">https://yourcodepush.server.com</string>
+    ```
+
+The Java API is made available by importing the `com.microsoft.codepush.react.CodePush` class into your `MainActivity.java` file, and consists of a single public class named `CodePush`.
+
+### Java API Reference (Android)
+
+#### CodePush
+
+Constructs the CodePush client runtime and represents the `ReactPackage` instance that you add to you app's list of packages.
+
+##### Constructors
+
+- __CodePush(String deploymentKey, Activity mainActivity)__ - Creates a new instance of the CodePush runtime, that will be used to query the service for updates via the provided deployment key. The `mainActivity` parameter should always be set to `this` when configuring your React packages list inside the `MainActivity` class. This constructor puts the CodePush runtime into "release mode", so if you want to enable debugging behavior, use the following constructor instead.
+
+- __CodePush(String deploymentKey, Activity mainActivity, bool isDebugMode)__ - Equivalent to the previous constructor but allows you to specify whether you want the CodePush runtime to be in debug mode or not. When using this constructor, the `isDebugMode` parameter should always be set to `BuildConfig.DEBUG` in order to stay synchronized with your build type. When putting CodePush into debug mode, the following behaviors are enabled:
+
+    1. Old CodePush updates aren't deleted from storage whenever a new binary is deployed to the emulator/device. This behavior enables you to deploy new binaries, without bumping the version during development, and without continuously getting the same update every time your app calls `sync`.
+
+    2. The local cache that the React Native runtime maintains in debug mode is deleted whenever a CodePush update is installed. This ensures that when the app is restarted after an update is applied, you will see the expected changes. As soon as [this PR](https://github.com/facebook/react-native/pull/4738) is merged, we won't need to do this anymore.
+
+- __CodePush(String deploymentKey, Context context, boolean isDebugMode, Integer publicKeyResourceDescriptor)__ - Equivalent to the previous constructor, but allows you to specify the public key resource descriptor needed to read public key content. Please refer to [Code Signing](setup-android.md#code-signing-setup) section for more details about the Code Signing Feature.
+
+- __CodePush(String deploymentKey, Context context, boolean isDebugMode, String serverUrl)__ Constructor allows you to specify CodePush Server Url. The Default value: `"https://codepush.appcenter.ms/"` is overridden by value specified in `serverUrl`.
+
+##### Builder
+
+As an alternative to constructors *you can also use `CodePushBuilder`* to setup a CodePush instance configured with *only parameters you want*.
+
+```java
+    @Override
+    protected List<ReactPackage> getPackages() {
+      return Arrays.<ReactPackage>asList(
+            new MainReactPackage(),
+            new CodePushBuilder("deployment-key-here",getApplicationContext())
+                .setIsDebugMode(BuildConfig.DEBUG)
+                .setPublicKeyResourceDescriptor(R.string.publicKey)
+                .setServerUrl("https://yourcodepush.server.com")
+                .build() //return configured CodePush instance
+      );
+    }
+```
+
+`CodePushBuilder` methods:
+
+* __public CodePushBuilder(String deploymentKey, Context context)__ - setup same parameters as via __CodePush(String deploymentKey, Activity mainActivity)__
+
+* __public CodePushBuilder setIsDebugMode(boolean isDebugMode)__ - allows you to specify whether you want the CodePush runtime to be in debug mode or not. Default value: `false`.
+
+* __public CodePushBuilder setServerUrl(String serverUrl)__ - allows you to specify CodePush Server Url. Default value: `"https://codepush.appcenter.ms/"`.
+
+* __public CodePushBuilder setPublicKeyResourceDescriptor(int publicKeyResourceDescriptor)__ - allows you to specify Public Key resource descriptor which will be used for reading Public Key content for `strings.xml` file. Please refer to [Code Signing](setup-android.md#code-signing-setup) section for more detailed information about purpose of this parameter.
+
+* __public CodePush build()__ - return configured `CodePush` instance.
+
+##### Public Methods
+
+- __setDeploymentKey(String deploymentKey)__ - Sets the deployment key that the app should use when querying for updates. This is a dynamic alternative to setting the deployment key in Codepush constructor/builder and/or specifying a deployment key in JS when calling `checkForUpdate` or `sync`.
+
+##### Static Methods
+
+- __getBundleUrl()__ - Returns the path to the most recent version of your app's JS bundle file, assuming that the resource name is `index.android.bundle`. If your app is using a different bundle name, then use the overloaded version of this method which allows specifying it. This method has the same resolution behavior as the Objective-C equivalent described above.
+
+- __getBundleUrl(String bundleName)__ - Returns the path to the most recent version of your app's JS bundle file, using the specified resource name (like `index.android.bundle`). This method has the same resolution behavior as the Objective-C equivalent described above.
+
+- __getPackageFolder()__ - Returns the path to the current update folder.
+
+- __overrideAppVersion(String appVersionOverride)__ - Sets the version of the application's binary interface, which would otherwise default to the Play Store version specified as the `versionName` in the `build.gradle`. This should be called a single time, before the CodePush instance is constructed.

package/docs/api-ios.md

@@ -0,0 +1,31 @@
+### Objective-C API Reference (iOS)
+
+The Objective-C API is made available by importing the `CodePush.h` header into your `AppDelegate.m` file, and consists of a single public class named `CodePush`.
+
+#### CodePush
+
+Contains static methods for retreiving the `NSURL` that represents the most recent JavaScript bundle file, and can be passed to the `RCTRootView`'s `initWithBundleURL` method when bootstrapping your app in the `AppDelegate.m` file.
+
+The `CodePush` class' methods can be thought of as composite resolvers which always load the appropriate bundle, in order to accommodate the following scenarios:
+
+1. When an end-user installs your app from the store (like `1.0.0`), they will get the JS bundle that is contained within the binary. This is the behavior you would get without using CodePush, but we make sure it doesn't break :)
+
+2. As soon as you begin releasing CodePush updates, your end-users will get the JS bundle that represents the latest release for the configured deployment. This is the behavior that allows you to iterate beyond what you shipped to the store.
+
+3. As soon as you release an update to the app store (like `1.1.0`), and your end-users update it, they will once again get the JS bundle that is contained within the binary. This behavior ensures that CodePush updates that targetted a previous binary version aren't used (since we don't know if they would work), and your end-users always have a working version of your app.
+
+4. Repeat #2 and #3 as the CodePush releases and app store releases continue on into infinity (and beyond?)
+
+Because of this behavior, you can safely deploy updates to both the app store(s) and CodePush as necesary, and rest assured that your end-users will always get the most recent version.
+
+##### Methods
+
+- __(NSURL \*)bundleURL__ - Returns the most recent JS bundle `NSURL` as described above. This method assumes that the name of the JS bundle contained within your app binary is `main.jsbundle`.
+
+- __(NSURL \*)bundleURLForResource:(NSString \*)resourceName__ - Equivalent to the `bundleURL` method, but also allows customizing the name of the JS bundle that is looked for within the app binary. This is useful if you aren't naming this file `main` (which is the default convention). This method assumes that the JS bundle's extension is `*.jsbundle`.
+
+- __(NSURL \*)bundleURLForResource:(NSString \*)resourceName withExtension:(NSString \*)resourceExtension__: Equivalent to the `bundleURLForResource:` method, but also allows customizing the extension used by the JS bundle that is looked for within the app binary. This is useful if you aren't naming this file `*.jsbundle` (which is the default convention).
+
+- __(void)overrideAppVersion:(NSString \*)appVersionOverride__ - Sets the version of the application's binary interface, which would otherwise default to the App Store version specified as the `CFBundleShortVersionString` in the `Info.plist`. This should be called a single time, before the bundle URL is loaded.
+
+- __(void)setDeploymentKey:(NSString \*)deploymentKey__ - Sets the deployment key that the app should use when querying for updates. This is a dynamic alternative to setting the deployment key in your `Info.plist` and/or specifying a deployment key in JS when calling `checkForUpdate` or `sync`.