Ta strona została przetłumaczona przez Cloud Translation API.

Android Kotlin Fundamentals 01.1: Pierwsze kroki

Ten moduł Codelab jest częścią kursu Android Kotlin Fundamentals. Najwięcej korzyści przyniesie Ci ukończenie wszystkich ćwiczeń w kolejności. Wszystkie ćwiczenia z tego kursu znajdziesz na stronie docelowej kursu Android Kotlin Fundamentals.

Wprowadzenie

W tym laboratorium nauczysz się tworzyć i uruchamiać swoją pierwszą aplikację na Androida, HelloWorld, w emulatorze i na urządzeniu fizycznym. Dowiesz się też, jak wygląda projekt na Androida.

Co warto wiedzieć

Musisz znać ogólny proces tworzenia oprogramowania w przypadku aplikacji zorientowanych obiektowo przy użyciu zintegrowanego środowiska programistycznego (IDE), takiego jak Android Studio.
Musisz mieć co najmniej rok doświadczenia w programowaniu obiektowym, w tym znać Javę i Kotlin.

Czego się nauczysz

Jak utworzyć podstawową aplikację na Androida w Android Studio.
Jak utworzyć projekt na Androida na podstawie szablonu.
Jak znaleźć główne komponenty projektu na Androida.
Jak uruchomić aplikację na Androida w emulatorze lub na urządzeniu fizycznym.

Co zrobisz

Utwórz nowy projekt Androida i domyślną aplikację o nazwie HelloWorld.
Utwórz emulator (urządzenie wirtualne), aby móc uruchamiać aplikację na komputerze.
Uruchom aplikację HelloWorld na urządzeniach wirtualnych i fizycznych.
Zapoznaj się z układem projektu.
Przejrzyj plik AndroidManifest.xml.

Aplikacja HelloWorld wyświetla ciąg znaków „Hello World” na ekranie wirtualnego lub fizycznego urządzenia z Androidem. Oto jak wygląda aplikacja:

W tym zadaniu utworzysz nowy projekt aplikacji, aby sprawdzić, czy Android Studio jest prawidłowo zainstalowany.

Otwórz Android Studio, jeśli nie jest jeszcze otwarte.
W głównym oknie dialogowym Witamy w Android Studio kliknij Rozpocznij nowy projekt Android Studio.
Wyświetli się okno Wybierz projekt . Wybierz Empty Activity (Pusta aktywność), jak pokazano poniżej, i kliknij Next (Dalej).

