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 podstawami IDE, takimi jak nawigacja, uzupełnianie kodu i skróty klawiszowe, przeczytaj artykuł Poznaj Androida 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 kompilować, testować i debugować niezależnie.

Więcej informacji o projektach i modułach w 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, aby ułatwić rozszerzanie i dostosowywanie.

Projekty oparte na Gradle oferują ważne funkcje do tworzenia aplikacji na Androida, w tym:

  • 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 w pliku manifestu, reguł wykluczenia Proguarda, niestandardowych reguł lint itp. w momencie 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 ten 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 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, przed migracją do Android Studio musisz skonfigurować go do pracy z Gradle.

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, który nie jest projektem 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:

Migracja polegająca na utworzeniu nowego pustego projektu

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 projektu do odpowiednich lokalizacji w nowej strukturze projektu.
  7. W Android Studio kliknij Plik > Struktura projektu, aby otworzyć okno Struktura projektu. W lewym panelu sprawdź, czy wybrany jest 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órą 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 przez Gradle do uruchomienia kompilacji.

    Domyślnie Android Studio wymaga, aby projekt był 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 blokach pluginManagement i dependencyResolutionManagement odpowiednio ustawiasz repozytoria używane do znajdowania wtyczek i zależności:

    Groovy

      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ódeł definiują katalogi używane do przechowywania różnych typów plików źródłowych. Gradle używa tych zbiorów źródłowych do określania lokalizacji określonych typów plików. Jeśli istniejący projekt nie jest zgodny z wartościami domyślnymi, możesz przenieść pliki w odpowiednie miejsce lub zmienić domyślne zestawy źródeł, aby Gradle wiedział, 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.

    W 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. W tym przykładzie do bloku dependencies{} w pliku kompilacji dodano instrukcje deklaracji dla kilku bibliotek AndroidX.

    Groovy

    ...
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 znaleźć odpowiednie deklaracje dla swoich bibliotek, przeszukaj repozytorium Google Maven lub Maven Central.
  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. Odszukaj katalog projektu, wybierz utworzony plik build.gradle lub build.gradle.kts, a potem 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 jest objęta kontrolą wersji, możesz ją skonfigurować po jej zaimportowaniu 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 Android Studio kliknij Włącz integrację z systemem 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 certyfikat wersji nie został wcześniej zdefiniowany, dodaj konfigurację podpisywania wersji do pliku build.gradle lub build.gradle.kts albo użyj opcji menu Utwórz > Wygeneruj podpisany pakiet APK, aby otworzyć kreator generowania podpisanego pliku 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 zwiększyć 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.