Migracja do Android Studio

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

Jeśli przeprowadzasz migrację z IntelliJ, a Twój projekt używa już Gradle, możesz otworzyć istniejący projekt z poziomu Android Studio. Jeśli korzystasz z 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ć, przygotowując się do migracji do Android Studio.

Organizacja projektów i modułów

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

Android Studio porządkuje kod w projekty, które zawierają wszystko, co definiuje Twoją aplikację na Androida – od kodu źródłowego aplikacji po konfiguracje i testowanie kodu. Projekty otwierają się w osobnych oknach w Android Studio. Każdy projekt zawiera 1 lub więcej modułów, co pozwala Ci podzielić projekt na odrębne jednostki funkcji. Moduły można niezależnie tworzyć, testować i debugować.

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 wykorzystuje pliki konfiguracyjne kompilacji napisane w skrypcie Groovy lub Kotlin, co ułatwia rozszerzanie i dostosowywanie.

Projekty oparte na Gradle oferują ważne funkcje związane z programowaniem Androida, w tym:

• Obsługa bibliotek binarnych (AAR). Nie musisz już kopiować źródeł bibliotek do własnych projektów. Możesz zadeklarować zależność, a biblioteka zostanie automatycznie pobrana i scalona z projektem. Obejmuje to automatyczne scalanie zasobów, wpisów w pliku manifestu, reguł wykluczania ProGuard, niestandardowych reguł lint itp.
• Obsługa wariantów kompilacji, które umożliwiają tworzenie różnych wersji aplikacji (np. wersji bezpłatnej i pro) z tego samego projektu.
• Łatwa konfiguracja kompilacji i jej dostosowywanie. Na przykład w ramach kompilacji możesz pobierać nazwy i kody wersji z tagów Git.
• Gradle można używać z poziomu IDE, wiersza poleceń oraz z serwerów ciągłej integracji, takich jak Jenkins, zapewniając tę samą kompilację za każdym razem.

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 do znanych lokalnych bibliotek źródłowych i binarnych ze współrzędnymi Maven. Więcej informacji znajdziesz w sekcji Deklarowanie zależności.

Migracja z IntelliJ

Jeśli Twój projekt IntelliJ korzysta z systemu kompilacji Gradle, możesz go zaimportować bezpośrednio do Android Studio. Jeśli w projekcie IntelliJ korzystasz z Maven lub innego systemu kompilacji, musisz go skonfigurować do pracy z Gradle, zanim przeprowadzisz migrację do Android Studio.

Importowanie projektu IntelliJ opartego na Gradle

Jeśli korzystasz już z 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. 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 do wyboru 2 opcje importowania projektu do Android Studio. Opisaliśmy je w sekcjach poniżej:

• Utwórz nowy pusty projekt Android Studio i skopiuj istniejący kod źródłowy do katalogów powiązanych z nowym projektem. Więcej informacji znajdziesz w sekcji o migracji przez utworzenie nowego pustego projektu.
• Utwórz nowy plik kompilacji Gradle dla swojego projektu, a potem zaimportuj projekt i nowy plik kompilacji do Android Studio. Więcej informacji znajdziesz w sekcji dotyczącej migracji przez utworzenie niestandardowego pliku kompilacji Gradle.

