Migracja z NativeActivity Część pakietu Android Game Development Kit.
Na tej stronie dowiesz się, jak przejść z NativeActivity
na GameActivity
w projekcie gier na Androida.
GameActivity
opiera się na NativeActivity
z platformy Android, z ulepszeniami i nowymi funkcjami:
- Obsługuje
Fragment
z Jetpacka. - Dodano obsługę
TextInput
w celu ułatwienia integracji z klawiaturą programową. - Obsługuje zdarzenia dotyku i kluczowe w klasie Java
GameActivity
, a nie interfejsuNativeActivity
onInputEvent
.
Przed migracją zalecamy przeczytanie przewodnika dla początkujących, w którym opisano, jak skonfigurować i zintegrować GameActivity
w projekcie.
Aktualizacje skryptu kompilacji w Javie
GameActivity
jest rozpowszechniany jako biblioteka jetpacka. Pamiętaj, aby zastosować kroki aktualizacji skryptu Gradle opisane w przewodniku dla początkujących:
Włącz bibliotekę Jetpack w pliku
gradle.properties
projektu:android.useAndroidX=true
Opcjonalnie określ wersję prefabu w tym samym pliku
gradle.properties
, na przykład:android.prefabVersion=2.0.0
Włącz funkcję prefab w pliku
build.gradle
aplikacji:android { ... // other configurations buildFeatures.prefab true }
Dodaj zależność
GameActivity
do aplikacji:- Dodaj biblioteki
core
igames-activity
. - Jeśli obecny minimalny obsługiwany poziom interfejsu API to mniej niż 16, zmień go na co najmniej 16.
- Zaktualizuj skompilowaną wersję pakietu SDK do wersji, której wymaga biblioteka
games-activity
. Jetpack w czasie kompilacji wersji zwykle wymaga najnowszej wersji pakietu SDK.
Zaktualizowany plik
build.gradle
może wyglądać mniej więcej tak:android { compiledSdkVersion 33 ... // other configurations. defaultConfig { minSdkVersion 16 } ... // other configurations. buildFeatures.prefab true } dependencies { implementation 'androidx.core:core:1.9.0' implementation 'androidx.games:games-activity:1.2.2' }
- Dodaj biblioteki
Aktualizacje kodu Kotlin lub Javy
NativeActivity
może pełnić rolę aktywności uruchamiania i tworzenia aplikacji pełnoekranowej. Obecnie nie można używać GameActivity jako aktywności startowej. Aplikacje muszą pobierać klasę z GameActivity
i używać jej jako aktywności uruchamiania. Aby utworzyć aplikację pełnoekranową, musisz też wprowadzić w jej konfiguracji dodatkowe zmiany.
W poniższych krokach przyjęto, że Twoja aplikacja używa NativeActivity
jako działania startowego. W przeciwnym razie możesz pominąć większość z nich.
Utwórz plik Kotlin lub Java do hostowania nowej aktywności uruchamiania. Na przykład ten kod tworzy
MainActivity
jako działanie uruchamiania i wczytuje główną bibliotekę natywną aplikacji (libAndroidGame.so
):Kotlin
class MainActivity : GameActivity() { override fun onResume() { super.onResume() // Use the function recommended from the following page: // https://d.android.com/training/system-ui/immersive hideSystemBars() } companion object { init { System.loadLibrary("AndroidGame") } } }
Java
public class MainActivity extends GameActivity { protected void onResume() { super.onResume(); // Use the function recommended from // https://d.android.com/training/system-ui/immersive hideSystemBars(); } static { System.loadLibrary("AndroidGame"); } }
Utwórz motyw pełnoekranowy aplikacji w pliku
res\values\themes.xml
:<resources xmlns:tools="http://schemas.android.com/tools"> <!-- Base application theme. --> <style name="Application.Fullscreen" parent="Theme.AppCompat.Light.NoActionBar"> <item name="android:windowFullscreen">true</item> <item name="android:windowContentOverlay">@null</item>" </style> </resources>
Zastosuj motyw do aplikacji w pliku
AndroidManifest.xml
:<application android:theme=”@style/Application.Fullscreen”> <!-- other configurations not listed here. --> </application>
Szczegółowe instrukcje dotyczące trybu pełnoekranowego znajdziesz w szczegółowym przewodniku i w repozytorium z przykładami gier.
Ten przewodnik po migracji nie zmienia nazwy biblioteki natywnej. Jeśli go zmienisz, upewnij się, że nazwy bibliotek natywnych są spójne w tych 3 lokalizacjach:
Kod Kotlin lub Java:
System.loadLibrary(“AndroidGame”)
AndroidManifest.xml
:<meta-data android:name="android.app.lib_name" android:value="AndroidGame" />
Plik skryptu kompilacji C/C++, na przykład
CMakeLists.txt
:add_library(AndroidGame ...)
Aktualizacje skryptu kompilacji C/C++
W instrukcjach w tej sekcji jako przykładu użyjemy cmake
. Jeśli Twoja aplikacja używa ndk-build
, musisz zmapować je na odpowiadające im polecenia opisane na stronie dokumentacji ndk-build.
Implementacja języka C/C++ firmy GameActivity polega na udostępnianiu kodu źródłowego. W przypadku wersji 1.2.2 lub nowszej dostępna jest statyczna wersja biblioteki. Biblioteka statyczna to zalecany typ wersji.
Wersja jest dodana do AAR za pomocą narzędzia prefab
. Kod natywny zawiera źródła C/C++ GameActivity i kod native_app_glue
. Należy je utworzyć razem z kodem C/C++ aplikacji.
NativeActivity
aplikacje używają już kodu native_app_glue
dostarczanego w pakiecie NDK. Musisz go zastąpić wersją native_app_glue
systemu GameActivity. Poza tym wszystkie kroki cmake
opisane we przewodniku dla początkujących mają zastosowanie:
Zaimportuj do projektu bibliotekę statyczną C/C++ lub kod źródłowy C/++ w następujący sposób.
Biblioteka statyczna
W pliku
CMakeLists.txt
projektu zaimportuj bibliotekę statycznągame-activity
do modułu prefabowegogame-activity_static
:find_package(game-activity REQUIRED CONFIG) target_link_libraries(${PROJECT_NAME} PUBLIC log android game-activity::game-activity_static)
Kod źródłowy
W pliku
CMakeLists.txt
projektu zaimportuj pakietgame-activity
i dodaj go do miejsca docelowego. Pakietgame-activity
wymagalibandroid.so
, więc jeśli go brakuje, musisz go też zaimportować.find_package(game-activity REQUIRED CONFIG) ... target_link_libraries(... android game-activity::game-activity)
Usuń wszystkie odniesienia do kodu
native_app_glue
pakietu NDK, takie jak:${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c ... set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -u ANativeActivity_onCreate")
Jeśli używasz wersji kodu źródłowego, dołącz pliki źródłowe
GameActivity
. W przeciwnym razie pomiń ten krok.get_target_property(game-activity-include game-activity::game-activity INTERFACE_INCLUDE_DIRECTORIES) add_library(${PROJECT_NAME} SHARED main.cpp ${game-activity-include}/game-activity/native_app_glue/android_native_app_glue.c ${game-activity-include}/game-activity/GameActivity.cpp ${game-activity-include}/game-text-input/gametextinput.cpp)
Rozwiązanie problemu: UnsatisfiedLinkError
Jeśli natrafisz na UnsatsifiedLinkError
dla funkcji com.google.androidgamesdk.GameActivity.initializeNativeCode()
, dodaj ten kod do pliku CMakeLists.txt
:
set(CMAKE_SHARED_LINKER_FLAGS
"${CMAKE_SHARED_LINKER_FLAGS} -u \
Java_com_google_androidgamesdk_GameActivity_initializeNativeCode")
Aktualizacje kodu źródłowego C/C++
Wykonaj te czynności, aby zastąpić odwołania do NativeActivity
w aplikacji ciągiem GameActivity
:
Użyj systemu
native_app_glue
wydanego zGameActivity
. Wyszukaj i zastąp całe użycie elementuandroid_native_app_glue.h
następującym fragmentem:#include <game-activity/native_app_glue/android_native_app_glue.h>
Ustaw filtr zdarzeń ruchu i filtr kluczowych zdarzeń na
NULL
, aby aplikacja mogła odbierać zdarzenia wejściowe ze wszystkich urządzeń wejściowych. Zwykle robisz to w ramach funkcjiandroid_main()
:void android_main(android_app* app) { ... // other init code. android_app_set_key_event_filter(app, NULL); android_app_set_motion_event_filter(app, NULL); ... // additional init code, and game loop code. }
Usuń powiązany kod
AInputEvent
i zastąp go implementacjąInputBuffer
platformy GameActivity:while (true) { // Read all pending events. int events; struct android_poll_source* source; // If not animating, block forever waiting for events. // If animating, loop until all events are read, then continue // to draw the next frame of animation. while ((ALooper_pollAll(engine.animating ? 0 : -1, nullptr, &events, (void**)&source)) >= 0) { // Process this app cycle or inset change event. if (source) { source->process(source->app, source); } ... // Other processing. // Check if app is exiting. if (state->destroyRequested) { engine_term_display(&engine); return; } } // Process input events if there are any. engine_handle_input(state); if (engine.animating) { // Draw a game frame. } } // Implement input event handling function. static int32_t engine_handle_input(struct android_app* app) { auto* engine = (struct engine*)app->userData; auto ib = android_app_swap_input_buffers(app); if (ib && ib->motionEventsCount) { for (int i = 0; i < ib->motionEventsCount; i++) { auto *event = &ib->motionEvents[i]; int32_t ptrIdx = 0; switch (event->action & AMOTION_EVENT_ACTION_MASK) { case AMOTION_EVENT_ACTION_POINTER_DOWN: case AMOTION_EVENT_ACTION_POINTER_UP: // Retrieve the index for the starting and the ending of any secondary pointers ptrIdx = (event->action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT; case AMOTION_EVENT_ACTION_DOWN: case AMOTION_EVENT_ACTION_UP: engine->state.x = GameActivityPointerAxes_getAxisValue( &event->pointers[ptrIdx], AMOTION_EVENT_AXIS_X); engine->state.y = GameActivityPointerAxes_getAxisValue( &event->pointers[ptrIdx], AMOTION_EVENT_AXIS_Y); break; case AMOTION_EVENT_ACTION_MOVE: // Process the move action: the new coordinates for all active touch pointers // are inside the event->pointers[]. Compare with our internally saved // coordinates to find out which pointers are actually moved. Note that there is // no index embedded inside event->action for AMOTION_EVENT_ACTION_MOVE (there // might be multiple pointers moved at the same time). ... break; } } android_app_clear_motion_events(ib); } // Process the KeyEvent in a similar way. ... return 0; }
Sprawdź i zaktualizuj logikę dołączoną do właściwości
AInputEvent
elementu NativeActivity. Jak pokazano w poprzednim kroku, przetwarzanieInputBuffer
przez GameActivity znajduje się poza pętląALooper_pollAll()
.Zastąp użycie elementu
android_app::activity->clazz
wartościąandroid_app:: activity->javaGameActivity
. GameActivity zmienia nazwę instancji JavaGameActivity
.
Dodatkowe czynności
Poprzednie kroki opisują działanie NativeActivity, ale GameActivity
oferuje też dodatkowe funkcje, które mogą Ci się przydać:
- TextInput.
- Kontroler gier.
- Fragment.
- Polecenia InSets w nowym oknie zdefiniowane w komponencie NativeAppGlueAppCmd.
Warto zapoznać się z tymi funkcjami i odpowiednio je wdrożyć w swoich grach.
Jeśli masz pytania lub rekomendacje dotyczące GameActivity lub innych bibliotek AGDK, utwórz błąd, aby nas o tym poinformować.