Migracja do Android Studio

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

Jeśli przeprowadzasz migrację z IntelliJ i 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 ręcznie przygotować projekt, zanim zaimportujesz go do Android Studio. Więcej informacji znajdziesz w sekcji Migracja z IntelliJ.

Podstawowe informacje o Android Studio

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

Organizacja projektu i modułu

Android Studio jest oparte na środowisku IDE IntelliJ IDEA. Aby zapoznać się z podstawami środowiska IDE, takimi jak nawigacja, uzupełnianie kodu i skróty klawiszowe, przeczytaj artykuł Poznaj Android Studio.

Android Studio organizuje kod w projekty, które zawierają wszystko, co definiuje 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 odrębne jednostki funkcjonalności. Moduły można kompilować, 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 używa plików konfiguracji kompilacji napisanych w skrypcie Groovy lub Kotlin, co ułatwia 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 scalona z Twoim projektem. Obejmuje to automatyczne scalanie zasobów, wpisów w pliku manifestu, reguł wykluczeń Proguard, niestandardowych reguł Lint itp. podczas kompilacji.
  • Obsługa wariantów kompilacji, która umożliwia tworzenie różnych wersji aplikacji (np. bezpłatnej wersji i płatnej) z tego samego projektu.
  • Łatwa konfiguracja kompilacji i dostosowywanie. Możesz na przykład pobierać nazwy i kody wersji z tagów Git w ramach kompilacji.
  • Gradle można używać w środowisku IDE, w wierszu poleceń i na serwerach ciągłej integracji, takich jak Jenkins, co zapewnia tę samą kompilację wszędzie i za każdym razem.

Więcej informacji o używaniu i konfigurowaniu Gradle znajdziesz w artykule Konfigurowanie 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 współrzędnymi 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ć go bezpośrednio do Android Studio. Jeśli Twój projekt IntelliJ korzysta z Maven lub innego systemu kompilacji, musisz go skonfigurować tak, aby działał z Gradle, zanim przeprowadzisz 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, wykonując te czynności:

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

Importowanie projektu IntelliJ nieopartego na Gradle

Jeśli Twój projekt IntelliJ nie korzysta jeszcze z systemu kompilacji Gradle, masz 2 opcje importowania projektu do Android Studio, które opisujemy w sekcjach poniżej:

Migracja przez utworzenie 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 działa Twoja aplikacja, a następnie kliknij Dalej.
  4. Kliknij Dodaj brak aktywności, a następnie kliknij Zakończ.
  5. W oknie narzędziowym Projekt kliknij strzałkę, aby otworzyć menu widoku i wybierz widok Projekt , aby zobaczyć i poznać strukturę nowego projektu Android Studio. Więcej informacji o zmianie 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. Upewnij się, że w panelu po lewej stronie jest wybrany moduł aplikacji.
  8. Wprowadź niezbędne zmiany na karcie Właściwości projektu (np. zmień minSdk lub targetSdk).
  9. Kliknij Zależności i dodaj wszystkie 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. Kliknij OK , aby zapisać zmiany.
  11. Kliknij Utwórz > Utwórz projekt , aby przetestować kompilację projektu, a w razie potrzeby rozwiązać wszystkie nierozwiązane błędy.

