Migracja do Android Studio

Przenoszenie projektów do Android Studio wymaga dostosowania się do nowej struktury projektu, systemu kompilacji i funkcji IDE.

Jeśli migrujesz z IntelliJ, a Twój projekt korzysta już z Gradle, możesz otworzyć istniejący projekt w Android Studio. Jeśli używasz IntelliJ, ale Twój projekt nie korzysta jeszcze z Gradle, musisz go przygotować ręcznie, zanim zaimportujesz go do Android Studio. Więcej informacji znajdziesz w sekcji Migracja z IntelliJ.

Podstawy Android Studio

Oto kilka najważniejszych różnic, o których należy pamiętać podczas przygotowywania się do migracji do Android Studio.

Organizacja projektów i modułów

Android Studio jest oparte na środowisku programistycznym IntelliJ IDEA. Aby zapoznać się z podstawowymi informacjami o IDE, takimi jak nawigacja, uzupełnianie kodu i skróty klawiszowe, zobacz Poznaj Android Studio.

Android Studio porządkuje kod w projektach, które zawierają wszystko, co definiuje Twoją aplikację na Androida, od kodu źródłowego aplikacji po konfiguracje kompilacji i kod testowy. Projekty otwierają się w osobnych oknach Android Studio. Każdy projekt zawiera co najmniej 1 moduł, który umożliwia podzielenie projektu na oddzielne jednostki funkcjonalne. Moduły można tworzyć, testować i debugować niezależnie.

Więcej informacji o projektach i modułach Android Studio znajdziesz w artykule Omówienie projektów.

System kompilacji oparty na Gradle

System kompilacji Android Studio jest oparty na Gradle i korzysta z plików konfiguracji kompilacji napisanych w skrypcie Groovy lub Kotlin, co ułatwia rozszerzanie i dostosowywanie.

Projekty oparte na Gradle oferują ważne funkcje dla programistów aplikacji na Androida, takie jak:

  • Obsługa bibliotek binarnych (AAR). Nie musisz już kopiować źródeł biblioteki do własnych projektów. Możesz zadeklarować zależność, a biblioteka zostanie automatycznie pobrana i złączona z Twoim projektem. Obejmuje to automatyczne scalanie zasobów, wpisów manifestu, reguł wykluczania ProGuard, niestandardowych reguł lintowania itd. w czasie kompilacji.
  • Obsługa wariantów kompilacji, które umożliwiają kompilowanie różnych wersji aplikacji (np. bezpłatnej i płatnej) z tego samego projektu.
  • łatwa konfiguracja wersji i dostosowywanie; Na przykład możesz pobrać nazwy i kody wersji z tagów Git w ramach kompilacji.
  • Gradle można używać w IDE, wierszu poleceń i na serwerach ciągłej integracji, takich jak Jenkins, co zapewnia taki sam kompilację wszędzie i za każdym razem.

Więcej informacji o używaniu i konfigurowaniu Gradle znajdziesz w artykule Konfigurowanie procesu kompilacji.

Zależności

Zależności bibliotek w Android Studio używają deklaracji zależności Gradle i zależności Maven w przypadku znanych lokalnych bibliotek źródłowych i binarnych z koordynatami Maven. Więcej informacji znajdziesz w artykule Deklarowanie zależności.

Migracja z IntelliJ

Jeśli Twój projekt IntelliJ korzysta z systemu kompilacji Gradle, możesz zaimportować projekt bezpośrednio do Android Studio. Jeśli Twój projekt w IntelliJ korzysta z Mavena lub innego systemu kompilacji, musisz skonfigurować go do pracy z Gradle, zanim będzie można przeprowadzić migrację do Android Studio.

Importowanie projektu IntelliJ opartego na Gradle

Jeśli używasz już Gradle w projekcie IntelliJ, otwórz go w Android Studio w ten sposób:

  1. Kliknij Plik > Nowy > Importuj projekt.
  2. Wybierz katalog projektu IntelliJ i kliknij OK. Projekt otworzy się w Android Studio.

