Migracja do Android Studio

Migracja projektów do Android Studio wymaga dostosowania się do nowego projektu struktury, systemu kompilacji i 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 używasz IntelliJ, ale Twój projekt nie korzysta jeszcze z Gradle, musisz ręcznie przygotuj projekt przed zaimportowaniem go na Androida Studio. Więcej informacji znajdziesz w artykule Migracja z IntelliJ. .

Podstawy Android Studio

Oto kilka głównych różnic, o których należy pamiętać, przygotowując się do do Android Studio.

Organizacja projektu 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 łączy kod w projekty zawierające wszystkie elementy, które definiują w aplikacji na Androida – od kodu źródłowego aplikacji po kompilowanie konfiguracji i testowanie kodu. Projekty otwierają się w oddzielnych oknach Android Studio. Każdy projekt zawiera co najmniej jeden moduł, który umożliwia podzielenie projektu na dyskretnych jednostek funkcjonalności. Moduły można niezależnie kompilować, testować zdebugowanymi.

Więcej informacji o Android Studio projektów i modułów znajdziesz w artykule Omówienie projektów.

System kompilacji oparty na Gradle

System kompilacji Android Studio opiera się Gradle i korzystanie z plików konfiguracji kompilacji napisane w języku Groovy lub Kotlin, aby można było łatwo rozszerzyć i personalizacji reklam.

Projekty oparte na Gradle oferują ważne funkcje w zakresie programowania na Androida, w tym:

  • Obsługa bibliotek binarnych (AAR). Nie musisz już kopiować biblioteki do własnych projektów. możesz zadeklaruj zależność, a parametr biblioteka jest automatycznie pobierana i scalana z 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 kompilacji i łatwe dostosowywanie. Dla: możesz na przykład pobierać nazwy i kody wersji z tagów Git jako część budowania.
  • Gradle można używać z IDE, z command line i ciągu z serwerami integracji, takimi jak Jenkins, zapewniając wszędzie tę samą kompilację obecnie się znajdujesz.

Więcej informacji o używaniu i konfigurowaniu Gradle znajdziesz w artykule Skonfiguruj kompilację.

Zależności

Zależności bibliotek w Android Studio używają deklaracji zależności Gradle i Zależności Maven dotyczące dobrze znanych lokalnych bibliotek źródłowych i bibliotek binarnych w Maven . Więcej informacji: Zadeklaruj zależności.

Migracja z IntelliJ

Jeśli Twój projekt IntelliJ używa systemu kompilacji Gradle, możesz importowanie projektu bezpośrednio do Android Studio. Jeśli Twój projekt IntelliJ używa Maven lub inny system kompilacji, musisz go skonfigurować do współpracy z Gradle przed migracją do Android Studio.

Zaimportuj projekt IntelliJ oparty na Gradle

Jeśli w swoim projekcie IntelliJ używasz już Gradle, otwórz go w 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 się otworzy w Android Studio.

Importowanie projektu innego niż Gradle IntelliJ

Jeśli Twój projekt IntelliJ nie korzysta jeszcze z systemu kompilacji Gradle, musisz do Androida Studio można wykorzystać dwie opcje, w następujących sekcjach:

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