Migruj, tworząc 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 ma zostać utworzony, a następnie kliknij Dalej.
3. Wybierz formaty, na których działa Twoja aplikacja, a potem kliknij Dalej.
4. Kliknij Add No Activity (Dodaj brak aktywności), a następnie Finish (Zakończ).
5. W oknie narzędzia Projekt kliknij strzałkę, aby otworzyć menu widoku, i wybierz widok Projekt, aby wyświetlić i przeanalizować organizację nowego projektu Android Studio. Więcej informacji o zmienianiu widoków i o strukturze projektów w Android Studio znajdziesz w artykule o plikach 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. Sprawdź, czy moduł aplikacji jest wybrany w panelu po lewej stronie.
8. Wprowadź niezbędne zmiany na karcie Właściwości projektu (np. zmień 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 , wybierz typ zależności, którą chcesz dodać, i postępuj zgodnie z instrukcjami.
10. Aby zapisać zmiany, kliknij OK.
11. Kliknij Utwórz > Utwórz projekt, aby przetestować tworzenie projektu i w razie potrzeby naprawić ewentualne błędy.

Przeprowadź migrację, tworząc niestandardowy plik kompilacji Gradle

Aby przenieść projekt do Android Studio przez utworzenie nowego pliku kompilacji Gradle wskazującego 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 zmieni zmienioną 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 oczekuje, że projekt jest uporządkowany, jak na ilustracji 1.

   

   W settings.gradle dla Groovy lub settings.gradle.kts ustawiasz repozytoria, które będą używane do wyszukiwania wtyczek i zależności w blokach pluginManagement i dependencyResolutionManagement:

   Odlotowy

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

   Wtyczka Androida do obsługi Gradle stosuje w projekcie niektóre domyślne zbiory źródłowe. Te zbiory źródłowe określają 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 miejsce, w którym powinny się znajdować, lub zmienić domyślne zestawy źródeł, aby Gradle wiedziała, gdzie je znaleźć.

   Więcej informacji o konfigurowaniu i dostosowywaniu pliku kompilacji Gradle znajdziesz w artykule o konfigurowaniu 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. Możesz odwoływać się do nich w bloku dependencies{} pliku kompilacji. System kompilacji zajmie się tymi bibliotekami za Ciebie, w tym pobieranie bibliotek, scalanie zasobów i scalanie wpisów w pliku manifestu. Poniższy przykład dodaje instrukcje deklaracji dla wielu bibliotek AndroidX do bloku dependencies{} pliku kompilacji.

   Odlotowy

   ...
   dependencies {
       implementation fileTree(dir: 'libs', include: ['*.jar'])
   
       // AndroidX libraries
       implementation 'androidx.core:core-ktx:1.13.0'
       implementation 'androidx.appcompat:appcompat:1.6.1'
       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.7.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.13.0")
       implementation("androidx.appcompat:appcompat:1.6.1")
       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.7.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 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 utworzony przez siebie plik build.gradle lub build.gradle.kts i kliknij OK, aby zaimportować projekt.
7. Kliknij Kompilacja > Utwórz projekt, aby przetestować plik kompilacji przez skompilowanie projektu i poprawić znalezione błędy.

Dalsze kroki

Po przeniesieniu projektu do Android Studio przeczytaj artykuł Tworzenie i uruchamianie aplikacji, aby dowiedzieć się więcej o tworzeniu aplikacji za pomocą Gradle i uruchamianiu aplikacji w Android Studio.

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ż pod kontrolą źródła, być może trzeba będzie włączyć ją w Android Studio. W menu VCS kliknij Enable Version Control Integration (Włącz integrację kontroli wersji) i wybierz odpowiedni system kontroli wersji.

Jeśli Twoja aplikacja nie jest pod kontrolą źródła, możesz ją skonfigurować po zaimportowaniu jej do Android Studio. Korzystając z opcji menu Android Studio VCS, możesz włączyć obsługę VCS w wybranym systemie kontroli wersji, utworzyć repozytorium, zaimportować nowe pliki do kontroli wersji i wykonać inne operacje związane z kontrolą wersji:

1. W menu Android Studio VCS 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 zobaczysz teraz kilka opcji zarządzania wersją w zależności od wybranego systemu.

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

Więcej informacji o kontroli wersji znajdziesz w dokumentacji dotyczącej kontroli wersji firmy IntelliJ.

Podpisywanie aplikacji

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

Podobnie proces importowania może wykryć istniejący certyfikat wersji. Jeśli wcześniej nie zdefiniowano żadnego certyfikatu wersji, 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 podpisanego pliku APK. Więcej informacji o podpisywaniu aplikacji znajdziesz w artykule Podpisywanie aplikacji.

Dostosuj maksymalny rozmiar sterty w Android Studio

Domyślnie maksymalny rozmiar sterty 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 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 każdym opublikowaniu nowej stabilnej wersji. Możesz jednak zdecydować się na częstsze aktualizacje i otrzymywać ich wersje poglądowe lub beta.

Więcej informacji o aktualizowaniu Androida Studio i korzystaniu z wersji testowej i beta znajdziesz w artykule o aktualizacjach.