Bu sayfa, Cloud Translation API ile çevrilmiştir.

NativeActivity'den taşı Android Oyun Geliştirme Kiti'nin bir parçasıdır.

Bu sayfada, NativeActivity - Android oyun projenizde GameActivity.

GameActivity, Android'deki NativeActivity verilerini temel almaktadır çerçevesini, geliştirmeleri ve yeni özellikleri içerir:

Jetpack'ten Fragment desteklenir.
Yumuşak klavye entegrasyonunu kolaylaştırmak için TextInput desteği ekler.
Bunun yerine GameActivity Java sınıfındaki dokunma ve önemli etkinlikleri işler: NativeActivity onInputEvent arayüzü.

Taşıma işleminden önce başlangıç kılavuzuna GameActivity ayarlarını yapıp projenize entegre edin.

Java derleme komut dosyası güncellemeleri

GameActivity, şu şekilde dağıtıldı: Jetpack kitaplığını açın. Açıklanan Gradle komut dosyası güncelleme adımlarını uyguladığınızdan emin olun başlangıç kılavuzunda:

Projenizin gradle.properties dosyasında Jetpack kitaplığını etkinleştirin:
```
android.useAndroidX=true
```
İsteğe bağlı olarak aynı gradle.properties dosyasında Prefab sürümü belirtin. örneğin:
```
android.prefabVersion=2.0.0
```
Uygulamanızın build.gradle dosyasında Prefabrik özelliğini etkinleştirin:
```
android {
    ... // other configurations
    buildFeatures.prefab true
}
```
GameActivity bağımlılığını uygulamanıza ekleyin:
1. core ve games-activity kitaplıklarını ekleyin.
2. Şu anda desteklenen minimum API düzeyiniz 16'dan düşükse güncelleyin en az 16 olmalıdır.
3. Derlenen SDK sürümünü, games-activity çok kolay olur. Jetpack genellikle en son SDK sürümünü şu adreste gerektirir: zamanı öğreneceğiz.
Güncellenen build.gradle dosyanız aşağıdaki gibi görünebilir:
```
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'
}
```

Kotlin veya Java kodu güncellemeleri

NativeActivity, başlangıç etkinliği olarak kullanılabilir ve tam ekran oluşturur bir uygulamadır. GameActivity şu anda başlangıç olarak kullanılamaz etkinliği'ne dokunun. Uygulamalar GameActivity kaynağından bir sınıf türetmeli ve bunu şu şekilde kullanmalıdır: başlatma etkinliğinden oluşur. Ayrıca, tam ekran uygulama oluşturabilirsiniz.

Aşağıdaki adımlarda uygulamanızın başlangıç olarak NativeActivity kullandığı varsayılmaktadır etkinliği'ne dokunun. Böyle bir durum söz konusu değilse çoğu bölümü atlayabilirsiniz.

Yeni başlangıç etkinliğini barındırmak için bir Kotlin veya Java dosyası oluşturun. Örneğin, aşağıdaki kod, başlangıç etkinliği olarak MainActivity öğesini oluşturur ve uygulamanın ana yerel kitaplığını (libAndroidGame.so) yükler:

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");
      }
  }

res\values\themes.xml dosyasında tam ekran uygulama teması oluşturun:

<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>

Temayı AndroidManifest.xml dosyasındaki uygulamaya uygulayın:
```
<application  android:theme=”@style/Application.Fullscreen”>
     
</application>
```
Tam ekran moduyla ilgili ayrıntılı talimatlar için kapsamlı bir rehbere ihtiyacınız olacaktır. örnekler deposu'na gidin.

Bu taşıma rehberi, yerel kitaplık adını değiştirmez. Değişiklik yerel kitaplık adlarının aşağıdaki üç dilde tutarlı olduğundan emin olun: yerler:

Kotlin veya Java kodu:
```
System.loadLibrary(“AndroidGame”)
```

AndroidManifest.xml:

<meta-data android:name="android.app.lib_name"
        android:value="AndroidGame" />

C/C++ derleme komut dosyası dosyasının içinde (örneğin, CMakeLists.txt):
```
add_library(AndroidGame ...)
```

C/C++ derleme komut dosyası güncellemeleri

Bu bölümdeki talimatlar örnek olarak cmake kullanır. Uygulamanız ndk-build kullanıyorsa bunları şurada açıklanan eşdeğer komutlarla eşlemeniz gerekir: ndk-build belgeleri sayfasını ziyaret edin.