Activity to pojedyncza, konkretna czynność, którą może wykonać użytkownik. Każda aplikacja musi mieć co najmniej 1 aktywność jako punkt wejścia. Potraktuj tę aktywność jako funkcję main() w innych programach. Działanie ma zwykle powiązany układ, który określa, jak elementy interfejsu użytkownika (UI) są wyświetlane na ekranie. Android Studio udostępnia kilka Activityszablonów, które pomogą Ci zacząć
.
W oknie Skonfiguruj projekt wpisz „HelloWorld” w polu Nazwa.
Zaakceptuj domyślną nazwę android.example.com w polu Domena firmy lub utwórz unikalną domenę firmy. Ta wartość plus nazwa aplikacji to nazwa pakietu aplikacji. Jeśli nie planujesz publikowania aplikacji, zaakceptuj wartość domyślną. Nazwę pakietu aplikacji możesz później zmienić, ale wymaga to dodatkowej pracy.
Sprawdź, czy domyślna lokalizacja zapisu jest miejscem, w którym chcesz przechowywać aplikację. Jeśli nie, zmień lokalizację na preferowany katalog.
Upewnij się, że język to Kotlin.
Upewnij się, że minimalny poziom interfejsu API to API 19: Android 4.4 (KitKat). W momencie pisania tego laboratorium kodowania Android Studio wskazywało, że przy tym poziomie interfejsu API aplikacja będzie działać na około 95, 3% urządzeń.
(Więcej informacji o minimalnych poziomach interfejsu API znajdziesz w dalszej części tego laboratorium kodowania. Aby dowiedzieć się więcej, kliknij Pomóż mi wybrać. Otworzy się okno z informacjami o poziomach interfejsu API.
Zaznacz pole wyboru Używaj artefaktów AndroidX.
Pozostaw wszystkie pozostałe pola wyboru odznaczone i kliknij Zakończ. Jeśli projekt wymaga więcej komponentów dla wybranego docelowego pakietu SDK, Android Studio zainstaluje je automatycznie. Może to zająć trochę czasu. Postępuj zgodnie z instrukcjami i zaakceptuj opcje domyślne.

Android Studio utworzy teraz projekt, co może trochę potrwać. Nie powinno być żadnych błędów. Jeśli pojawią się ostrzeżenia, zignoruj je.

W tym zadaniu zapoznasz się z projektem HelloWorld w Android Studio i poznasz podstawy tworzenia aplikacji w tym środowisku.

Krok 1. Zapoznaj się z panelem Projekt

Jeśli karta Projekt nie jest jeszcze wybrana, kliknij ją. Karta Project znajduje się w kolumnie kart pionowych po lewej stronie okna Android Studio. Otworzy się panel Projekt.
Aby wyświetlić projekt jako standardową hierarchię projektu Androida, w menu u góry okienka Projekt wybierz Android. (Domyślnie jest to Android). Pliki projektu możesz wyświetlać na wiele sposobów, w tym w hierarchii systemu plików. Jednak w przypadku widoku Android praca nad projektem jest łatwiejsza.

Krok 2. Otwórz folder aplikacji

Cały kod i wszystkie zasoby aplikacji znajdują się w folderze app.

W panelu Project > Android (Projekt > Android) rozwiń folder app. W folderze app znajdują się 4 podfoldery: manifests, java, generatedJava i res.
Rozwiń folder java, a potem folder com.example.android.HelloWorld, aby wyświetlić plik Kotlin MainActivity.

Folder java zawiera cały główny kod Kotlin aplikacji na Androida. Kod Kotlin znajduje się w folderze java z przyczyn historycznych. Ta konwencja umożliwia Kotlinowi bezproblemową współpracę z kodem napisanym w języku programowania Java, nawet w tym samym projekcie i aplikacji.

Pliki klas aplikacji znajdują się w 3 podfolderach, jak pokazano na ilustracji powyżej. Folder com.example.hello.helloworld (lub nazwa domeny, którą podano) zawiera wszystkie pliki pakietu aplikacji. W szczególności klasa MainActivity jest głównym punktem wejścia do aplikacji. Więcej informacji o MainActivity znajdziesz w kolejnych ćwiczeniach z programowania. Pozostałe 2 foldery w folderze java są używane do kodu związanego z testowaniem, np. testów jednostkowych.

Zwróć uwagę na folder generatedJava. Ten folder zawiera pliki generowane przez Android Studio podczas kompilowania aplikacji. Nie edytuj niczego w tym folderze, ponieważ zmiany mogą zostać zastąpione podczas ponownego kompilowania aplikacji. Warto jednak znać ten folder, gdy podczas debugowania musisz przejrzeć te pliki.

Krok 3. Przejrzyj folder res

W panelu Project > Android (Projekt > Android) rozwiń folder res.

Folder res zawiera zasoby. Zasoby w Androidzie to statyczne treści używane w aplikacjach. Zasoby obejmują obrazy, ciągi tekstowe, układy ekranu, style i wartości, takie jak kolory szesnastkowe czy standardowe wymiary.

Aplikacje na Androida w jak największym stopniu oddzielają kod Kotlin od zasobów. Dzięki temu łatwiej jest znaleźć wszystkie ciągi tekstowe lub ikony używane w interfejsie aplikacji. Gdy zmienisz jeden z tych plików zasobów, zmiana zostanie zastosowana wszędzie tam, gdzie plik jest używany w aplikacji.
W folderze res rozwiń folder layout, aby wyświetlić plik activity_main.xml.

Twój Activity jest zwykle powiązany z plikiem układu interfejsu, zdefiniowanym jako plik XML w katalogu res/layout. Ten plik układu zwykle ma nazwę odpowiadającą aktywności. W tym przypadku nazwa działania to MainActivity, więc powiązany układ to activity_main.

Krok 4. Przejrzyj folder manifests i plik AndroidManifest.xml

Folder manifests zawiera pliki, które dostarczają systemowi Android podstawowych informacji o aplikacji.

Rozwiń folder manifests i dwukrotnie kliknij AndroidManifest.xml, aby go otworzyć. Plik AndroidManifest.xml zawiera szczegóły, których system Android potrzebuje do uruchomienia aplikacji, w tym informacje o tym, jakie działania są częścią aplikacji.
Zwróć uwagę, że element MainActivity jest używany w elemencie <activity>. Wszystkie Activity w aplikacji muszą być zadeklarowane w manifeście. Oto przykład właściwości MainActivity:

<activity android:name=".MainActivity">
   <intent-filter>
       <action android:name="android.intent.action.MAIN"/>

       <category android:name="android.intent.category.LAUNCHER"/>
   </intent-filter>
</activity>

Zwróć uwagę na element <intent-filter> wewnątrz elementu <activity>. Elementy <action> i <category> w tym filtrze intencji informują Androida, gdzie ma rozpocząć działanie aplikacji, gdy użytkownik kliknie ikonę programu uruchamiającego. Więcej informacji o filtrach intencji znajdziesz w dalszej części tego kursu.

Plik AndroidManifest.xml to również miejsce, w którym definiujesz uprawnienia wymagane przez aplikację. Uprawnienia obejmują możliwość odczytywania kontaktów z telefonu, wysyłania danych przez internet lub uzyskiwania dostępu do sprzętu, takiego jak aparat urządzenia.

Gradle to system automatyzacji kompilacji, który używa języka specyficznego dla domeny do opisywania struktury projektu, konfiguracji i zależności aplikacji. Podczas kompilowania i uruchamiania aplikacji zobaczysz informacje o działającym procesie kompilacji Gradle. Wyświetlane są też informacje o instalowanym pakiecie APK (Android Package Kit). (APK to format pliku pakietu, którego system operacyjny Android używa do rozpowszechniania i instalowania aplikacji mobilnych).

Poznaj system Gradle:

Rozwiń folder Gradle Scripts. W panelu Project > Android ten folder zawiera wszystkie pliki potrzebne systemowi kompilacji.
Znajdź plik build.gradle(Project: HelloWorld).

Ten plik zawiera opcje konfiguracji wspólne dla wszystkich modułów, z których składa się Twój projekt. Każdy projekt Androida Studio zawiera 1 plik kompilacji Gradle najwyższego poziomu. Ten plik definiuje repozytoria i zależności Gradle, które są wspólne dla wszystkich modułów w projekcie.
Znajdź plik build.gradle(Module:app).

Oprócz pliku build.gradle na poziomie projektu każdy moduł ma własny plik build.gradle. Plik build.gradle na poziomie modułu umożliwia skonfigurowanie ustawień kompilacji dla każdego modułu. (Aplikacja HelloWorld ma tylko jeden moduł – moduł samej aplikacji). Ten plik build.gradle jest najczęściej edytowany podczas zmieniania konfiguracji kompilacji na poziomie aplikacji. Na przykład edytujesz ten plik build.gradle, gdy zmieniasz poziom pakietu SDK obsługiwany przez aplikację lub gdy deklarujesz nowe zależności w sekcji dependencies. Więcej informacji o obu tych kwestiach znajdziesz w dalszej części tego kursu.

W tym zadaniu utworzysz urządzenie wirtualne (emulator) za pomocą menedżera urządzenia wirtualnego z Androidem (AVD). Urządzenie wirtualne symuluje konfigurację określonego typu urządzenia z Androidem. Następnie używasz tego wirtualnego urządzenia do uruchamiania aplikacji.

Emulator Androida to niezależna aplikacja, która ma własne wymagania systemowe. Urządzenia wirtualne mogą zajmować dużo miejsca na dysku. W razie problemów zapoznaj się z artykułem Uruchamianie aplikacji na emulatorze Androida.

Krok 1. Utwórz wirtualne urządzenie z Androidem (AVD)

Aby uruchomić emulator na komputerze, musisz utworzyć konfigurację opisującą urządzenie wirtualne.

W Android Studio wybierz Tools > AVD Manager lub kliknij ikonę AVD Manager na pasku narzędzi. Pojawi się okno Your Virtual Devices (Twoje urządzenia wirtualne). Jeśli masz już utworzone urządzenia wirtualne, w oknie dialogowym zobaczysz ich listę (jak na ilustracji poniżej). W przeciwnym razie zobaczysz pustą listę.
W lewym dolnym rogu okna kliknij +Utwórz urządzenie wirtualne. Pojawi się okno Wybierz sprzęt z listą wstępnie skonfigurowanych urządzeń. W przypadku każdego urządzenia tabela zawiera kolumnę z rozmiarem ekranu po przekątnej (Rozmiar), rozdzielczością ekranu w pikselach (Rozdzielczość) i gęstością pikseli (Gęstość).
Wybierz urządzenie, np. Nexus 5x lub Pixel XL, i kliknij Dalej. Pojawi się okno Obraz systemu .
Kliknij kartę Zalecane i wybierz wersję systemu Android, która ma być uruchomiona na urządzeniu wirtualnym (np. Pie).

Po wybraniu obrazu systemu kliknij Dalej. Otworzy się okno Android Virtual Device (AVD). Sprawdź konfigurację i kliknij Zakończ.

Krok 2. Uruchom aplikację na urządzeniu wirtualnym

W tym zadaniu uruchomisz nową aplikację.

W Android Studio wybierz Run > Run app (Uruchom > Uruchom aplikację) lub kliknij ikonę Run (Uruchom) – Uruchom aplikację lub kliknij ikonę Uruchom [ICON HERE] na pasku narzędzi. [IMAGEINFO]: ic_run.png, Android Studio Run icon" style="width: 24.00px" src="img/6c65750f2ce7f651.png"> na pasku narzędzi. Pojawi się okno Wybierz docelowe wdrożenie z ostrzeżeniem, że nie ma dostępnych urządzeń. Ten komunikat ostrzegawczy pojawia się, gdy do komputera deweloperskiego nie jest podłączone urządzenie fizyczne lub gdy nie zostało jeszcze uruchomione urządzenie wirtualne.
W oknie Select Deployment Target (Wybierz docelowe urządzenie wdrożenia) w sekcji Available Virtual Devices (Dostępne urządzenia wirtualne) wybierz utworzone urządzenie wirtualne. Kliknij OK.

Emulator uruchamia się i włącza tak samo jak urządzenie fizyczne. W zależności od szybkości komputera może to trochę potrwać. Aplikacja zostanie skompilowana, a gdy emulator będzie gotowy, Android Studio prześle do niego plik APK aplikacji i go uruchomi.

Aplikacja HelloWorld powinna wyglądać tak, jak na ilustracji poniżej.

W tym zadaniu uruchomisz aplikację na fizycznym urządzeniu mobilnym, takim jak telefon lub tablet (jeśli je masz). Zawsze testuj aplikacje na urządzeniach wirtualnych i fizycznych.

Co jest potrzebne:

urządzenie z Androidem, np. telefon lub tablet;
kabel USB do podłączenia urządzenia z Androidem do komputera przez port USB;
Jeśli używasz systemu Linux lub Windows, konieczne może być wykonanie dodatkowych czynności. Zapoznaj się z dokumentacją Uruchamianie aplikacji na urządzeniu. Konieczne może być też zainstalowanie odpowiedniego sterownika USB na urządzeniu. W przypadku sterowników USB dla systemu Windows zapoznaj się z artykułem Instalowanie sterowników USB OEM.

Krok 1. Włącz debugowanie USB

Aby umożliwić Androidowi Studio komunikację z urządzeniem z Androidem, musisz włączyć debugowanie USB w ustawieniach Opcje programisty na urządzeniu.

W Androidzie 4.2 (Jelly Bean) i nowszych ustawienia Opcje programisty są domyślnie ukryte. Aby wyświetlić opcje programisty i włączyć debugowanie USB:

Na urządzeniu otwórz Ustawienia, wyszukaj Informacje o telefonie, kliknij Informacje o telefonie, a potem 7 razy kliknij Numer kompilacji.
Wróć na poprzednią stronę (Ustawienia / System). Na liście pojawi się pozycja Opcje programisty. Kliknij Opcje programisty.
Wybierz Debugowanie USB.

Krok 2. Uruchom aplikację na urządzeniu z Androidem

Teraz możesz połączyć urządzenie i uruchomić aplikację z Androida Studio.

Podłącz urządzenie z Androidem do komputera deweloperskiego za pomocą kabla USB. Na urządzeniu powinno pojawić się okno dialogowe z prośbą o zezwolenie na debugowanie USB.
Aby zapamiętać ten komputer, wybierz opcję Zawsze zezwalaj. Kliknij OK.
Na pasku narzędzi Android Studio na komputerze kliknij przycisk Uruchom . Otworzy się okno Wybierz miejsce docelowe wdrożenia z listą dostępnych emulatorów i połączonych urządzeń. Powinno być widoczne Twoje urządzenie fizyczne oraz wszystkie emulatory.
Wybierz urządzenie i kliknij OK. Android Studio zainstaluje aplikację na urządzeniu i ją uruchomi.

Rozwiązywanie problemów

Jeśli Android Studio nie rozpoznaje urządzenia, wypróbuj te rozwiązania:

Odłącz kabel USB i podłącz go ponownie.
Uruchom ponownie Android Studio.

Jeśli komputer nadal nie znajduje urządzenia lub wyświetla komunikat „Nieautoryzowane”, wykonaj te czynności:

Odłącz kabel USB.
Na urządzeniu otwórz Opcje programisty w aplikacji Ustawienia.
Kliknij Odwołaj dostęp do debugowania USB.
Ponownie podłącz urządzenie do komputera.
Gdy pojawi się prośba, przyznaj uprawnienia.

Może być konieczne zainstalowanie odpowiedniego sterownika USB dla urządzenia. Zapoznaj się z artykułem Uruchamianie aplikacji na urządzeniu.

Wyzwanie: po skonfigurowaniu środowiska i zapoznaniu się z podstawowym procesem programowania wykonaj te czynności:

Utwórz nowy projekt w Android Studio.
Zmień powitanie „Hello World” na „Happy Birthday to” i imię osoby, która niedawno obchodziła urodziny.

Aby zainstalować Android Studio, otwórz stronę Android Studio i postępuj zgodnie z instrukcjami pobierania i instalacji.
Aby wyświetlić hierarchię Androida aplikacji w panelu Project (Projekt), kliknij kartę Project (Projekt) w kolumnie kart pionowych. Następnie w menu u góry kliknij Android.
Jeśli chcesz dodać do projektu nowe zależności lub zmienić wersje zależności, edytuj plik build.gradle(Module:app).
Cały kod i wszystkie zasoby aplikacji znajdują się w folderach app i res. Folder java zawiera działania, testy i inne komponenty w kodzie źródłowym Kotlin lub Java (lub w obu tych językach). Folder res zawiera zasoby, takie jak układy, ciągi tekstowe i obrazy.
Aby dodać do aplikacji na Androida funkcje, komponenty i uprawnienia, edytuj plik AndroidManifest.xml. Wszystkie komponenty aplikacji, takie jak dodatkowe działania, muszą być zadeklarowane w tym pliku XML.
Aby utworzyć wirtualne urządzenie z Androidem (emulator), na którym będzie można uruchomić aplikację, użyj Menedżera AVD.
Aby uruchomić aplikację na fizycznym urządzeniu z Androidem za pomocą Android Studio, włącz na nim debugowanie USB. Aby to zrobić, otwórz Ustawienia > Informacje o telefonie i kliknij Numer kompilacji 7 razy. Następnie otwórz Ustawienia > Opcje programisty i wybierz Debugowanie USB.

Kurs Udacity:

Tworzenie aplikacji na Androida w języku Kotlin

Dokumentacja Android Studio:

Inne:

W tej sekcji znajdziesz listę możliwych zadań domowych dla uczniów, którzy wykonują ten moduł w ramach kursu prowadzonego przez instruktora. Nauczyciel musi:

W razie potrzeby przypisz pracę domową.
Poinformuj uczniów, jak przesyłać projekty.
Oceń zadania domowe.

Instruktorzy mogą korzystać z tych sugestii w dowolnym zakresie i mogą zadawać inne zadania domowe, które uznają za odpowiednie.

Jeśli wykonujesz ten kurs samodzielnie, możesz użyć tych zadań domowych, aby sprawdzić swoją wiedzę.

Tworzenie i uruchamianie aplikacji

Utwórz nowy projekt na Androida na podstawie pustego szablonu.
Otwórz plik res/strings.xml.
Zmień wartość ciągu app_name na „My Dice Roller”. Ta nazwa pojawi się na pasku tytułu.
Utwórz emulator urządzenia, kierując go na dowolną wersję Androida, i uruchom aplikację. Zwróć uwagę na zmianę tytułu aplikacji.

Odpowiedz na te pytania

Pytanie 1

Jaka jest nazwa pliku układu głównej aktywności?

MainActivity.java
AndroidManifest.xml
activity_main.xml
build.gradle

Pytanie 2

Jaka jest nazwa zasobu tekstowego, który określa nazwę aplikacji?

app_name
xmlns:app
android:name
applicationId

Pytanie 3

Jakiego narzędzia używasz do tworzenia nowego emulatora?

Monitor urządzeń z Androidem
[narzędzie] AVD Manager
SDK Manager
Edytor motywów

Przesyłanie aplikacji do oceny

Sprawdź, czy aplikacja zawiera te elementy:

Activity, na którym wyświetla się „Hello World”.
Pasek tytułu z napisem „Mój symulator rzutu kostką”.

Rozpocznij kolejną lekcję: 1.2. Podstawowa struktura aplikacji

Linki do innych ćwiczeń z tego kursu znajdziesz na stronie docelowej ćwiczeń z podstaw języka Kotlin na Androidzie.