Jak mogę wygenerować APK, który może działać bez serwera z React-Native?

Zbudowałem aplikację, mogę ją uruchomić na moim lokalnym emulatorze (a także na moim urządzeniu z Androidem w tej samej sieci, zmieniając serwer debugowania).

Chcę jednak zbudować pakiet APK, który mogę wysłać komuś bez dostępu do serwera programistycznego i chcę, aby mógł on testować aplikację.

Widzę, że jest sekcja Używanie pakietu offline w sekcji iOS dokumentacji. Ale nie mogłem wymyślić, jak to zrobić dla Androida. czy to możliwe? Jeśli tak to jak?

AKTUALIZACJA: W odpowiedzi na to pytanie ( Android nie załadował pakietu JS ) mówi się, że pakiet offline można pobrać z serwera programistycznego. Ale gdy otrzymam pakiet z serwera programowania, nie można załadować plików obrazów.

Po odpowiedzi Adityi Singh wygenerowany (niepodpisany) apk nie zainstaluje się na moim telefonie. Musiałem wygenerować podpisany apk, korzystając z instrukcji tutaj .

Dla mnie działało:

$ keytool -genkey -v -keystore my-release-key.keystore -alias my-key-alias -keyalg RSA -keysize 2048 -validity 10000

Umieść my-release-key.keystoreplik w android/app katalogu w folderze projektu. Następnie edytuj plik ~/.gradle/gradle.propertiesi dodaj następujące elementy (zastąp **** poprawnym hasłem do pliku kluczy, aliasem i hasłem klucza)

MYAPP_RELEASE_STORE_FILE=my-release-key.keystore
MYAPP_RELEASE_KEY_ALIAS=my-key-alias
MYAPP_RELEASE_STORE_PASSWORD=****
MYAPP_RELEASE_KEY_PASSWORD=****

Jeśli używasz systemu MacOS, możesz przechowywać hasło w pęku kluczy, postępując zgodnie z instrukcjami tutaj, zamiast przechowywać je w postaci zwykłego tekstu.

Następnie edytuj aplikację / build.gradle i upewnij się, że są tam następujące (może być konieczne dodanie sekcji z signingConfigs signingConfig):

...
android {
    ...
    defaultConfig { ... }
    signingConfigs {
        release {
            if (project.hasProperty('MYAPP_RELEASE_STORE_FILE')) {
                storeFile file(MYAPP_RELEASE_STORE_FILE)
                storePassword MYAPP_RELEASE_STORE_PASSWORD
                keyAlias MYAPP_RELEASE_KEY_ALIAS
                keyPassword MYAPP_RELEASE_KEY_PASSWORD
            }
        }
    }
    buildTypes {
        release {
            ...
            signingConfig signingConfigs.release
        }
    }
}
...

Następnie uruchom polecenie cd android && ./gradlew assembleRelease,

W systemie Windows „cd android”, a następnie uruchom gradlew assembleReleasepolecenie i znajdź podpisany apk podandroid/app/build/outputs/apk/app-release.apk

Musisz utworzyć klucz, aby podpisać apk. Użyj poniżej, aby utworzyć swój klucz:

 keytool -genkey -v -keystore my-app-key.keystore -alias my-app-alias -keyalg RSA -keysize 2048 -validity 10000

Po wyświetleniu monitu użyj hasła

Po wygenerowaniu klucza użyj go do wygenerowania instalowalnej kompilacji:

 react-native bundle --platform android --dev false --entry-file index.android.js --bundle-output android/app/src/main/assets/index.android.bundle --assets-dest android/app/src/main/res/

Wygeneruj kompilację za pomocą gradna

 cd android && ./gradlew assembleRelease

Prześlij pakiet APK na swój telefon. -rFlag zastąpi istniejącą aplikację (jeśli istnieje)

adb install -r ./app/build/outputs/apk/app-release-unsigned.apk

Bardziej szczegółowy opis znajduje się tutaj: https://facebook.github.io/react-native/docs/signed-apk-android.html

AKTUALIZACJA : Na podstawie komentarzy @shashuec i @Fallen

jeśli pojawi się błąd

ENOENT: nie ma takiego pliku ani katalogu, otwórz „android / app / src / main / resources / index.android.bundle”

uruchom mkdir android / app / src / main / asset

W tym procesie powinieneś po prostu użyć Androida Studio. To jest po prostu prostsze. Ale najpierw uruchom to polecenie w swoim katalogu aplikacji natywnej:

Dla nowszej wersji React-Native (np. React Native 0.49.0 i tak dalej ...)

react-native bundle --platform android --dev false --entry-file index.js --bundle-output android/app/src/main/assets/index.android.bundle --assets-dest android/app/src/main/res

Dla starszej wersji React-Native (0.49.0 i poniżej)

