Android Kotlin Fundamentals 01.1: Pierwsze kroki

Te ćwiczenia są częścią kursu Android Kotlin Fundamentals. Skorzystaj z tego kursu, jeśli będziesz wykonywać kolejno kilka ćwiczeń z programowania. Wszystkie ćwiczenia z kursu są wymienione na stronie docelowej ćwiczeń z programowania na temat Kotlin.

Wstęp

W tym ćwiczeniu z programowania tworzysz i uruchamiasz swoją pierwszą aplikację Android – HelloWorld, w emulatorze i na fizycznym urządzeniu. Dowiedz się też, jak wygląda projekt na Androida.

Co warto wiedzieć

• Omówienie ogólnego procesu programowania aplikacji zorientowanych na obiekty za pomocą IDE (zintegrowanego środowiska programistycznego), takiego jak Android Studio.
• Musisz mieć co najmniej roczne doświadczenie w programowaniu zorientowanym na obiekty, a także mieć przynajmniej doświadczenie w tworzeniu języków Java i Kotlin.

Czego się nauczysz:

• Jak utworzyć podstawową aplikację na Androida w Android Studio
• Jak utworzyć projekt na Androida na podstawie szablonu.
• Znajdowanie głównych komponentów projektu Androida
• Jak uruchomić aplikację na Androida w emulatorze lub na urządzeniu fizycznym.

Co chcesz

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

Aplikacja HelloWorld wyświetli ciąg "Hello World" na ekranie urządzenia wirtualnego lub fizycznego Androida. Aplikacja wygląda tak:

W tym zadaniu utworzysz nowy projekt aplikacji, który ma zweryfikować, czy Android Studio jest prawidłowo zainstalowany.

1. Otwórz aplikację Android Studio, jeśli nie jest jeszcze otwarta.
2. W głównym oknie Witamy w Android Studio kliknij Rozpocznij nowy projekt Android Studio.
   
   
3. Pojawi się okno Wybierz projekt. Wybierz Pusta aktywność, jak pokazano poniżej, i kliknij Dalej.
   
   
   
   Activity to pojedynczy, ukierunkowany element, który użytkownik może zrobić. Każda aplikacja musi mieć co najmniej jedną aktywność jako punkt wejścia. Potraktuj je jako funkcję main() w innych programach. Z aktywnością zwykle jest powiązany układ, który określa sposób wyświetlania elementów interfejsu (UI) na ekranie. Android Studio udostępnia kilka szablonów Activity, które pomogą Ci zacząć.
   
4. W oknie Configure your project (Skonfiguruj projekt) wpisz &Hellot;HelloWorld" w polu Name (Nazwa).
   
   
5. Zaakceptuj domyślną domenę android.example.com w przypadku domeny firmy lub utwórz unikalną domenę firmy. Ta wartość oraz nazwa aplikacji to nazwa jej pakietu. Jeśli nie chcesz publikować aplikacji, zaakceptuj wartość domyślną. Nazwę pakietu aplikacji możesz później zmienić, ale wymaga to dodatkowej pracy.
6. Sprawdź, czy domyślnym miejscem, w którym chcesz przechowywać aplikację, jest Zapisz lokalizację. Jeśli nie, zmień lokalizację na preferowany katalog.
7. Sprawdź, czy Język to Kotlin.
8. Upewnij się, że masz co najmniej API 19: Android 4.4 (KitKat). W momencie programowania ćwiczeń z Androida zaznaczono, że na tym poziomie interfejsu API aplikacja będzie uruchamiana na około 95, 3% urządzeń.
   Więcej informacji o minimalnych poziomach interfejsu API znajdziesz w dalszej części tego ćwiczenia. Aby dowiedzieć się więcej, kliknij Pomóż mi wybrać. Otworzy się okno z informacjami o poziomach interfejsu API.
   
9. Zaznacz pole Użyj artefaktów Androida X.
10. Pozostałe pola wyboru pozostaw niezaznaczone i kliknij Zakończ. Jeśli Twój projekt wymaga więcej komponentów dla wybranego docelowego pakietu SDK, Android Studio zainstaluje je automatycznie, co może chwilę potrwać. Postępuj zgodnie z wyświetlanymi instrukcjami i zaakceptuj opcje domyślne.

