Migracja do Android Studio

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

Jeśli przeprowadzasz migrację z IntelliJ, a Twój projekt korzysta już z Gradle, możesz otworzyć istniejący projekt z Android Studio. Jeśli korzystasz z IntelliJ, ale Twój projekt nie korzysta jeszcze z Gradle, musisz ręcznie przygotować projekt przed zaimportowaniem 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ć przed przejściem do Android Studio.

Organizacja projektu i modułów

Android Studio opiera się na IDE IntelliJ IDEA. Aby zapoznać się z podstawami IDE, takimi jak nawigacja, uzupełnianie kodu i skróty klawiszowe, zobacz Poznaj Android Studio.

Android Studio łączy kod w projekty, które zawierają wszystkie elementy, które definiują aplikację na Androida – od kodu źródłowego aplikacji po kompilacje i testowanie kodu. Projekty otwierają się w oddzielnych oknach Android Studio. Każdy projekt zawiera co najmniej 1 moduł, który pozwala podzielić projekt na osobne jednostki funkcji. 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 scalona 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 Pro) z tego samego projektu.
  • Łatwa konfiguracja kompilacji i łatwe dostosowywanie. Możesz na przykład pobierać nazwy i kody wersji z tagów Git w ramach kompilacji.
  • Gradle można używać w IDE, z wiersza poleceń i z serwerów ciągłej integracji, takich jak Jenkins, dzięki czemu zawsze i wszędzie ta sama kompilacja jest wykorzystywana.

Więcej informacji o używaniu i konfigurowaniu Gradle znajdziesz w artykule o konfigurowaniu 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 dobrze znanych lokalnych bibliotek źródłowych i bibliotek binarnych ze współrzędnymi Maven. Więcej informacji znajdziesz w artykule o deklarowaniu 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 IntelliJ używa narzędzia Maven lub innego systemu kompilacji, musisz skonfigurować go do współpracy z Gradle, zanim będzie można przejść na Android Studio.

Zaimportuj projekt IntelliJ oparty na Gradle

Jeśli w swoim projekcie IntelliJ korzystasz już z Gradle, 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 innego niż Gradle IntelliJ

Jeśli w Twoim projekcie IntelliJ nie jest jeszcze używany system kompilacji Gradle, masz 2 opcje importowania projektu do Android Studio. Zostały one opisane w sekcjach poniżej:

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

Aby przenieść projekt do Android Studio przez utworzenie nowego pustego projektu i skopiowanie plików źródłowych 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 chcesz go utworzyć, a następnie kliknij Dalej.
  3. Wybierz formaty, na których działa Twoja aplikacja, i kliknij Dalej.
  4. Kliknij kolejno Dodaj brak aktywności i Zakończ.
  5. W oknie narzędzia Projekt kliknij strzałkę, aby otworzyć menu widoku, i wybierz widok Projekt, aby wyświetlić i zbadać organizację nowego projektu Android Studio. Więcej informacji o zmienianiu widoków i sposobie tworzenia struktury projektów w Android Studio znajdziesz w artykule Pliki projektów.
  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. Na karcie Właściwości projektu wprowadź niezbędne zmiany (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 wyświetlanymi instrukcjami.
  10. Kliknij OK, aby zapisać zmiany.
  11. Kliknij Kompilacja > Utwórz projekt, aby przetestować kompilację projektu i w razie potrzeby usunąć ewentualne błędy.

Przeprowadź migrację przez utworzenie niestandardowego pliku kompilacji Gradle

Aby przenieść projekt do Android Studio przez utworzenie nowego pliku 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 oddzielnej lokalizacji, ponieważ proces migracji zmienia zawartość projektu.
  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 wymaga, aby projekt był zorganizowany tak, jak pokazano na rys. 1.

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

    W settings.gradle, dla Groovy lub settings.gradle.kts dla skryptu Kotlin ustawiasz repozytoria używane do znajdowania wtyczek i zależności odpowiednio w blokach pluginManagement i dependencyResolutionManagement:

    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: od 31 marca 2021 r. repozytorium JCenter jest dostępne tylko do odczytu. Więcej informacji znajdziesz w artykule o aktualizacji usługi JCenter.

    Wtyczka Androida do obsługi Gradle stosuje do projektu niektóre domyślne zbiory ź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ódłowych do określania lokalizacji konkretnych 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, z których projektów bibliotek korzystasz.

    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{} w pliku kompilacji. System kompilacji będzie obsługiwać te biblioteki za Ciebie, między innymi pobierać je, scalać w zasoby i scalać wpisy 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.13.1'
    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.8.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.13.1")
    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.8.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 w swoich bibliotekach, przeszukaj repozytorium Google Maven lub Maven.
  4. Zapisz plik build.gradle, a następnie zamknij projekt w IntelliJ. Przejdź do katalogu projektu i usuń katalog .idea oraz wszystkie znajdujące się w nim pliki IML.
  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. Kliknij Kompilacja > Utwórz projekt, aby przetestować plik kompilacji przez kompilację projektu i rozwiązać wszelkie znalezione błędy.

Dalsze kroki

Po przeniesieniu projektu do Android Studio więcej informacji o tworzeniu i uruchamianiu aplikacji w Android Studio znajdziesz w artykule 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 zacząć korzystać z Android Studio, przeczytaj artykuł Poznaj Android Studio.

Skonfiguruj kontrolę wersji

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

Jeśli aplikacja jest już kontrolowana nad źródłem, konieczne może być włączenie jej w Android Studio. W menu VCS kliknij Włącz integrację kontroli 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. Za pomocą opcji menu w Android Studio VCS możesz włączyć obsługę VCS w odpowiednim systemie 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. Wybierz w menu system kontroli wersji, który chcesz powiązać z katalogiem głównym projektu, a następnie kliknij OK. W menu VCS znajdziesz teraz różne opcje kontroli wersji zależnie od wybranego systemu.

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

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

Podpisywanie aplikacji

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

Proces importu może również wykryć istniejący certyfikat wersji. 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.

Dostosuj maksymalny rozmiar stosu w Android Studio

Domyślnie rozmiar stosu Android Studio nie może przekraczać 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 do kompilacji i narzędzi SDK. Możesz określić, których wersji chcesz używać w Android Studio.

Domyślnie Android Studio zapewnia automatyczne aktualizacje po opublikowaniu nowej wersji stabilnej. Możesz jednak wybrać częstsze aktualizacje i otrzymywać wersje przedpremierowe lub beta.

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