react-native bundle --platform android --dev false --entry-file index.android.js   --bundle-output android/app/src/main/assets/index.android.bundle   --assets-dest android/app/src/main/res/

Następnie użyj Android studio, aby otworzyć folder „android”, w którym zareagujesz na natywny katalog aplikacji, poprosi o aktualizację gradle i kilka innych rzeczy. przejdź do build-> Wygeneruj podpisany APK i postępuj zgodnie z instrukcjami. To naprawdę proste.

Uruchom to polecenie:

react-native run-android --variant=release

Pamiętaj, że --variant=releasejest dostępna tylko wtedy, gdy masz skonfigurowane podpisywanie przy użyciu cd android && ./gradlew assembleRelease.

dla React Native 0.49 i nowszych

powinieneś przejść do katalogu projektu na terminalu i uruchomić tę komendę

1 - mkdir android/app/src/main/assets
2 - react-native bundle --platform android --dev false --entry-file index.js --bundle-output android/app/src/main/assets/index.android.bundle --assets-dest android/app/src/main/res

jeśli poniżej 0,49

  1 - mkdir android/app/src/main/assets
  2 - react-native bundle --platform android --dev false --entry-file index.android.js --bundle-output android/app/src/main/assets/index.android.bundle --assets-dest android/app/src/main/res

Następnie użyj Android studio, aby otworzyć folder „android”, w którym zareagujesz na natywny katalog aplikacji, poprosi o aktualizację gradle i kilka innych rzeczy. przejdź do build-> Wygeneruj podpisany APK i postępuj zgodnie z instrukcjami. To dobrze.

Jeśli masz Failure [INSTALL_PARSE_FAILED_NO_CERTIFICATES].

Próbowałem użyć metody @ Aditya do wygenerowania niepodpisanego pliku APK i zainstalowania go, ale kiedy poszedłem go zainstalować na moim tablecie z Androidem, wystąpił błąd Failure [INSTALL_PARSE_FAILED_NO_CERTIFICATES] .

Wyobrażam sobie, że dzieje się tak, ponieważ plik APK nie został podpisany, a tablet nie był z tego zadowolony. Po wygenerowaniu pliku pakietu React Native byłem w stanie wygenerować podpisany plik APK, jak zwykle, za pośrednictwem Android Studio.

Nawiasem mówiąc, nasza aplikacja jest w pełni działającą aplikacją na Androida, która już istnieje w Sklepie Play, a my dodajemy do niej React Native w kawałkach wielkości kęsa, ponieważ jest niesamowity.

Podsumowując, oto moje kroki:

1) Generuj pakiet React Native:

react-native bundle --platform android --dev false --entry-file index.android.js --bundle-output android/<your-package-name>/src/main/assets/index.android.bu‌​ndle --assets-dest android/<your-package-name>/src/main/res/ 

2) Wygeneruj podpisany plik APK z Android Studio.

3) Zainstaluj podpisany plik APK na urządzeniu USB:

adb -d install -r <path_to_signed_apk> 

-dFlaga tylko mówi adbdo zainstalowania na urządzeniu USB załączonym, w przypadku gdy masz emulator działa tak dobrze. Jeśli chcesz zainstalować na dowolnym emulatorze, upuść -dflagę.

4) Zysk!

Spróbuj poniżej, wygeneruje app-debug.apk w folderze root / android / app / build / Output / apk / debug

react-native bundle --platform android --dev false --entry-file index.js --bundle-output android/app/src/main/assets/index.android.bundle --assets-dest android/app/src/main/res

następnie przejdź do folderu Androida i uruchom

./gradlew assembleDebug

Jeśli ktoś chce budować bez kluczy playstore, to polecenie byłoby bardzo pomocne.

# react-native run-android --variant=release

Po zakończeniu kompilacji możesz znaleźć apk w pliku kompilacji wydania.

Przejdź do katalogu projektu i uruchom polecenie:

cd android && ./gradlew assembleRelease

Jeśli pojawi się błąd związany z plikiem index.android.js. Wynika to z faktu, że używasz nowej wersji natywnej React (używam wersji 0.55.4). Po prostu zamień „index.android.js” na „index.js”

react-native bundle --platform android --dev false --entry-file index.js   --bundle-output android/app/src/main/assets/index.android.bundle   --assets-dest android/app/src/main/res/

Mam inne rozwiązanie: - Generowanie klucza podpisu Możesz wygenerować prywatny klucz podpisu za pomocą keytool. W systemie Windows keytool należy uruchomić z C: \ Program Files \ Java \ jdkx.x.x_x \ bin.

$ keytool -genkey -v -keystore my-release-key.keystore -alias my-key-alias -keyalg RSA -keysize 2048 -validity 10000

Umieść plik my-release-key.keystore w katalogu android / app w folderze projektu.