Android Studio utworzy projekt, co może zająć trochę czasu. Nie powinny pojawić się żadne błędy. Jeśli zobaczysz jakiekolwiek ostrzeżenia, zignoruj je.

W tym zadaniu poznasz projekt HelloWorld w Android Studio i nauczysz się podstaw programowania w Android Studio.

Krok 1. Przeglądaj panel Projekt

1. Jeśli karta Project (Projekt) nie jest jeszcze wybrana, zaznacz ją. Karta Projekt znajduje się w kolumnie kart pionowych po lewej stronie okna Android Studio. Otworzy się panel Projekt.
   
   
   
2. Aby wyświetlić projekt jako standardową hierarchię projektu na Androida, wybierz Android w menu u góry panelu Projekt. (wersją domyślną jest Android). Pliki projektu możesz wyświetlać na wiele różnych sposobów, w tym po wyświetleniu ich w hierarchii systemu plików. Jednak łatwiej jest pracować nad nim w widoku Androida.
   
   

Uwaga: w ramach tego ćwiczenia i innych będą się one odnosić do panelu projektu, gdy wartość jest ustawiona na Androida jako panel Projekt > Android.

Krok 2. Przeglądaj folder aplikacji

Wszystkie kody i zasoby dotyczące Twojej aplikacji znajdują się w folderze app.

1. W panelu Projekt > Android rozwiń folder aplikacja. W folderze app znajdują się 4 podfoldery: manifests, java, generatedJava i res.
2. Rozwiń folder java, a potem folder com.example.android.HelloWorld, by zobaczyć plik Kotlin MainActivity.
   
   
   
   W folderze java znajduje się cały główny kod Kotlin dla aplikacji na Androida. Z historycznych powodów kod ten jest widoczny w folderze java. Dzięki tej konwencji Kotlin może bezproblemowo współpracować z kodem napisanym w języku Java, nawet w tym samym projekcie i aplikacji.
   
   Pliki zajęć w Twojej aplikacji są zawarte w 3 podfolderach, jak widać na rysunku powyżej. Folder com.example.hello.helloworld (lub określona nazwa domeny) zawiera wszystkie pliki pakietu aplikacji. Szczególną uwagę przychodzi Ci klasa MainActivity. Z następnego ćwiczenia z programowania dowiesz się więcej o MainActivity. Pozostałe dwa foldery w folderze java służą do testowania kodu, np. do testowania jednostkowego.

Uwaga: w systemie plików pliki Kotlin mają rozszerzenie .kt i ikonę K. W widoku projektu Android Studio wyświetla nazwę klasy (MainActivity) bez rozszerzenia.

3. Zwróć uwagę na folder generatedJava. Ten folder zawiera pliki, które Android Studio generuje podczas tworzenia aplikacji. Nie edytuj niczego w tym folderze, bo zmiany mogą zostać zastąpione podczas tworzenia aplikacji. Jednak informacje o tym folderze przydają się, gdy trzeba przeglądać pliki w trakcie debugowania.

Krok 3. Przeglądaj folder res

1. W panelu Projekt > Android rozwiń folder res.
   
   Folder res zawiera zasoby. Zasoby w Androidzie to treści statyczne używane w aplikacjach. Zasoby obejmują obrazy, ciągi tekstowe, układy ekranu, style i wartości takie jak kolory w formacie szesnastkowym lub wymiary standardowe.
   
   Aplikacje na Androida rozdzielają kod i zasoby Kotlin maksymalnie. Znacznie ułatwia to znajdowanie wszystkich ciągów tekstowych lub ikon, które są używane w interfejsie aplikacji. Gdy zmienisz jeden z tych plików, zmiana zostanie zastosowana wszędzie tam, gdzie plik jest używany w aplikacji.
2. W folderze res rozwiń folder layout, by wyświetlić plik activity_main.xml.
   
   
   

Plik Activity jest zwykle powiązany z plikiem układu interfejsu zdefiniowanym w pliku XML w katalogu res/layout. Nazwa tego pliku układu pochodzi zwykle od aktywności. Nazwa aktywności to MainActivity, więc powiązany układ to activity_main.