Importowanie projektu IntelliJ innego niż Gradle

Jeśli Twój projekt IntelliJ nie korzysta jeszcze z systemu kompilacji Gradle, masz 2 opcje importowania projektu do Android Studio. Opcje te są opisane w następnych sekcjach:

Aby przeprowadzić migrację, utwórz nowy pusty projekt

Aby przenieść projekt do Android Studio, tworząc nowy pusty projekt i kopiując pliki źródłowe do nowych katalogów, wykonaj te czynności:

  1. Otwórz Android Studio i kliknij Plik > Nowy > Nowy projekt.
  2. Wpisz nazwę projektu aplikacji i określ lokalizację, w której ma zostać utworzony, a następnie kliknij Dalej.
  3. Wybierz formaty, w których aplikacja będzie działać, a potem kliknij Dalej.
  4. Kliknij kolejno Dodaj brak aktywności i Zakończ.
  5. W oknie narzędzi Projekt kliknij strzałkę, aby otworzyć menu widoku, i wybierz widok Projekt, aby zobaczyć i przeglądać organizację nowego projektu w Android Studio. Więcej informacji o zmienianiu widoków i strukturze projektów w Android Studio znajdziesz w artykule Pliki projektu.
  6. Przejdź do lokalizacji wybranej dla nowego projektu i przenieś kod, testy jednostkowe, testy instrumentacji i zasoby ze starych katalogów projektów do odpowiednich lokalizacji w nowej strukturze projektu.
  7. W Android Studio kliknij Plik > Struktura projektu, aby otworzyć okno Struktura projektu. Upewnij się, że w panelu po lewej stronie jest wybrany moduł aplikacji.
  8. Wprowadź niezbędne modyfikacje na karcie Właściwości projektu (np. zmodyfikuj minSdk lub targetSdk).
  9. Kliknij Zależności i dodaj biblioteki, od których zależy Twój projekt, jako zależności Gradle. Aby dodać nową zależność, kliknij Dodaj , a następnie wybierz typ zależności, który chcesz dodać, i postępuj zgodnie z instrukcjami.
  10. Aby zapisać zmiany, kliknij OK.
  11. Kliknij Kompiluj > Utwórz projekt, aby przetestować kompilowanie projektu, a w razie potrzeby usunąć ewentualne błędy.

Przejście na Gradle przez utworzenie niestandardowego pliku kompilacji Gradle

Aby przenieść projekt do Android Studio, tworząc nowy plik kompilacji Gradle, który będzie wskazywał istniejące pliki źródłowe, wykonaj te czynności:

  1. Zanim zaczniesz, utwórz kopię zapasową plików projektu w oddzielnym miejscu, ponieważ proces migracji zmodyfikuje zawartość projektu na miejscu.
  2. Utwórz w katalogu projektu plik o nazwie build.gradle, jeśli używasz Groovy, lub build.gradle.kts, jeśli używasz skryptu Kotlin. Ten plik zawiera wszystkie informacje wymagane do uruchomienia kompilacji przez Gradle.

    Domyślnie Android Studio oczekuje, że projekt będzie zorganizowany w sposób pokazany na rysunku 1.

    Rysunek 1. Domyślna struktura projektu modułu aplikacji na Androida.

    W przypadku skryptu Groovy (settings.gradle) lub skryptu Kotlin (settings.gradle.kts) w odpowiednich blokach pluginManagement i dependencyResolutionManagement ustawiasz repozytoria używane do znajdowania wtyczek i zależności:

    Odlotowe

      pluginManagement {
      repositories {
          google()
          mavenCentral()
          gradlePluginPortal()
      }
  }
  dependencyResolutionManagement {
      repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
      repositories {
          google()
          mavenCentral()
      }
  }
  rootProject.name = "Test App"
  include ':app'

    Kotlin

      pluginManagement {
      repositories {
          google()
          mavenCentral()
          gradlePluginPortal()
      }
  }
  dependencyResolutionManagement {
      repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
      repositories {
          google()
          mavenCentral()
      }
  }
  rootProject.name = "Test App"
  include(":app")

    Ostrzeżenie: 31 marca 2021 r. repozytorium JCenter stało się tylko do odczytu. Więcej informacji znajdziesz w aktualizacji usługi JCenter.

    Wtyczka Androida do obsługi Gradle stosuje w projekcie niektóre domyślne zestawy źródłowe. Te zbiory źródłowe definiują katalogi używane do przechowywania różnych typów plików źródłowych. Gradle używa tych zbiorów źródeł do określania lokalizacji określonych typów plików. Jeśli Twój istniejący projekt nie jest zgodny z ustawieniami domyślnymi, możesz przenieść pliki tam, gdzie powinny się znajdować, lub zmienić domyślne zestawy źródłowe, aby Gradle wiedziała, gdzie je znaleźć.

    Więcej informacji o konfigurowaniu i dostosowywaniu pliku kompilacji Gradle znajdziesz w artykule Konfigurowanie kompilacji.

  3. Następnie określ, których projektów biblioteki używasz.

    Dzięki Gradle nie musisz już dodawać tych bibliotek jako projektów kodu źródłowego. Zamiast tego możesz je wywołać w bloku dependencies{} w pliku kompilacji. System kompilacji obsługuje te biblioteki, m.in. pobiera biblioteki, scala zasoby i scala wpisy w pliku manifestu. Ten przykład dodaje instrukcje deklaracji dla kilku bibliotek AndroidaX do bloku dependencies{} w pliku kompilacji.

    Odlotowe

    ...
dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    // AndroidX libraries
    implementation 'androidx.core:core-ktx:1.15.0'
    implementation 'androidx.appcompat:appcompat:1.7.0'
    implementation 'androidx.cardview:cardview:1.0.0'
    implementation 'com.google.android.material:material:1.7.0'
    implementation 'androidx.gridlayout:gridlayout:1.0.0'
    implementation 'androidx.leanback:leanback:1.1.0-rc02'
    implementation 'androidx.mediarouter:mediarouter:1.7.0'
    implementation 'androidx.palette:palette-ktx:1.0.0'
    implementation 'androidx.recyclerview:recyclerview:1.3.2'
    implementation 'androidx.annotation:annotation:1.9.1'

    // Note: these libraries require that the Google repository has been declared
    // in the pluginManagement section of the top-level build.gradle file.
}

    Kotlin

    ...
dependencies {
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))

    // AndroidX libraries
    implementation("androidx.core:core-ktx:1.15.0")
    implementation("androidx.appcompat:appcompat:1.7.0")
    implementation("androidx.cardview:cardview:1.0.0")
    implementation("com.google.android.material:material:1.7.0")
    implementation("androidx.gridlayout:gridlayout:1.0.0")
    implementation("androidx.leanback:leanback:1.1.0-rc02")
    implementation("androidx.mediarouter:mediarouter:1.7.0")
    implementation("androidx.palette:palette-ktx:1.0.0")
    implementation("androidx.recyclerview:recyclerview:1.3.2")
    implementation("androidx.annotation:annotation:1.9.1")

    // Note: these libraries require that the Google repository has been declared
    // in the pluginManagement section of the top-level build.gradle.kts file.
}
    Aby uzyskać pomoc w określeniu prawidłowych instrukcji deklaracji w swoich bibliotekach, przeszukaj repozytorium Google Maven lub Maven.
  4. Zapisz plik build.gradle, a następnie zamknij projekt w IntelliJ. Otwórz katalog projektu i usuń katalog .idea oraz wszystkie pliki IML w tym projekcie.
  5. Uruchom Android Studio i kliknij Plik > Nowy > Importuj projekt.
  6. Znajdź katalog projektu, wybierz utworzony plik build.gradle lub build.gradle.kts, a następnie kliknij OK, aby zaimportować projekt.
  7. Aby przetestować plik kompilacji, kliknij Kompiluj > Utwórz projekt, aby skompilować projekt i usunąć znalezione błędy.

Dalsze kroki