Aby przenieść projekt do Android Studio przez utworzenie nowego pustego projektu, kopiując pliki źródłowe do nowych katalogów, wykonaj te czynności:

  1. Otwórz Android Studio i kliknij Plik > Nowe > Nowy projekt.
  2. Wpisz nazwę projektu aplikacji i określ lokalizację, w której 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ędzia Projekt kliknij strzałkę, aby otworzyć widok. i wybierz widok Projekt, aby wyświetlić organizacji nowego projektu w Android Studio. Aby dowiedzieć się więcej o zmianie oraz o tym, jak Android Studio tworzy projekty, 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 projektu do odpowiednich lokalizacji w nowej strukturze projektu.
  7. W Android Studio kliknij Plik > Struktura projektu, aby otworzyć Okno Struktura projektu. Upewnij się, że moduł aplikacji jest zaznaczony w w panelu po lewej stronie.
  8. Na karcie Właściwości wprowadź niezbędne zmiany w ustawieniach tagu (np. zmodyfikowanie 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 potem 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ę. w razie potrzeby usunąć nieuregulowane błędy.

Przeprowadź migrację przez utworzenie niestandardowego pliku kompilacji Gradle

Migracja projektu do Android Studio przez utworzenie nowego pliku kompilacji Gradle , aby wskazać istniejące pliki źródłowe, wykonaj te czynności:

  1. Zanim zaczniesz, utwórz kopię zapasową plików projektu w osobnym lokalizacji, ponieważ proces migracji modyfikuje zawartość projektu miejsce.
  2. W katalogu projektu utwórz 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 w sposób pokazany na rysunku 1.

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

    Za settings.gradle, dla Groovy lub settings.gradle.kts dla skryptu Kotlin ustawiasz repozytoria służące do znajdowania wtyczek i zależności w pluginManagement i dependencyResolutionManagement bloki:

    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: 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 domyślne ustawiania źródeł projektu. 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 konkretnego pliku . Jeśli Twój istniejący projekt nie jest zgodny z ustawieniami domyślnymi, możesz przenieś pliki tam, gdzie powinny, albo zmień ustawienia domyślne zestawów źródłowych, aby Gradle wiedziała, gdzie je znaleźć.

    Więcej informacji o konfigurowaniu i dostosowywaniu pliku kompilacji Gradle znajdziesz w artykule Skonfiguruj kompilację.

  3. Następnie określ, z których projektów bibliotek korzystasz.

    Dzięki Gradle możesz nie muszą dodawać tych bibliotek jako projektów kodu źródłowego. Zamiast tego możesz znajdziesz je w bloku dependencies{} w pliku kompilacji. system kompilacji będzie obsługiwać te biblioteki za Ciebie, łącznie z pobieraniem scalania zasobów oraz wpisów manifestu. Poniżej dodaje instrukcje deklaracji dla wielu bibliotek AndroidaX do w bloku dependencies{} 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.2'

    // 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.2")

    // 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 deklaracji dla biblioteki, wyszukaj Google Maven repozytorium lub Maven Centralna.
  4. Zapisz plik build.gradle, a następnie zamknij projekt w IntelliJ. Przejdź do katalogu projektu i usuń plik .idea i wszystkie pliki IML w w projektach AI.
  5. Uruchom Android Studio i kliknij Plik > Nowe > Importuj Projekt.
  6. Znajdź katalog projektu, wybierz build.gradle lub build.gradle.kts utworzony przez Ciebie plik, a potem kliknij OK, aby zaimportować w projektach AI.
  7. Kliknij Kompilacja > Utwórz projekt, aby przetestować plik kompilacji podczas tworzenia projektu i eliminować ewentualne 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 procesu możesz też dowiedzieć się więcej o: kontrolę wersji, zarządzanie zależnościami i konfigurowanie Android Studio. Aby uzyskać zaczęło korzystać z Android Studio, 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 dodawać za pomocą wtyczek.

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

Jeśli aplikacja nie podlega kontroli źródła, możesz ją skonfigurować po zaimportowaniu do Android Studio. Użyj opcji menu VCS w Android Studio, aby włączyć obsługa VCS dla odpowiedniego systemu kontroli wersji, tworzenie repozytorium, importowanie nowych plików do kontroli wersji oraz kontrolować inne wersje, operacje:

  1. W menu VCS Android Studio kliknij Włącz integrację z systemem kontroli wersji.
  2. Wybierz system kontroli wersji, który chcesz powiązać z katalogiem głównym projektu i kliknij OK. W menu VCS znajdziesz teraz opcje kontroli wersji na podstawie wybranego systemu.

Uwaga: możesz też użyć menu Plik > Ustawienia > Opcja menu „Kontrola wersji” w menu do konfigurowania i modyfikowania 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 tym przypadku Android Studio nadal wspomina o tym, certyfikat. W przeciwnym razie konfiguracja debugowania będzie wykorzystywać plik wygenerowany w narzędziu Android Studio. magazyn kluczy debugowania przy użyciu znanego hasła i klucza domyślnego o znanym Hasło jest w języku: $HOME/.android/debug.keystore. Ustawiono typ kompilacji do debugowania aby automatycznie używać tej konfiguracji debugowania podczas uruchamiania lub debugowania projektu w Android Studio.

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

Dostosuj maksymalny rozmiar stosu w Android Studio

Domyślnie rozmiar stosu Android Studio nie może przekraczać 1280 MB. Jeśli jesteś pracujesz nad dużym projektem lub system ma dużo pamięci RAM, wydajność przez zwiększenie maksymalnego stosu rozmiar.

Aktualizacje oprogramowania

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

Domyślnie Android Studio zapewnia automatyczne aktualizacje za każdym razem, gdy pojawi się nowa stabilna wersja jest już dostępna, ale możesz ją aktualizować częściej, wersji testowej lub beta.

Więcej informacji o aktualizowaniu Android Studio oraz korzystaniu z wersji przedpremierowej i beta wersji, przeczytaj o aktualizacjach.