Krok 4. Przeglądaj folder manifestu i plik AndroidManifest.xml

Folder manifests zawiera pliki, które zawierają podstawowe informacje o aplikacji w systemie Android.

1. Rozwiń folder manifests i kliknij dwukrotnie plik AndroidManifest.xml, aby go otworzyć. Plik AndroidManifest.xml zawiera szczegóły potrzebne aplikacji na Androida do uruchamiania aplikacji, w tym informacje o aktywnościach, które są częścią aplikacji.
   
   
   
2. Pamiętaj, że do elementu <activity> odwołuje się MainActivity. Wszelkie Activity w aplikacji muszą być zadeklarowane w pliku manifestu. Oto przykład elementu MainActivity:

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

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

3. Zwróć uwagę na element <intent-filter> w środku <activity>. Elementy <action> i <category> w tym filtrze intencji wskazują Androida, gdzie należy uruchomić aplikację, gdy użytkownik kliknie ikonę programu uruchamiającego. Więcej informacji o filtrach intencji znajdziesz w ćwiczeniach z programowania.

Plik AndroidManifest.xml także zawiera informacje o uprawnieniach potrzebnych aplikacji. Uprawnienia aplikacji pozwalają jej na odczytywanie kontaktów z telefonu, wysyłanie danych przez internet i korzystanie ze sprzętu, np. aparatu urządzenia.

Gradle to system automatyzacji kompilacji, który używa języka specyficznego dla domeny do opisywania struktury, konfiguracji i zależności zależności aplikacji. Gdy kompilujesz i uruchamiasz aplikację, zobaczysz informacje o uruchomionej kompilacji Gradle. Zobaczysz też informacje o instalowanym pakiecie Android SDK Package (APK). APK to format pliku pakietu używany przez system operacyjny Android na potrzeby dystrybucji i instalowania aplikacji mobilnych.

Zapoznaj się z systemem Gradle:

1. Rozwiń folder Gradle Scripts. W panelu Projekt > Android ten folder zawiera wszystkie pliki potrzebne przez system kompilacji.
   
   
   
2. Poszukaj pliku build.gradle(Project: HelloWorld).
   
   Ten plik zawiera opcje konfiguracji typowe dla wszystkich modułów składających się na Twój projekt. Każdy projekt Android Studio zawiera 1 plik kompilacji Gradle najwyższego poziomu. Ten plik definiuje repozytoria Gradle i zależności, które są wspólne dla wszystkich modułów w projekcie.
3. Odszukaj 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ł – samą aplikację. Ten plik build.gradle jest najczęściej edytowany podczas zmiany konfiguracji kompilacji na poziomie aplikacji. Możesz na przykład edytować ten plik build.gradle, gdy zmienisz poziom pakietu SDK obsługiwany przez Twoją aplikację lub zadeklarujesz nowe zależności w sekcji dependencies. Więcej informacji na ten temat znajdziesz w dalszej części ćwiczeń z programowania.

W tym zadaniu utworzysz urządzenie wirtualne (emulator) za pomocą menedżera urządzeń wirtualnych z Androidem. Urządzenie wirtualne symuluje konfigurację określonego typu urządzenia z Androidem. Następnie używasz go do uruchomienia aplikacji.

Emulator Androida jest niezależną aplikacją i ma własne wymagania systemowe. Urządzenia wirtualne mogą zajmować dużo miejsca na dysku. Jeśli napotkasz jakieś problemy, zobacz Uruchamianie aplikacji w emulatorze Androida.

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

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

1. W Android Studio wybierz Narzędzia > AVD Manager lub kliknij ikonę Menedżer AVD na pasku narzędzi. Pojawi się okno Twoje urządzenia wirtualne. Jeśli masz już utworzone urządzenia wirtualne, wyświetla się okno (jak widać na ilustracji poniżej). W przeciwnym razie wyświetla się pusta lista.
   
   
   