Migracja 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 osobnej lokalizacji, ponieważ proces migracji modyfikuje zawartość projektu w 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 tak jak na rysunku 1.

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

    W pliku settings.gradle (w przypadku Groovy) lub settings.gradle.kts (w przypadku skryptu Kotlin) ustawiasz repozytoria, które są używane do znajdowania wtyczek i zależności odpowiednio w blokach pluginManagement i dependencyResolutionManagement:

    Dynamiczny

      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 artykule Aktualizacja usługi JCenter.

    Wtyczka Androida do obsługi Gradle stosuje do projektu domyślne zestawy źródeł. Te zestawy źródeł określają katalogi używane do przechowywania różnych typów plików źródłowych. Gradle używa tych zestawów źródeł do określania lokalizacji określonych typów plików. Jeśli Twój dotychczasowy projekt nie jest zgodny z ustawieniami domyślnymi, możesz przenieść pliki do odpowiednich miejsc 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 bibliotek używasz.

    Dzięki Gradle nie musisz już dodawać tych bibliotek jako projektów kodu źródłowego. Możesz się do nich odwoływać w bloku dependencies{} pliku kompilacji. System kompilacji obsługuje te biblioteki, w tym pobieranie bibliotek, scalanie zasobów i scalanie wpisów w pliku manifestu. Poniższy przykład dodaje instrukcje deklaracji dla kilku bibliotek AndroidX do bloku dependencies{} pliku kompilacji.

    Dynamiczny

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

    // AndroidX libraries
    implementation 'androidx.core:core-ktx:1.18.0'
    implementation 'androidx.appcompat:appcompat:1.7.1'
    implementation 'androidx.cardview:cardview:1.0.0'
    implementation 'com.google.android.material:material:1.7.0'
    implementation 'androidx.gridlayout:gridlayout:1.1.0'
    implementation 'androidx.leanback:leanback:'
    implementation 'androidx.mediarouter:mediarouter:1.8.1'
    implementation 'androidx.palette:palette-ktx:1.0.0'
    implementation 'androidx.recyclerview:recyclerview:1.4.0'
    implementation 'androidx.annotation:annotation:1.10.0'

    // 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.18.0")
    implementation("androidx.appcompat:appcompat:1.7.1")
    implementation("androidx.cardview:cardview:1.0.0")
    implementation("com.google.android.material:material:1.7.0")
    implementation("androidx.gridlayout:gridlayout:1.1.0")
    implementation("androidx.leanback:leanback:")
    implementation("androidx.mediarouter:mediarouter:1.8.1")
    implementation("androidx.palette:palette-ktx:1.0.0")
    implementation("androidx.recyclerview:recyclerview:1.4.0")
    implementation("androidx.annotation:annotation:1.10.0")

    // 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 dla bibliotek, przeszukaj repozytorium Google Maven lub Maven Central.
  4. Zapisz plik build.gradle, a następnie zamknij projekt w IntelliJ. Przejdź do katalogu projektu i usuń katalog .idea oraz wszystkie pliki IML w projekcie.
  5. Uruchom Android Studio i kliknij Plik > Nowy > Importuj projekt.
  6. Znajdź katalog projektu, wybierz plik build.gradle lub build.gradle.kts utworzony, a następnie kliknij OK , aby zaimportować projekt.
  7. Kliknij Utwórz > Utwórz projekt , aby przetestować plik kompilacji, tworząc projekt , i rozwiąż wszelkie znalezione błędy.

Dalsze kroki

Po przeniesieniu projektu do Android Studio dowiedz się więcej o tworzeniu za pomocą Gradle i uruchamianiu aplikacji w Android Studio, czytając artykuł Tworzenie i uruchamianie aplikacji.

W zależności od projektu i przepływu pracy możesz też 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 różne systemy kontroli wersji, w tym Git, Mercurial i Subversion. Inne systemy kontroli wersji można dodawać za pomocą wtyczek.

Jeśli Twoja aplikacja jest już objęta kontrolą źródła, może być konieczne włączenie jej w Android Studio. W menu VCS kliknij Włącz integrację kontroli wersji i wybierz odpowiedni system kontroli wersji.

Jeśli Twoja aplikacja nie jest objęta kontrolą źródła, możesz ją skonfigurować po 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 wykonać 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: możesz też użyć opcji menu Plik > Ustawienia > Kontrola wersji , aby skonfigurować i zmodyfikować kontrolę wersji.

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

Podpisywanie aplikacji

Jeśli wcześniej używano certyfikatu debugowania, może on zostać wykryty podczas importowania. W takim przypadku Android Studio nadal będzie się odwoływać do tego certyfikatu. W przeciwnym razie konfiguracja debugowania używa magazynu kluczy debugowania wygenerowanego przez Android Studio, z użyciem znanego hasła i klucza domyślnego ze znanym hasłem znajdującego się w $HOME/.android/debug.keystore. Rodzaj kompilacji do 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 wersji. Jeśli wcześniej nie zdefiniowano certyfikatu wersji, dodaj konfigurację podpisywania wersji do pliku build.gradle lub build.gradle.kts albo użyj opcji menu Utwórz > Wygeneruj podpisany plik APK , aby otworzyć Kreatora generowania podpisanego pliku APK. Więcej informacji o podpisywaniu aplikacji znajdziesz w artykule Podpisywanie aplikacji.

Dostosowywanie maksymalnego rozmiaru sterty w Android Studio

Domyślnie maksymalny rozmiar sterty w Android Studio wynosi 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 sterty.

Aktualizacje oprogramowania

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

Domyślnie Android Studio automatycznie aktualizuje się po wydaniu nowej stabilnej wersji, ale możesz też częściej aktualizować i otrzymywać wersje Canary lub RC.

Więcej informacji o aktualizowaniu Android Studio i używaniu wersji Canary i RC znajdziesz w artykule Aktualizacje.