")).toBeTrue(); + expect(Planning.isDescriptionEmpty("
")).toBeTrue();
+ expect(Planning.isDescriptionEmpty(null)).toBeTrue();
+ expect(Planning.isDescriptionEmpty(undefined)).toBeTrue();
+ expect(Planning.isDescriptionEmpty("coucou")).toBeFalse();
+ expect(Planning.isDescriptionEmpty("
coucou
")).toBeFalse(); +}); + +test('isEventDateStringFormatValid', () => { + expect(Planning.isEventDateStringFormatValid("2020-03-21 09:00")).toBeTrue(); + expect(Planning.isEventDateStringFormatValid("3214-64-12 01:16")).toBeTrue(); + + expect(Planning.isEventDateStringFormatValid("3214-64-12 01:16:00")).toBeFalse(); + expect(Planning.isEventDateStringFormatValid("3214-64-12 1:16")).toBeFalse(); + expect(Planning.isEventDateStringFormatValid("3214-f4-12 01:16")).toBeFalse(); + expect(Planning.isEventDateStringFormatValid("sqdd 09:00")).toBeFalse(); + expect(Planning.isEventDateStringFormatValid("2020-03-21")).toBeFalse(); + expect(Planning.isEventDateStringFormatValid("2020-03-21 truc")).toBeFalse(); + expect(Planning.isEventDateStringFormatValid("3214-64-12 1:16:65")).toBeFalse(); + expect(Planning.isEventDateStringFormatValid("garbage")).toBeFalse(); + expect(Planning.isEventDateStringFormatValid("")).toBeFalse(); + expect(Planning.isEventDateStringFormatValid(undefined)).toBeFalse(); + expect(Planning.isEventDateStringFormatValid(null)).toBeFalse(); +}); + +test('stringToDate', () => { + let testDate = new Date(); + expect(Planning.stringToDate(undefined)).toBeNull(); + expect(Planning.stringToDate("")).toBeNull(); + expect(Planning.stringToDate("garbage")).toBeNull(); + expect(Planning.stringToDate("2020-03-21")).toBeNull(); + expect(Planning.stringToDate("09:00:00")).toBeNull(); + expect(Planning.stringToDate("2020-03-21 09:g0")).toBeNull(); + expect(Planning.stringToDate("2020-03-21 09:g0:")).toBeNull(); + testDate.setFullYear(2020, 2, 21); + testDate.setHours(9, 0, 0, 0); + expect(Planning.stringToDate("2020-03-21 09:00")).toEqual(testDate); + testDate.setFullYear(2020, 0, 31); + testDate.setHours(18, 30, 0, 0); + expect(Planning.stringToDate("2020-01-31 18:30")).toEqual(testDate); + testDate.setFullYear(2020, 50, 50); + testDate.setHours(65, 65, 0, 0); + expect(Planning.stringToDate("2020-51-50 65:65")).toEqual(testDate); +}); + +test('getFormattedEventTime', () => { + expect(Planning.getFormattedEventTime(null, null)) + .toBe('/ - /'); + expect(Planning.getFormattedEventTime(undefined, undefined)) + .toBe('/ - /'); + expect(Planning.getFormattedEventTime("20:30", "23:00")) + .toBe('/ - /'); + expect(Planning.getFormattedEventTime("2020-03-30", "2020-03-31")) + .toBe('/ - /'); + + + expect(Planning.getFormattedEventTime("2020-03-21 09:00", "2020-03-21 09:00")) + .toBe('09:00'); + expect(Planning.getFormattedEventTime("2020-03-21 09:00", "2020-03-22 17:00")) + .toBe('09:00 - 23:59'); + expect(Planning.getFormattedEventTime("2020-03-30 20:30", "2020-03-30 23:00")) + .toBe('20:30 - 23:00'); +}); + +test('getDateOnlyString', () => { + expect(Planning.getDateOnlyString("2020-03-21 09:00")).toBe("2020-03-21"); + expect(Planning.getDateOnlyString("2021-12-15 09:00")).toBe("2021-12-15"); + expect(Planning.getDateOnlyString("2021-12-o5 09:00")).toBeNull(); + expect(Planning.getDateOnlyString("2021-12-15 09:")).toBeNull(); + expect(Planning.getDateOnlyString("2021-12-15")).toBeNull(); + expect(Planning.getDateOnlyString("garbage")).toBeNull(); +}); + +test('isEventBefore', () => { + expect(Planning.isEventBefore( + "2020-03-21 09:00", "2020-03-21 10:00")).toBeTrue(); + expect(Planning.isEventBefore( + "2020-03-21 10:00", "2020-03-21 10:15")).toBeTrue(); + expect(Planning.isEventBefore( + "2020-03-21 10:15", "2021-03-21 10:15")).toBeTrue(); + expect(Planning.isEventBefore( + "2020-03-21 10:15", "2020-05-21 10:15")).toBeTrue(); + expect(Planning.isEventBefore( + "2020-03-21 10:15", "2020-03-30 10:15")).toBeTrue(); + + expect(Planning.isEventBefore( + "2020-03-21 10:00", "2020-03-21 10:00")).toBeFalse(); + expect(Planning.isEventBefore( + "2020-03-21 10:00", "2020-03-21 09:00")).toBeFalse(); + expect(Planning.isEventBefore( + "2020-03-21 10:15", "2020-03-21 10:00")).toBeFalse(); + expect(Planning.isEventBefore( + "2021-03-21 10:15", "2020-03-21 10:15")).toBeFalse(); + expect(Planning.isEventBefore( + "2020-05-21 10:15", "2020-03-21 10:15")).toBeFalse(); + expect(Planning.isEventBefore( + "2020-03-30 10:15", "2020-03-21 10:15")).toBeFalse(); + + expect(Planning.isEventBefore( + "garbage", "2020-03-21 10:15")).toBeFalse(); + expect(Planning.isEventBefore( + undefined, undefined)).toBeFalse(); +}); + +test('dateToString', () => { + let testDate = new Date(); + testDate.setFullYear(2020, 2, 21); + testDate.setHours(9, 0, 0, 0); + expect(Planning.dateToString(testDate)).toBe("2020-03-21 09:00"); + testDate.setFullYear(2021, 0, 12); + testDate.setHours(9, 10, 0, 0); + expect(Planning.dateToString(testDate)).toBe("2021-01-12 09:10"); + testDate.setFullYear(2022, 11, 31); + testDate.setHours(9, 10, 15, 0); + expect(Planning.dateToString(testDate)).toBe("2022-12-31 09:10"); +}); + +test('generateEmptyCalendar', () => { + jest.spyOn(Date, 'now') + .mockImplementation(() => + new Date('2020-01-14T00:00:00.000Z').getTime() + ); + let calendar = Planning.generateEmptyCalendar(1); + expect(calendar).toHaveProperty("2020-01-14"); + expect(calendar).toHaveProperty("2020-01-20"); + expect(calendar).toHaveProperty("2020-02-10"); + expect(Object.keys(calendar).length).toBe(32); + calendar = Planning.generateEmptyCalendar(3); + expect(calendar).toHaveProperty("2020-01-14"); + expect(calendar).toHaveProperty("2020-01-20"); + expect(calendar).toHaveProperty("2020-02-10"); + expect(calendar).toHaveProperty("2020-02-14"); + expect(calendar).toHaveProperty("2020-03-20"); + expect(calendar).toHaveProperty("2020-04-12"); + expect(Object.keys(calendar).length).toBe(92); +}); + +test('pushEventInOrder', () => { + let eventArray = []; + let event1 = {date_begin: "2020-01-14 09:15"}; + Planning.pushEventInOrder(eventArray, event1); + expect(eventArray.length).toBe(1); + expect(eventArray[0]).toBe(event1); + + let event2 = {date_begin: "2020-01-14 10:15"}; + Planning.pushEventInOrder(eventArray, event2); + expect(eventArray.length).toBe(2); + expect(eventArray[0]).toBe(event1); + expect(eventArray[1]).toBe(event2); + + let event3 = {date_begin: "2020-01-14 10:15", title: "garbage"}; + Planning.pushEventInOrder(eventArray, event3); + expect(eventArray.length).toBe(3); + expect(eventArray[0]).toBe(event1); + expect(eventArray[1]).toBe(event2); + expect(eventArray[2]).toBe(event3); + + let event4 = {date_begin: "2020-01-13 09:00"}; + Planning.pushEventInOrder(eventArray, event4); + expect(eventArray.length).toBe(4); + expect(eventArray[0]).toBe(event4); + expect(eventArray[1]).toBe(event1); + expect(eventArray[2]).toBe(event2); + expect(eventArray[3]).toBe(event3); +}); + +test('generateEventAgenda', () => { + jest.spyOn(Date, 'now') + .mockImplementation(() => + new Date('2020-01-14T00:00:00.000Z').getTime() + ); + let eventList = [ + {date_begin: "2020-01-14 09:15"}, + {date_begin: "2020-02-01 09:15"}, + {date_begin: "2020-01-15 09:15"}, + {date_begin: "2020-02-01 09:30"}, + {date_begin: "2020-02-01 08:30"}, + ]; + const calendar = Planning.generateEventAgenda(eventList, 2); + expect(calendar["2020-01-14"].length).toBe(1); + expect(calendar["2020-01-14"][0]).toBe(eventList[0]); + expect(calendar["2020-01-15"].length).toBe(1); + expect(calendar["2020-01-15"][0]).toBe(eventList[2]); + expect(calendar["2020-02-01"].length).toBe(3); + expect(calendar["2020-02-01"][0]).toBe(eventList[4]); + expect(calendar["2020-02-01"][1]).toBe(eventList[1]); + expect(calendar["2020-02-01"][2]).toBe(eventList[3]); +}); + +test('getCurrentDateString', () => { + jest.spyOn(Date, 'now') + .mockImplementation(() => { + let date = new Date(); + date.setFullYear(2020, 0, 14); + date.setHours(15, 30, 54, 65); + return date.getTime(); + }); + expect(Planning.getCurrentDateString()).toBe('2020-01-14 15:30'); +}); diff --git a/__tests__/utils/Proxiwash.test.js b/__tests__/utils/Proxiwash.test.js new file mode 100644 index 0000000..4aca8e7 --- /dev/null +++ b/__tests__/utils/Proxiwash.test.js @@ -0,0 +1,142 @@ +import React from 'react'; +import {getCleanedMachineWatched, getMachineEndDate, getMachineOfId, isMachineWatched} from "../../src/utils/Proxiwash"; + +test('getMachineEndDate', () => { + jest.spyOn(Date, 'now') + .mockImplementation(() => + new Date('2020-01-14T15:00:00.000Z').getTime() + ); + let expectDate = new Date('2020-01-14T15:00:00.000Z'); + expectDate.setHours(23); + expectDate.setMinutes(10); + expect(getMachineEndDate({endTime: "23:10"}).getTime()).toBe(expectDate.getTime()); + + expectDate.setHours(16); + expectDate.setMinutes(30); + expect(getMachineEndDate({endTime: "16:30"}).getTime()).toBe(expectDate.getTime()); + + expect(getMachineEndDate({endTime: "15:30"})).toBeNull(); + + expect(getMachineEndDate({endTime: "13:10"})).toBeNull(); + + jest.spyOn(Date, 'now') + .mockImplementation(() => + new Date('2020-01-14T23:00:00.000Z').getTime() + ); + expectDate = new Date('2020-01-14T23:00:00.000Z'); + expectDate.setHours(0); + expectDate.setMinutes(30); + expect(getMachineEndDate({endTime: "00:30"}).getTime()).toBe(expectDate.getTime()); +}); + +test('isMachineWatched', () => { + let machineList = [ + { + number: "0", + endTime: "23:30", + }, + { + number: "1", + endTime: "20:30", + }, + ]; + expect(isMachineWatched({number: "0", endTime: "23:30"}, machineList)).toBeTrue(); + expect(isMachineWatched({number: "1", endTime: "20:30"}, machineList)).toBeTrue(); + expect(isMachineWatched({number: "3", endTime: "20:30"}, machineList)).toBeFalse(); + expect(isMachineWatched({number: "1", endTime: "23:30"}, machineList)).toBeFalse(); +}); + +test('getMachineOfId', () => { + let machineList = [ + { + number: "0", + }, + { + number: "1", + }, + ]; + expect(getMachineOfId("0", machineList)).toStrictEqual({number: "0"}); + expect(getMachineOfId("1", machineList)).toStrictEqual({number: "1"}); + expect(getMachineOfId("3", machineList)).toBeNull(); +}); + +test('getCleanedMachineWatched', () => { + let machineList = [ + { + number: "0", + endTime: "23:30", + }, + { + number: "1", + endTime: "20:30", + }, + { + number: "2", + endTime: "", + }, + ]; + let watchList = [ + { + number: "0", + endTime: "23:30", + }, + { + number: "1", + endTime: "20:30", + }, + { + number: "2", + endTime: "", + }, + ]; + let cleanedList = watchList; + expect(getCleanedMachineWatched(watchList, machineList)).toStrictEqual(cleanedList); + + watchList = [ + { + number: "0", + endTime: "23:30", + }, + { + number: "1", + endTime: "20:30", + }, + { + number: "2", + endTime: "15:30", + }, + ]; + cleanedList = [ + { + number: "0", + endTime: "23:30", + }, + { + number: "1", + endTime: "20:30", + }, + ]; + expect(getCleanedMachineWatched(watchList, machineList)).toStrictEqual(cleanedList); + + watchList = [ + { + number: "0", + endTime: "23:30", + }, + { + number: "1", + endTime: "20:31", + }, + { + number: "3", + endTime: "15:30", + }, + ]; + cleanedList = [ + { + number: "0", + endTime: "23:30", + }, + ]; + expect(getCleanedMachineWatched(watchList, machineList)).toStrictEqual(cleanedList); +}); \ No newline at end of file diff --git a/__tests__/utils/WebData.js b/__tests__/utils/WebData.js new file mode 100644 index 0000000..9f8fb5b --- /dev/null +++ b/__tests__/utils/WebData.js @@ -0,0 +1,45 @@ +import React from 'react'; +import {isResponseValid} from "../../src/utils/WebData"; + +let fetch = require('isomorphic-fetch'); // fetch is not implemented in nodeJS but in react-native + +test('isRequestResponseValid', () => { + let json = { + error: 0, + data: {} + }; + expect(isResponseValid(json)).toBeTrue(); + json = { + error: 1, + data: {} + }; + expect(isResponseValid(json)).toBeTrue(); + json = { + error: 50, + data: {} + }; + expect(isResponseValid(json)).toBeTrue(); + json = { + error: 50, + data: {truc: 'machin'} + }; + expect(isResponseValid(json)).toBeTrue(); + json = { + message: 'coucou' + }; + expect(isResponseValid(json)).toBeFalse(); + json = { + error: 'coucou', + data: {truc: 'machin'} + }; + expect(isResponseValid(json)).toBeFalse(); + json = { + error: 0, + data: 'coucou' + }; + expect(isResponseValid(json)).toBeFalse(); + json = { + error: 0, + }; + expect(isResponseValid(json)).toBeFalse(); +}); diff --git a/android/app/BUCK b/android/app/BUCK new file mode 100644 index 0000000..d959762 --- /dev/null +++ b/android/app/BUCK @@ -0,0 +1,55 @@ +# To learn about Buck see [Docs](https://buckbuild.com/). +# To run your application with Buck: +# - install Buck +# - `npm start` - to start the packager +# - `cd android` +# - `keytool -genkey -v -keystore keystores/debug.keystore -storepass android -alias androiddebugkey -keypass android -dname "CN=Android Debug,O=Android,C=US"` +# - `./gradlew :app:copyDownloadableDepsToLibs` - make all Gradle compile dependencies available to Buck +# - `buck install -r android/app` - compile, install and run application +# + +load(":build_defs.bzl", "create_aar_targets", "create_jar_targets") + +lib_deps = [] + +create_aar_targets(glob(["libs/*.aar"])) + +create_jar_targets(glob(["libs/*.jar"])) + +android_library( + name = "all-libs", + exported_deps = lib_deps, +) + +android_library( + name = "app-code", + srcs = glob([ + "src/main/java/**/*.java", + ]), + deps = [ + ":all-libs", + ":build_config", + ":res", + ], +) + +android_build_config( + name = "build_config", + package = "fr.amicaleinsat.application", +) + +android_resource( + name = "res", + package = "fr.amicaleinsat.application", + res = "src/main/res", +) + +android_binary( + name = "app", + keystore = "//android/keystores:debug", + manifest = "src/main/AndroidManifest.xml", + package_type = "debug", + deps = [ + ":app-code", + ], +) diff --git a/android/app/build.gradle b/android/app/build.gradle new file mode 100644 index 0000000..b8fa57f --- /dev/null +++ b/android/app/build.gradle @@ -0,0 +1,215 @@ +apply plugin: "com.android.application" + +import com.android.build.OutputFile + +/** + * The react.gradle file registers a task for each build variant (e.g. bundleDebugJsAndAssets + * and bundleReleaseJsAndAssets). + * These basically call `react-native bundle` with the correct arguments during the Android build + * cycle. By default, bundleDebugJsAndAssets is skipped, as in debug/dev mode we prefer to load the + * bundle directly from the development server. Below you can see all the possible configurations + * and their defaults. If you decide to add a configuration block, make sure to add it before the + * `apply from: "../../node_modules/react-native/react.gradle"` line. + * + * project.ext.react = [ + * // the name of the generated asset file containing your JS bundle + * bundleAssetName: "index.android.bundle", + * + * // the entry file for bundle generation + * entryFile: "index.android.js", + * + * // https://facebook.github.io/react-native/docs/performance#enable-the-ram-format + * bundleCommand: "ram-bundle", + * + * // whether to bundle JS and assets in debug mode + * bundleInDebug: false, + * + * // whether to bundle JS and assets in release mode + * bundleInRelease: true, + * + * // whether to bundle JS and assets in another build variant (if configured). + * // See http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Build-Variants + * // The configuration property can be in the following formats + * // 'bundleIn${productFlavor}${buildType}' + * // 'bundleIn${buildType}' + * // bundleInFreeDebug: true, + * // bundleInPaidRelease: true, + * // bundleInBeta: true, + * + * // whether to disable dev mode in custom build variants (by default only disabled in release) + * // for example: to disable dev mode in the staging build type (if configured) + * devDisabledInStaging: true, + * // The configuration property can be in the following formats + * // 'devDisabledIn${productFlavor}${buildType}' + * // 'devDisabledIn${buildType}' + * + * // the root of your project, i.e. where "package.json" lives + * root: "../../", + * + * // where to put the JS bundle asset in debug mode + * jsBundleDirDebug: "$buildDir/intermediates/assets/debug", + * + * // where to put the JS bundle asset in release mode + * jsBundleDirRelease: "$buildDir/intermediates/assets/release", + * + * // where to put drawable resources / React Native assets, e.g. the ones you use via + * // require('./image.png')), in debug mode + * resourcesDirDebug: "$buildDir/intermediates/res/merged/debug", + * + * // where to put drawable resources / React Native assets, e.g. the ones you use via + * // require('./image.png')), in release mode + * resourcesDirRelease: "$buildDir/intermediates/res/merged/release", + * + * // by default the gradle tasks are skipped if none of the JS files or assets change; this means + * // that we don't look at files in android/ or ios/ to determine whether the tasks are up to + * // date; if you have any other folders that you want to ignore for performance reasons (gradle + * // indexes the entire tree), add them here. Alternatively, if you have JS files in android/ + * // for example, you might want to remove it from here. + * inputExcludes: ["android/**", "ios/**"], + * + * // override which node gets called and with what additional arguments + * nodeExecutableAndArgs: ["node"], + * + * // supply additional arguments to the packager + * extraPackagerArgs: [] + * ] + */ + +project.ext.react = [ + entryFile: "index.js", + enableHermes: false, +] + +apply from: "../../node_modules/react-native/react.gradle" + +project.ext.vectoricons = [ + iconFontNames: [ 'MaterialCommunityIcons.ttf'] // Name of the font files you want to copy +] +apply from: "../../node_modules/react-native-vector-icons/fonts.gradle" + +/** + * Set this to true to create two separate APKs instead of one: + * - An APK that only works on ARM devices + * - An APK that only works on x86 devices + * The advantage is the size of the APK is reduced by about 4MB. + * Upload all the APKs to the Play Store and people will download + * the correct one based on the CPU architecture of their device. + */ +def enableSeparateBuildPerCPUArchitecture = false + +/** + * Run Proguard to shrink the Java bytecode in release builds. + */ +def enableProguardInReleaseBuilds = false + +/** + * The preferred build flavor of JavaScriptCore. + * + * For example, to use the international variant, you can use: + * `def jscFlavor = 'org.webkit:android-jsc-intl:+'` + * + * The international variant includes ICU i18n library and necessary data + * allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that + * give correct results when using with locales other than en-US. Note that + * this variant is about 6MiB larger per architecture than default. + */ +def jscFlavor = 'org.webkit:android-jsc:+' + +/** + * Whether to enable the Hermes VM. + * + * This should be set on project.ext.react and mirrored here. If it is not set + * on project.ext.react, JavaScript will not be compiled to Hermes Bytecode + * and the benefits of using Hermes will therefore be sharply reduced. + */ +def enableHermes = project.ext.react.get("enableHermes", false); + +android { + compileSdkVersion rootProject.ext.compileSdkVersion + + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + defaultConfig { + applicationId 'fr.amicaleinsat.application' + minSdkVersion rootProject.ext.minSdkVersion + targetSdkVersion rootProject.ext.targetSdkVersion + versionCode 19 + versionName "3.0.2" + missingDimensionStrategy 'react-native-camera', 'general' + } + splits { + abi { + reset() + enable enableSeparateBuildPerCPUArchitecture + universalApk false // If true, also generate a universal APK + include "armeabi-v7a", "x86", "arm64-v8a", "x86_64" + } + } + signingConfigs { + debug { + storeFile file('debug.keystore') + storePassword 'android' + keyAlias 'androiddebugkey' + keyPassword 'android' + } + release { + if (project.hasProperty('MYAPP_UPLOAD_STORE_FILE')) { + storeFile file(MYAPP_UPLOAD_STORE_FILE) + storePassword MYAPP_UPLOAD_STORE_PASSWORD + keyAlias MYAPP_UPLOAD_KEY_ALIAS + keyPassword MYAPP_UPLOAD_KEY_PASSWORD + } + } + } + buildTypes { + debug { + signingConfig signingConfigs.debug + } + release { + // Caution! In production, you need to generate your own keystore file. + // see https://facebook.github.io/react-native/docs/signed-apk-android. + signingConfig signingConfigs.release + minifyEnabled enableProguardInReleaseBuilds + proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro" + } + } + // applicationVariants are e.g. debug, release + applicationVariants.all { variant -> + variant.outputs.each { output -> + // For each separate APK per architecture, set a unique version code as described here: + // https://developer.android.com/studio/build/configure-apk-splits.html + def versionCodes = ["armeabi-v7a": 1, "x86": 2, "arm64-v8a": 3, "x86_64": 4] + def abi = output.getFilter(OutputFile.ABI) + if (abi != null) { // null for the universal-debug, universal-release variants + output.versionCodeOverride = + versionCodes.get(abi) * 1048576 + defaultConfig.versionCode + } + + } + } +} + +dependencies { + implementation fileTree(dir: "libs", include: ["*.jar"]) + implementation "com.facebook.react:react-native:+" // From node_modules + + if (enableHermes) { + def hermesPath = "../../node_modules/hermes-engine/android/"; + debugImplementation files(hermesPath + "hermes-debug.aar") + releaseImplementation files(hermesPath + "hermes-release.aar") + } else { + implementation jscFlavor + } +} + +// Run this once to be able to run the application with BUCK +// puts all compile dependencies into folder libs for BUCK to use +task copyDownloadableDepsToLibs(type: Copy) { + from configurations.compile + into 'libs' +} + +apply from: file("../../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesAppBuildGradle(project) diff --git a/android/app/build_defs.bzl b/android/app/build_defs.bzl new file mode 100644 index 0000000..fff270f --- /dev/null +++ b/android/app/build_defs.bzl @@ -0,0 +1,19 @@ +"""Helper definitions to glob .aar and .jar targets""" + +def create_aar_targets(aarfiles): + for aarfile in aarfiles: + name = "aars__" + aarfile[aarfile.rindex("/") + 1:aarfile.rindex(".aar")] + lib_deps.append(":" + name) + android_prebuilt_aar( + name = name, + aar = aarfile, + ) + +def create_jar_targets(jarfiles): + for jarfile in jarfiles: + name = "jars__" + jarfile[jarfile.rindex("/") + 1:jarfile.rindex(".jar")] + lib_deps.append(":" + name) + prebuilt_jar( + name = name, + binary_jar = jarfile, + ) diff --git a/android/app/proguard-rules.pro b/android/app/proguard-rules.pro new file mode 100644 index 0000000..f8690bc --- /dev/null +++ b/android/app/proguard-rules.pro @@ -0,0 +1,13 @@ +# Add project specific ProGuard rules here. +# By default, the flags in this file are appended to flags specified +# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt +# You can edit the include path and order by changing the proguardFiles +# directive in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# Add any project specific keep options here: + +-keep class com.facebook.hermes.unicode.** { *; } +-keep class com.facebook.jni.** { *; } \ No newline at end of file diff --git a/android/app/src/debug/AndroidManifest.xml b/android/app/src/debug/AndroidManifest.xml new file mode 100644 index 0000000..99e38fc --- /dev/null +++ b/android/app/src/debug/AndroidManifest.xml @@ -0,0 +1,7 @@ +