2. Kliknij +Utwórz urządzenie wirtualne w lewym dolnym rogu okna. Pojawi się okno Wybierz sprzęt z listą wstępnie skonfigurowanych urządzeń. Na każdym urządzeniu tabela przedstawia kolumnę o przekątnej ekranu (Rozmiar), rozdzielczość ekranu w pikselach (Rozdzielczość) i gęstość pikseli (Gęstość).
   
   
3. Wybierz urządzenie, na przykład Nexus 5x lub Pixel XL, i kliknij Dalej. Pojawi się okno Obraz systemu.
4. Kliknij kartę Zalecane i wybierz wersję Androida, którą chcesz uruchomić na urządzeniu wirtualnym (np. Pie).
   
   
   

Uwaga: dostępnych jest znacznie więcej wersji Androida niż na karcie Zalecane. Aby je zobaczyć, otwórz karty x86 Obrazów i Inne obrazy.

Obrazy zajmują dużo miejsca na dysku, więc tylko niektóre z nich są częścią oryginalnej instalacji. Jeśli obok obrazu systemu, którego chcesz użyć, znajduje się link Pobierz, oznacza to, że obraz nie jest zainstalowany. Kliknij link, aby rozpocząć pobieranie. Może to zająć dużo czasu. Po zakończeniu pobierania kliknij Zakończ.

5. Po wybraniu obrazu systemu kliknij Dalej. Otworzy się okno Wirtualne urządzenie z Androidem (AVD). Sprawdź konfigurację i kliknij Zakończ.

Krok 2. Uruchom aplikację na urządzeniu wirtualnym

W tym zadaniu uruchomisz nową aplikację.

1. W Android Studio wybierz Uruchom > Uruchom aplikację lub kliknij ikonę Uruchom na pasku narzędzi. Pojawi się okno Wybierz wdrożenie, które wyświetli ostrzeżenie. To ostrzeżenie pojawia się, jeśli nie masz fizycznego urządzenia podłączonego do komputera programisty lub nie uruchomiono jeszcze urządzenia wirtualnego.
2. W oknie Select Deployment Target (Wybierz cel wdrożenia) w sekcji Dostępne urządzenia wirtualne wybierz utworzone przez siebie urządzenie wirtualne. Kliknij OK.
   
   
   
   Emulator uruchomi się i uruchomi, podobnie jak urządzenie fizyczne. W zależności od szybkości komputera ten proces może chwilę potrwać. Aplikacja tworzy aplikację, a gdy emulator jest gotowy, Android Studio przesyła go do emulatora i uruchamia.
   
   Aplikacja HelloWorld powinna być widoczna na ilustracji poniżej.
   
   

W tym zadaniu uruchamiasz aplikację na fizycznym urządzeniu mobilnym, takim jak telefon czy tablet, jeśli masz taką aplikację. Zawsze testuj aplikacje zarówno na urządzeniach wirtualnych, jak i na urządzeniach fizycznych.

Co jest potrzebne:

• Urządzenie z Androidem, np. telefon lub tablet.
• kabla USB do połączenia urządzenia z Androidem z komputerem przez port USB;
• Jeśli używasz systemu Linux lub Windows, może być konieczne wykonanie dodatkowych czynności. Zapoznaj się z dokumentacją Uruchamianie aplikacji na urządzeniach. Może być też konieczne zainstalowanie odpowiedniego sterownika USB dla urządzenia. W przypadku sterowników USB opartych na systemie Windows zobacz Instalowanie sterowników USB USB.

Krok 1. Włącz debugowanie USB

Aby Android Studio mógł komunikować się z Twoim urządzeniem z Androidem, musisz włączyć debugowanie USB w ustawieniach Opcji programisty urządzenia.

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

1. Na urządzeniu otwórz Ustawienia, wyszukaj Informacje o telefonie, kliknij Informacje o telefonie i siedmiokrotnie kliknij Numer kompilacji.
2. Wróć na poprzednią stronę (Ustawienia / System). Na liście pojawią się Opcje programisty. Kliknij Opcje programisty.
3. Kliknij Debugowanie USB.

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

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

1. Podłącz urządzenie z Androidem do komputera używanego kablem USB. Na urządzeniu powinno pojawić się okno z prośbą o zezwolenie na debugowanie USB.
   
   
   