Edytuj plik android / app / build.gradle w folderze projektu i dodaj konfigurację podpisywania,

android {
....
signingConfigs { 
  release { 

      storeFile file('my-release-key.keystore') 
      storePassword 'yourpassword' 
      keyAlias 'my-key-alias' 
      keyPassword 'yourpassword' 

  } 
}}}


buildTypes {release {signingConfig signingConfigs.release}}

i biegnij

gradlew assembleRelease

To da ci dwa pliki na Android \ app \ build \ wyjścia \ apk app-release.apk i app-release-unsigned.apk teraz zainstaluj app-release.apk na urządzeniu z Androidem.

Mam nadzieję, że pomoże nowym początkującym

Oficjalny dokument tutaj

Jeśli nie masz magazynu kluczy niż użyj przed komendą, pomiń

Generowanie klucza podpisu / pliku kluczy Można wygenerować prywatny klucz podpisu za pomocą keytool. W systemie Windows keytool należy uruchomić z C: \ Program Files \ Java \ jdkx.x.x_x \ bin.

$ keytool -genkey -v -keystore my-release-key.keystore -alias my-key-alias -keyalg RSA -keysize 2048 -validity 10000

otrzymasz plik taki jak my-release-key.keystore

Konfigurowanie zmiennych stopni Umieść plik my-release-key.keystore w katalogu android / app w folderze projektu. Zmodyfikuj plik android / gradle.properties i dodaj następujące elementy (zamień ***** na prawidłowe hasło magazynu kluczy, alias i hasło klucza), obejdź ustawienie enableAapt2 ustawione na fałsz, ponieważ problem dotyczy wersji 3.0 Androida

MYAPP_RELEASE_STORE_FILE=my-release-key.keystore
MYAPP_RELEASE_KEY_ALIAS=my-key-alias
MYAPP_RELEASE_STORE_PASSWORD=*****
MYAPP_RELEASE_KEY_PASSWORD=*****

android.enableAapt2=false

następnie dodaj te app / buid.gradle (app)

poniżej domyślnej konfiguracji

signingConfigs {
        release {
            if (project.hasProperty('MYAPP_RELEASE_STORE_FILE')) {
                storeFile file(MYAPP_RELEASE_STORE_FILE)
                storePassword MYAPP_RELEASE_STORE_PASSWORD
                keyAlias MYAPP_RELEASE_KEY_ALIAS
                keyPassword MYAPP_RELEASE_KEY_PASSWORD
            }
        }

oraz wersja typu Inside Build {}

 signingConfig signingConfigs.release

następnie po prostu uruchom to polecenie w terminalu Android Studio Poniższe polecenia zautomatyzują przede wszystkim odpowiedzi

jeśli Windows

cd android
gradlew assembleRelease

jeśli linux / mac

$ cd android
$ ./gradlew assembleRelease

jeśli wystąpi błąd, usuń cały folder kompilacji i uruchom polecenie

gradlew clean

niż znowu

gradlew assembleRelease

Najnowsze reakcje natywnych wersji w pakiecie projektu

Android

react-native bundle --platform android --dev false --entry-file index.js --bundle-output android/app/src/main/assets/index.android.bundle --assets-dest android/app/src/main/res/

iOS

react-native bundle --entry-file index.js --platform ios --dev false --bundle-output ios/main.jsbundle --assets-dest ios

Sposób GUI w Android Studio

• Otwórz aplikację Android React Native w Android Studio (oznacza to po prostu otwarcie folderu Android Twojego projektu React-Native w Android Studio)
• Przejdź do karty „Kompilacja” u góry
• Przejdź do „Kompilacji pakietów / pakietów APK”
• Następnie wybierz „Zbuduj pliki APK”
• Poprowadzi Cię przez proces lokalizowania kluczy do podpisania APK lub tworzenia kluczy, jeśli jeszcze ich nie masz, co jest bardzo proste. Jeśli tylko ćwiczysz, możesz wygenerować te klucze i zapisać je na pulpicie.
• Po zakończeniu tego procesu i jeśli kompilacja zakończyła się powodzeniem, poniżej pojawi się wyskakujące okienko w Android Studio. Kliknij znajdujący się w nim link z napisem „zlokalizuj” (APK)
• To zabierze Cię do pliku apk, przenieś go na urządzenie z Androidem. Następnie przejdź do tego pliku na urządzeniu z Androidem i zainstaluj go.

Użycie aplikacji Android Studio do wygenerowania podpisanego pliku APK dla projektu React's Android jest również dobrą i łatwą opcją, otwarcie projektu Android React w aplikacji Android Studio i wygenerowanie naciśnięcia klawisza i podpisanego APK.

Zapoznaj się z oficjalną dokumentacją reagującą na temat generowania podpisanego APK

Generowanie podpisanego APK przez React-Native