Migracja do Android Studio

Przeniesienie projektów do Android Studio wymaga dostosowania się do nowej struktury projektu, systemu kompilacji i funkcji 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 Androida Studio. Więcej informacji znajdziesz w sekcji Migracja z IntelliJ.

Podstawy Android Studio

Oto kilka najważniejszych różnic, o których warto pamiętać podczas przygotowywania się do przejścia na Androida Studio.

Organizacja projektu i modułu

Android Studio jest oparte na środowisku IDE 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 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 funkcjonalne. Moduły można kompilować, testować i debugować niezależnie.

Więcej informacji o projektach i modułach Android Studio znajdziesz w omówieniu projektów.

System kompilacji oparty na Gradle

System kompilacji Androida 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. w czasie kompilacji.
• Obsługa wariantów kompilacji, które umożliwiają tworzenie różnych wersji aplikacji (np. bezpłatnej i pro) w ramach 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 IDE, z wiersza poleceń i na serwerach ciągłej integracji, takich jak Jenkins. Zapewnia to takie samo kompilowanie w każdym miejscu 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 dotyczące bibliotek w Android Studio korzystają z deklaracji zależności Gradle i zależności Maven w przypadku 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 Twój projekt IntelliJ korzysta z Mavena lub innego systemu kompilacji, musisz go skonfigurować do współpracy z Gradle, zanim przeprowadzisz migrację do Androida 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. Projekt otworzy się w Android Studio.

Importowanie projektu IntelliJ bez Gradle

Jeśli Twój projekt IntelliJ nie korzysta jeszcze z systemu kompilacji Gradle, masz 2 możliwości zaimportowania go do Androida Studio. Opisujemy je w kolejnych sekcjach:

• 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 Migracja przez utworzenie nowego pustego projektu.
• Utwórz nowy plik kompilacji Gradle dla projektu, a następnie zaimportuj projekt i nowy plik kompilacji do Android Studio. Więcej informacji znajdziesz w sekcji Migracja przez utworzenie niestandardowego pliku kompilacji Gradle.

Migracja przez utworzenie nowego pustego projektu

Aby przenieść projekt do Android Studio, utwórz nowy pusty projekt i skopiuj pliki źródłowe do nowych katalogów:

1. Otwórz Android Studio i kliknij File > New > New Project (Plik > Nowy > Nowy projekt).
2. Wpisz nazwę projektu aplikacji i określ lokalizację, w której ma zostać utworzony, a potem 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 kliknij Finish (Zakończ).
5. W oknie narzędziowym Project (Projekt) kliknij strzałkę, aby otworzyć menu widoku, i wybierz widok Project (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 sekcji 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 File > Project Structure (Plik > Struktura projektu), aby otworzyć okno dialogowe Project Structure (Struktura projektu). Sprawdź, czy 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 Dependencies (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. Aby zapisać zmiany, kliknij OK.
11. Kliknij Build > Make Project (Skompiluj > Utwórz projekt), aby przetestować kompilację projektu, i w razie potrzeby rozwiąż wszelkie błędy.

Przenoszenie 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 potrzebne Gradle do uruchomienia kompilacji.

   Domyślnie Android Studio oczekuje, że projekt będzie zorganizowany tak, jak pokazano na rysunku 1.

   

   W settings.gradle w przypadku skryptu 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:

   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 zostało przełączone w tryb tylko do odczytu. Więcej informacji znajdziesz w tym artykule.

   Wtyczka Androida do obsługi Gradle stosuje do projektu niektóre domyślne zbiory ź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 zbiorów źródeł do określania lokalizacji określonych typów plików. Jeśli istniejący projekt nie jest zgodny z ustawieniami domyślnymi, możesz przenieść pliki do odpowiednich lokalizacji lub zmienić domyślne zbiory źródeł, aby Gradle wiedział, gdzie ich szukać.

   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 z kodem źródłowym. Zamiast tego możesz się do nich odwoływać w bloku dependencies{} w pliku kompilacji. System kompilacji zajmuje się tymi bibliotekami, w tym pobieraniem bibliotek, scalaniem zasobów i scalaniem wpisów w pliku manifestu. Poniższy przykład dodaje instrukcje deklaracji dla kilku bibliotek AndroidX do bloku dependencies{} w pliku kompilacji.

   Groovy

   ...
   dependencies {
       implementation fileTree(dir: 'libs', include: ['*.jar'])
   
       // AndroidX libraries
       implementation 'androidx.core:core-ktx:1.16.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.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.16.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.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 określić prawidłowe deklaracje dla swoich bibliotek, wyszukaj je w 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 File > New > Import Project (Plik > Nowy > Zaimportuj projekt).
6. Znajdź katalog projektu, wybierz utworzony plik build.gradle lub build.gradle.kts, a następnie kliknij OK, aby zaimportować projekt.
7. Kliknij Build > Make Project (Kompilacja > Utwórz projekt), aby przetestować plik kompilacji, kompilując projekt, i rozwiązać znalezione błędy.

Dalsze kroki

Po przeprowadzeniu migracji projektu do Android Studio dowiedz się więcej o kompilowaniu za pomocą Gradle i uruchamianiu aplikacji w Android Studio, czytając artykuł Kompilowanie i uruchamianie aplikacji.

W zależności od projektu i przepływu pracy możesz też potrzebować więcej informacji o kontroli wersji, zarządzaniu zależnościami i konfigurowaniu Androida 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 dodać 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 Enable Version Control Integration (Włącz integrację z systemem kontroli wersji) i wybierz odpowiedni system kontroli wersji.

Jeśli aplikacja nie jest objęta kontrolą źródła, możesz ją skonfigurować po zaimportowaniu do Androida 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 Enable Version Control Integration (Włącz integrację z systemem kontroli wersji).
2. Wybierz z menu 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 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 pracy z kontrolą wersji znajdziesz w dokumentacji IntelliJ na temat kontroli wersji.

Podpisywanie aplikacji

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

Dostosowywanie maksymalnego rozmiaru sterty 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 jest aktualizowany niezależnie od wtyczki Gradle, narzędzi do kompilacji i narzędzi SDK. Możesz określić, których wersji chcesz używać w Androidzie Studio.

Domyślnie Android Studio automatycznie aktualizuje się, gdy tylko pojawi się nowa stabilna wersja, ale możesz też aktualizować się częściej i otrzymywać wersje podglądowe lub beta.

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