react-native-ota-sdk 1.0.0

package/android/src/main/java/com/otaupdater/react/BundleManager.java

@@ -0,0 +1,327 @@
+package com.otaupdater.react;
+
+import android.os.Build;
+
+import org.json.JSONObject;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.nio.ByteBuffer;
+
+import javax.net.ssl.HttpsURLConnection;
+
+public class BundleManager {
+
+    private String mDocumentsDirectory;
+    private String mBundleFileName;
+
+    public BundleManager(String documentsDirectory) {
+        this(documentsDirectory, OTAConstants.DEFAULT_JS_BUNDLE_NAME);
+    }
+
+    public BundleManager(String documentsDirectory, String bundleFileName) {
+        mDocumentsDirectory = documentsDirectory;
+        mBundleFileName = bundleFileName;
+    }
+
+    private String getDownloadFilePath() {
+        return OTAUtils.appendPathComponent(getOTAPath(), OTAConstants.DOWNLOAD_FILE_NAME);
+    }
+
+    private String getUnzippedFolderPath() {
+        return OTAUtils.appendPathComponent(getOTAPath(), OTAConstants.UNZIPPED_FOLDER_NAME);
+    }
+
+    private String getDocumentsDirectory() {
+        return mDocumentsDirectory;
+    }
+
+    private String getOTAPath() {
+        return OTAUtils.appendPathComponent(getDocumentsDirectory(), OTAConstants.CODE_PUSH_FOLDER_PREFIX);
+    }
+
+    private String getStatusFilePath() {
+        return OTAUtils.appendPathComponent(getOTAPath(), OTAConstants.STATUS_FILE);
+    }
+
+    public JSONObject getCurrentPackageInfo() {
+        String statusFilePath = getStatusFilePath();
+        if (!FileUtils.fileAtPathExists(statusFilePath)) {
+            return new JSONObject();
+        }
+
+        try {
+            return OTAUtils.getJsonObjectFromFile(statusFilePath);
+        } catch (IOException e) {
+            throw new OTAUnknownException("Error getting current package info", e);
+        }
+    }
+
+    public void updateCurrentPackageInfo(JSONObject packageInfo) {
+        try {
+            OTAUtils.writeJsonToFile(packageInfo, getStatusFilePath());
+        } catch (IOException e) {
+            throw new OTAUnknownException("Error updating current package info", e);
+        }
+    }
+
+    public String getCurrentPackageFolderPath() {
+        JSONObject info = getCurrentPackageInfo();
+        String packageHash = info.optString(OTAConstants.CURRENT_PACKAGE_KEY, null);
+        if (packageHash == null) {
+            return null;
+        }
+
+        return getPackageFolderPath(packageHash);
+    }
+
+    public String getCurrentPackageBundlePath(String bundleFileName) {
+        String packageFolder = getCurrentPackageFolderPath();
+        if (packageFolder == null) {
+            return null;
+        }
+
+        JSONObject currentPackage = getCurrentPackage();
+        if (currentPackage == null) {
+            return null;
+        }
+
+        String relativeBundlePath = currentPackage.optString(OTAConstants.RELATIVE_BUNDLE_PATH_KEY, null);
+        if (relativeBundlePath == null) {
+            return OTAUtils.appendPathComponent(packageFolder, bundleFileName);
+        } else {
+            return OTAUtils.appendPathComponent(packageFolder, relativeBundlePath);
+        }
+    }
+
+    public String getPackageFolderPath(String packageHash) {
+        return OTAUtils.appendPathComponent(getOTAPath(), packageHash);
+    }
+
+    public String getCurrentPackageHash() {
+        JSONObject info = getCurrentPackageInfo();
+        return info.optString(OTAConstants.CURRENT_PACKAGE_KEY, null);
+    }
+
+    public String getPreviousPackageHash() {
+        JSONObject info = getCurrentPackageInfo();
+        return info.optString(OTAConstants.PREVIOUS_PACKAGE_KEY, null);
+    }
+
+    public JSONObject getCurrentPackage() {
+        String packageHash = getCurrentPackageHash();
+        if (packageHash == null) {
+            return null;
+        }
+
+        return getPackage(packageHash);
+    }
+
+    public JSONObject getPreviousPackage() {
+        String packageHash = getPreviousPackageHash();
+        if (packageHash == null) {
+            return null;
+        }
+
+        return getPackage(packageHash);
+    }
+
+    public JSONObject getPackage(String packageHash) {
+        String folderPath = getPackageFolderPath(packageHash);
+        String packageFilePath = OTAUtils.appendPathComponent(folderPath, OTAConstants.PACKAGE_FILE_NAME);
+        try {
+            return OTAUtils.getJsonObjectFromFile(packageFilePath);
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    public void downloadPackage(JSONObject updatePackage, String expectedBundleFileName,
+                                DownloadProgressCallback progressCallback) throws IOException {
+        String newUpdateHash = updatePackage.optString(OTAConstants.PACKAGE_HASH_KEY, null);
+        if (newUpdateHash == null) {
+            // Generate hash from version if not provided
+            String versionName = updatePackage.optString(OTAConstants.VERSION_NAME_KEY, "unknown");
+            newUpdateHash = String.valueOf(versionName.hashCode());
+            OTAUtils.setJSONValueForKey(updatePackage, OTAConstants.PACKAGE_HASH_KEY, newUpdateHash);
+        }
+
+        String newUpdateFolderPath = getPackageFolderPath(newUpdateHash);
+        String newUpdateMetadataPath = OTAUtils.appendPathComponent(newUpdateFolderPath, OTAConstants.PACKAGE_FILE_NAME);
+        
+        if (FileUtils.fileAtPathExists(newUpdateFolderPath)) {
+            FileUtils.deleteDirectoryAtPath(newUpdateFolderPath);
+        }
+
+        String downloadUrlString = updatePackage.optString(OTAConstants.DOWNLOAD_URL_KEY, null);
+        if (downloadUrlString == null) {
+            throw new OTAInvalidUpdateException("Download URL is missing from update package");
+        }
+
+        HttpURLConnection connection = null;
+        BufferedInputStream bin = null;
+        FileOutputStream fos = null;
+        BufferedOutputStream bout = null;
+        File downloadFile = null;
+        boolean isZip = false;
+
+        try {
+            URL downloadUrl = new URL(downloadUrlString);
+            connection = (HttpURLConnection) (downloadUrl.openConnection());
+
+            if (android.os.Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP &&
+                downloadUrl.toString().startsWith("https")) {
+                try {
+                    ((HttpsURLConnection)connection).setSSLSocketFactory(new TLSSocketFactory());
+                } catch (Exception e) {
+                    throw new OTAUnknownException("Error set SSLSocketFactory. ", e);
+                }
+            }
+
+            connection.setRequestProperty("Accept-Encoding", "identity");
+            bin = new BufferedInputStream(connection.getInputStream());
+
+            long totalBytes = connection.getContentLength();
+            long receivedBytes = 0;
+
+            File downloadFolder = new File(getOTAPath());
+            downloadFolder.mkdirs();
+            downloadFile = new File(downloadFolder, OTAConstants.DOWNLOAD_FILE_NAME);
+            fos = new FileOutputStream(downloadFile);
+            bout = new BufferedOutputStream(fos, OTAConstants.DOWNLOAD_BUFFER_SIZE);
+            byte[] data = new byte[OTAConstants.DOWNLOAD_BUFFER_SIZE];
+            byte[] header = new byte[4];
+
+            int numBytesRead = 0;
+            while ((numBytesRead = bin.read(data, 0, OTAConstants.DOWNLOAD_BUFFER_SIZE)) >= 0) {
+                if (receivedBytes < 4) {
+                    for (int i = 0; i < numBytesRead; i++) {
+                        int headerOffset = (int) (receivedBytes) + i;
+                        if (headerOffset >= 4) {
+                            break;
+                        }
+                        header[headerOffset] = data[i];
+                    }
+                }
+
+                receivedBytes += numBytesRead;
+                bout.write(data, 0, numBytesRead);
+                if (progressCallback != null) {
+                    progressCallback.call(new DownloadProgress(totalBytes, receivedBytes));
+                }
+            }
+
+            if (totalBytes > 0 && totalBytes != receivedBytes) {
+                throw new OTAUnknownException("Received " + receivedBytes + " bytes, expected " + totalBytes);
+            }
+
+            isZip = ByteBuffer.wrap(header).getInt() == 0x504b0304;
+        } catch (MalformedURLException e) {
+            throw new OTAMalformedDataException(downloadUrlString, e);
+        } finally {
+            try {
+                if (bout != null) bout.close();
+                if (fos != null) fos.close();
+                if (bin != null) bin.close();
+                if (connection != null) connection.disconnect();
+            } catch (IOException e) {
+                throw new OTAUnknownException("Error closing IO resources.", e);
+            }
+        }
+
+        if (isZip) {
+            String unzippedFolderPath = getUnzippedFolderPath();
+            FileUtils.unzipFile(downloadFile, unzippedFolderPath);
+            FileUtils.deleteFileOrFolderSilently(downloadFile);
+
+            FileUtils.copyDirectoryContents(unzippedFolderPath, newUpdateFolderPath);
+            FileUtils.deleteFileAtPathSilently(unzippedFolderPath);
+
+            // Find bundle file in the extracted contents
+            String relativeBundlePath = findJSBundleInUpdateContents(newUpdateFolderPath, expectedBundleFileName);
+
+            if (relativeBundlePath == null) {
+                throw new OTAInvalidUpdateException("Update is invalid - A JS bundle file named \"" + expectedBundleFileName + "\" could not be found within the downloaded contents.");
+            } else {
+                OTAUtils.setJSONValueForKey(updatePackage, OTAConstants.RELATIVE_BUNDLE_PATH_KEY, relativeBundlePath);
+            }
+        } else {
+            FileUtils.moveFile(downloadFile, newUpdateFolderPath, expectedBundleFileName);
+        }
+
+        OTAUtils.writeJsonToFile(updatePackage, newUpdateMetadataPath);
+    }
+
+    private String findJSBundleInUpdateContents(String updateFolderPath, String expectedBundleFileName) {
+        File updateFolder = new File(updateFolderPath);
+        if (!updateFolder.exists() || !updateFolder.isDirectory()) {
+            return null;
+        }
+
+        File[] files = updateFolder.listFiles();
+        if (files == null) {
+            return null;
+        }
+
+        // First, check root level
+        for (File file : files) {
+            if (file.isFile() && file.getName().equals(expectedBundleFileName)) {
+                return file.getName();
+            }
+        }
+
+        // Then check subdirectories recursively
+        for (File file : files) {
+            if (file.isDirectory()) {
+                String found = findJSBundleInUpdateContents(file.getAbsolutePath(), expectedBundleFileName);
+                if (found != null) {
+                    return file.getName() + "/" + found;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public String getCurrentBundlePath() {
+        return getCurrentPackageBundlePath(mBundleFileName);
+    }
+
+    public void installPackage(JSONObject updatePackage, boolean removePendingUpdate) {
+        String packageHash = updatePackage.optString(OTAConstants.PACKAGE_HASH_KEY, null);
+        JSONObject info = getCurrentPackageInfo();
+
+        String currentPackageHash = info.optString(OTAConstants.CURRENT_PACKAGE_KEY, null);
+        if (packageHash != null && packageHash.equals(currentPackageHash)) {
+            return;
+        }
+
+        if (removePendingUpdate) {
+            String currentPackageFolderPath = getCurrentPackageFolderPath();
+            if (currentPackageFolderPath != null) {
+                FileUtils.deleteDirectoryAtPath(currentPackageFolderPath);
+            }
+        } else {
+            String previousPackageHash = getPreviousPackageHash();
+            if (previousPackageHash != null && !previousPackageHash.equals(packageHash)) {
+                FileUtils.deleteDirectoryAtPath(getPackageFolderPath(previousPackageHash));
+            }
+
+            OTAUtils.setJSONValueForKey(info, OTAConstants.PREVIOUS_PACKAGE_KEY, info.optString(OTAConstants.CURRENT_PACKAGE_KEY, null));
+        }
+
+        OTAUtils.setJSONValueForKey(info, OTAConstants.CURRENT_PACKAGE_KEY, packageHash);
+        updateCurrentPackageInfo(info);
+    }
+
+    public void clearUpdates() {
+        FileUtils.deleteDirectoryAtPath(getOTAPath());
+    }
+}
+

package/android/src/main/java/com/otaupdater/react/DownloadProgress.java

@@ -0,0 +1,26 @@
+package com.otaupdater.react;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+public class DownloadProgress {
+    private long mTotalBytes;
+    private long mReceivedBytes;
+
+    public DownloadProgress(long totalBytes, long receivedBytes) {
+        mTotalBytes = totalBytes;
+        mReceivedBytes = receivedBytes;
+    }
+
+    public boolean isCompleted() {
+        return mTotalBytes == mReceivedBytes;
+    }
+
+    public WritableMap createWritableMap() {
+        WritableMap map = Arguments.createMap();
+        map.putDouble("totalBytes", mTotalBytes);
+        map.putDouble("receivedBytes", mReceivedBytes);
+        return map;
+    }
+}
+

package/android/src/main/java/com/otaupdater/react/DownloadProgressCallback.java

@@ -0,0 +1,6 @@
+package com.otaupdater.react;
+
+public interface DownloadProgressCallback {
+    void call(DownloadProgress downloadProgress);
+}
+

package/android/src/main/java/com/otaupdater/react/FileUtils.java

@@ -0,0 +1,206 @@
+package com.otaupdater.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(
+                        OTAUtils.appendPathComponent(sourceDirectoryPath, sourceFile.getName()),
+                        OTAUtils.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 OTAUnknownException("Error closing IO resources.", e);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void deleteDirectoryAtPath(String directoryPath) {
+        if (directoryPath == null) {
+            OTAUtils.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();
+            if (files != null) {
+                for (File fileEntry : files) {
+                    if (fileEntry.isDirectory()) {
+                        deleteFileOrFolderSilently(fileEntry);
+                    } else {
+                        fileEntry.delete();
+                    }
+                }
+            }
+        }
+
+        if (!file.delete()) {
+            OTAUtils.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 OTAUnknownException("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 OTAUnknownException("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/otaupdater/react/OTAConstants.java

@@ -0,0 +1,28 @@
+package com.otaupdater.react;
+
+public class OTAConstants {
+    public static final String ASSETS_BUNDLE_PREFIX = "assets://";
+    public static final String CODE_PUSH_FOLDER_PREFIX = "OTAUpdates";
+    public static final String CODE_PUSH_PREFERENCES = "OTAUpdater";
+    public static final String CURRENT_PACKAGE_KEY = "currentPackage";
+    public static final String DEFAULT_JS_BUNDLE_NAME = "index.android.bundle";
+    public static final int DOWNLOAD_BUFFER_SIZE = 1024 * 256;
+    public static final String DOWNLOAD_FILE_NAME = "download.zip";
+    public static final String DOWNLOAD_PROGRESS_EVENT_NAME = "OTADownloadProgress";
+    public static final String DOWNLOAD_URL_KEY = "downloadUrl";
+    public static final String FAILED_UPDATES_KEY = "OTA_FAILED_UPDATES";
+    public static final String PACKAGE_FILE_NAME = "app.json";
+    public static final String PACKAGE_HASH_KEY = "packageHash";
+    public static final String PENDING_UPDATE_HASH_KEY = "hash";
+    public static final String PENDING_UPDATE_IS_LOADING_KEY = "isLoading";
+    public static final String PENDING_UPDATE_KEY = "OTA_PENDING_UPDATE";
+    public static final String PREVIOUS_PACKAGE_KEY = "previousPackage";
+    public static final String REACT_NATIVE_LOG_TAG = "ReactNative";
+    public static final String RELATIVE_BUNDLE_PATH_KEY = "bundlePath";
+    public static final String STATUS_FILE = "ota.json";
+    public static final String UNZIPPED_FOLDER_NAME = "unzipped";
+    public static final String VERSION_NAME_KEY = "versionName";
+    public static final String VERSION_CODE_KEY = "versionCode";
+    public static final String CLIENT_UNIQUE_ID_KEY = "clientUniqueId";
+}
+

package/android/src/main/java/com/otaupdater/react/OTAInvalidUpdateException.java

@@ -0,0 +1,12 @@
+package com.otaupdater.react;
+
+public class OTAInvalidUpdateException extends RuntimeException {
+    public OTAInvalidUpdateException(String message) {
+        super(message);
+    }
+
+    public OTAInvalidUpdateException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
+

package/android/src/main/java/com/otaupdater/react/OTAMalformedDataException.java

@@ -0,0 +1,12 @@
+package com.otaupdater.react;
+
+public class OTAMalformedDataException extends RuntimeException {
+    public OTAMalformedDataException(String message) {
+        super(message);
+    }
+
+    public OTAMalformedDataException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
+