Po migracji projektu do Android Studio możesz dowiedzieć się więcej o kompilowaniu za pomocą Gradle i uruchamianiu aplikacji w Android Studio. Więcej informacji znajdziesz w artykule Kompilowanie i uruchamianie aplikacji.

W zależności od projektu i przepływu pracy możesz też chcieć dowiedzieć się więcej o kontroli wersji, zarządzaniu zależnościami i konfigurowaniu Android Studio. Aby rozpocząć korzystanie z Android Studio, przeczytaj artykuł Poznaj Android Studio.

Konfigurowanie kontroli wersji

Android Studio obsługuje wiele systemów kontroli wersji, w tym Git, Mercurial i Subversion. Inne systemy kontroli wersji można dodawać za pomocą wtyczek.

Jeśli aplikacja jest już objęta kontrolą wersji, konieczne może być włączenie tej funkcji w Android Studio. W menu VCS kliknij Włącz integrację z kontrolą wersji i wybierz odpowiedni system kontroli wersji.

Jeśli aplikacja nie podlega kontroli nad źródłem, możesz ją skonfigurować po zaimportowaniu aplikacji do Android Studio. Użyj opcji menu VCS w Android Studio, aby włączyć obsługę VCS dla wybranego systemu kontroli wersji, utworzyć repozytorium, zaimportować nowe pliki do kontroli wersji i wykonywać inne operacje kontroli wersji:

  1. W menu VCS w Android Studio kliknij Włącz integrację kontroli wersji.
  2. W menu wybierz system kontroli wersji, który chcesz powiązać z katalogiem głównym projektu, a następnie kliknij OK. Menu VCS wyświetla teraz kilka opcji kontroli wersji na podstawie wybranego systemu.

Uwaga: aby skonfigurować i zmodyfikować kontrolę wersji, możesz też użyć opcji menu Plik > Ustawienia > Kontrola wersji.

Więcej informacji o pracy z kontrolą wersji znajdziesz w dokumentacji IntelliJ dotyczącej kontroli wersji.

Podpisywanie aplikacji

Jeśli certyfikat debugowania był używany wcześniej, może zostać wykryty podczas procesu importowania. W takim przypadku Android Studio nadal odwołuje się do tego certyfikatu. W przeciwnym razie konfiguracja debugowania używa klucza debugowania wygenerowanego przez Androida Studio, który korzysta z znanego hasła i domyślnego klucza z znanym hasłem znajdującym się w pliku $HOME/.android/debug.keystore. Typ kompilacji debugowania jest ustawiony tak, aby automatycznie używać tej konfiguracji debugowania podczas uruchamiania lub debugowania projektu w Android Studio.

Podobnie proces importowania może wykryć istniejący certyfikat wydania. Jeśli nie zdefiniowano wcześniej certyfikatu wersji, dodaj konfigurację podpisywania wersji do pliku build.gradle lub build.gradle.kts albo użyj opcji menu Kompilacja > Wygeneruj podpisany pakiet APK, aby otworzyć Kreatora podpisanego pakietu APK. Więcej informacji o podpisywaniu aplikacji znajdziesz w artykule Podpisywanie aplikacji.

Dostosowywanie maksymalnego rozmiaru stosu w Android Studio

Domyślny rozmiar stosu w Android Studio to 1280 MB. Jeśli pracujesz nad dużym projektem lub Twój system ma dużo pamięci RAM, możesz poprawić wydajność, zwiększając maksymalny rozmiar stosu.

Aktualizacje oprogramowania

Android Studio aktualizuje się niezależnie od wtyczki Gradle, narzędzi kompilacji i narzędzi pakietu SDK. Możesz określić, których wersji chcesz używać w Android Studio.

Domyślnie Android Studio zapewnia automatyczne aktualizacje po wydaniu nowej wersji stabilnej, ale możesz też zdecydować się na częstsze aktualizacje i otrzymywanie wersji w wersji zapoznawczej lub beta.

Więcej informacji o aktualizowaniu Android Studio oraz korzystaniu z wersji testowych i beta znajdziesz w artykule o aktualizacjach.