GameActivity'nin C/C++ uygulaması, bir kaynak kodu sürümü sağlıyordu. 1.2.2 ve sonraki sürümler için statik kitaplık sürümü sağlanır. Statik kitaplığınız önerilen sürüm türüdür.

Yayın, AAR'nin içinde prefab yardımcı olur. Yerel kod, GameActivity'nin C/C++ kaynaklarını ve native_app_glue kod. Bunların, kullandığınız Google uygulamanın C/C++ kodu.

NativeActivity uygulama zaten native_app_glue kullanıyor kodu NDK içinde gönderilir. Bunu GameActivity sürümüyle değiştirmeniz gerekir / native_app_glue. Bunun dışında, cmake adımın tamamı şu başlangıç kılavuzu geçerlidir:

C/C++ statik kitaplığını veya C/++ kaynak kodunu takip etmeniz gerekir.
Statik kitaplık
Projenizin CMakeLists.txt dosyasına game-activity statik game-activity_static prefab modülüne ekledik:
```
find_package(game-activity REQUIRED CONFIG)
target_link_libraries(${PROJECT_NAME} PUBLIC log android
game-activity::game-activity_static)
```
Kaynak kodu
Projenizin CMakeLists.txt dosyasına game-activity pakete ekleyip hedefinize ekleyin. game-activity paketi için gerekenler libandroid.so; eksikse dosyayı da içe aktarmanız gerekir.
```
find_package(game-activity REQUIRED CONFIG)
...
target_link_libraries(... android game-activity::game-activity)
```

NDK'nın native_app_glue koduna yapılan tüm referansları kaldırın. Örneğin:

${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c
    ...
set(CMAKE_SHARED_LINKER_FLAGS
    "${CMAKE_SHARED_LINKER_FLAGS} -u ANativeActivity_onCreate")

Kaynak kodu sürümünü kullanıyorsanız GameActivity kaynağını ekleyin. dosyası olarak da kaydedebilir. Aksi halde bu adımı atlayın.

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)

UnsatisfiedLinkError sorununu giderme

Bir UnsatsifiedLinkError ile karşılaşırsanız com.google.androidgamesdk.GameActivity.initializeNativeCode() işlevi, ekleyin CMakeLists.txt dosyanıza bu kodu ekleyin:

set(CMAKE_SHARED_LINKER_FLAGS
    "${CMAKE_SHARED_LINKER_FLAGS} -u \
    Java_com_google_androidgamesdk_GameActivity_initializeNativeCode")

C/C++ kaynak kodu güncellemeleri

NativeActivity referansını değiştirmek için şu adımları uygulayın: GameActivity ile uygulama:

Yayınlanan native_app_glue öğesini GameActivity ile kullanın. Arayın ve tüm android_native_app_glue.h kullanımını şununla değiştir:
```
#include <game-activity/native_app_glue/android_native_app_glue.h>
```

Uygulamanızın şunları yapabilmesi için hem hareket etkinliği filtresini hem de önemli etkinlik filtresini NULL olarak ayarlayın: tüm giriş cihazlarından giriş etkinliklerini alma. Bu işlemi genelde android_main() işlevi:

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.
}

AInputEvent ilgili kodu kaldırıp GameActivity komutuyla değiştirin InputBuffer uygulaması:

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;
}

NativeActivity'ye eklenen mantığı inceleyin ve güncelleyin. AInputEvent Önceki adımda gösterildiği gibi, GameActivity'nin InputBuffer işleme, ALooper_pollAll() döngüsünün dışında.
android_app::activity->clazz kullanımını şununla değiştir: android_app:: activity->javaGameActivity. GameActivity, Java GameActivity örneği.

Ek adımlar

Önceki adımlar NativeActivity'nin işlevlerini kapsamaktadır, ancak GameActivity ek özellikler hakkında daha fazla bilgi edinebilirsiniz:

TextInput.
Oyun Kumandası.
Parça.
NativeAppGlueAppCmd'de tanımlanan yeni penceredeki InSets komutları.

Bu özellikleri keşfetmenizi ve kendi ihtiyaçlarınıza uygun şekilde kullanmanızı öneririz. oyunlar.

GameActivity veya diğer AGDK ile ilgili sorularınız ya da önerileriniz varsa bize bildirmek için bir hata oluşturun.