2. Wybierz opcję Zawsze zezwalaj, aby zapamiętać ten komputer. Kliknij OK.
3. Na komputerze kliknij przycisk Uruchom na pasku narzędzi Android Studio. Otworzy się okno Wybierz wdrożenie, w którym znajdziesz listę dostępnych emulatorów i połączonych urządzeń. Urządzenie fizyczne powinno być widoczne wraz z emulatorami.
   
   
   
4. Wybierz urządzenie i kliknij OK. Android Studio zainstaluje aplikację na Twoim urządzeniu i uruchomi ją.

Rozwiązywanie problemów

Jeśli Android Studio nie rozpozna Twojego urządzenia, wykonaj te czynności:

1. Odłącz kabel USB i podłącz go z powrotem.
2. Ponownie uruchom Androida Studio.

Jeśli komputer nadal nie może znaleźć urządzenia lub deklaruje je jako „nieautoryzowane”, wykonaj następujące czynności:

1. Odłącz kabel USB.
2. Na urządzeniu otwórz Opcje programisty w aplikacji Ustawienia.
3. Kliknij Unieważnij autoryzacje debugowania USB.
4. Podłącz urządzenie do komputera.
5. Po wyświetleniu prośby udziel autoryzacji.

Może być konieczne zainstalowanie odpowiedniego sterownika USB dla urządzenia. Zobacz Uruchamianie aplikacji na urządzeniach.

Uwaga: wszystkie testy zabezpieczające logowanie są opcjonalne.

Wyzwanie: po skonfigurowaniu i zapoznaniu się z podstawowym procesem programowania:

1. Utwórz nowy projekt w Android Studio.
2. Zmień „Witaj, świecie” i „Witam” na „Wszystkiego najlepszego z okazji urodzin” i nazwisko osoby, która niedawno miała urodziny.

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

Kurs Udacity:

• Tworzenie aplikacji na Androida razem z Kotlin

Dokumentacja Androida Studio:

• Strona pobierania Androida Studio
• Informacje o wersji Android Studio
• Przedstawiamy Android Studio
• Tworzenie urządzeń wirtualnych i zarządzanie nimi
• Omówienie pliku manifestu aplikacji
• Konfigurowanie kompilacji
• Tworzenie urządzeń wirtualnych i zarządzanie nimi

Inne:

• Strona Gradle
• Strona Wikipedii Gradle

Ta sekcja zawiera listę możliwych zadań domowych dla uczniów, którzy pracują w ramach tego ćwiczenia w ramach kursu prowadzonego przez nauczyciela. To nauczyciel może wykonać te czynności:

• W razie potrzeby przypisz zadanie domowe.
• Poinformuj uczniów, jak przesyłać zadania domowe.
• Oceń projekty domowe.

Nauczyciele mogą wykorzystać te sugestie tak długo, jak chcą lub chcą, i mogą przypisać dowolne zadanie domowe.

Jeśli samodzielnie wykonujesz te ćwiczenia z programowania, możesz sprawdzić swoją wiedzę w tych zadaniach domowych.

Tworzenie i uruchamianie aplikacji

• Utwórz nowy projekt na Androida z pustego szablonu.
• Otwórz plik res/strings.xml.
• Zmień wartość ciągu „app_name” na „Moj kości do gry”. Ta nazwa pojawi się na pasku tytułu.
• Utwórz emulator urządzenia i ustaw jego kierowanie na dowolną wersję Androida oraz uruchom aplikację. Zwróć uwagę na to, jak zmieniła się nazwa aplikacji.

Odpowiedz na te pytania

Pytanie 1

Jaka jest nazwa pliku układu głównego działania?

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

Pytanie 2

Jaka jest nazwa zasobu ciągu znaków, który określa nazwę aplikacji?

• app_name
• xmlns:app
• android:name
• applicationId

Pytanie 3

Za pomocą którego narzędzia utworzysz nowy emulator?

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

Przesyłanie aplikacji do oceny

Upewnij się, że aplikacja zawiera:

• Activity wyświetlający się na ekranie komunikat „Hello World”.
• Pasek tytułu, który brzmi „Moja kościa”.

Rozpocznij następną lekcję: 1.2: podstawowa struktura aplikacji

Linki do innych ćwiczeń z programowania w tym kursie znajdziesz na stronie docelowej z ćwiczeniami z podstaw Androida Kotlin.