Android Developer Codelab

Możesz pomóc w opracowaniu najczęściej instalowanego systemu operacyjnego w historii Ziemi. Tak, jesteś tutaj, aby rozpocząć podróż, aby zostać inżynierem platformy Android.

Chociaż ścieżka jest trudna, my, zespół Androida, staramy się uprościć Twoją podróż w każdym wydaniu. Każdego dnia wprowadzamy ulepszenia poprzez bezpośrednią pracę w projekcie Android Open Source Project (AOSP).

Więc usiądź wygodnie, odpal terminal i stwórzmy historię.

Cele

Misja tego codelab jest dwojaka:

To codelab da ci mały przedsmak tego, jak wygląda przepływ pracy programisty dla inżynierów Androida pracujących na platformie (systemie operacyjnym).
To codelab to funkcja wymuszająca przekazywanie opinii na temat narzędzi, dokumentacji i przepływu pracy programisty Androida, gdy zaczynasz od zera.

Wymagania wstępne

Oto pełna lista wymagań dla tego codelab, pochodząca z wymagań dotyczących programowania platformy ogólnej ( AOSP ).

Aby skorzystać z tego codelab, musisz skonfigurować:

Fizyczna stacja robocza Linux spełniająca wszystkie wymagania publiczne .
Repozytorium i konfiguracja Git wymagane do edytowania bazy kodu systemu Android.

Środowisko

Zwykle użytkownicy tworzą i programują bezpośrednio na stacji roboczej. Ponieważ możesz pracować na różnych terminalach, a wiele używanych poleceń jest specyficznych dla terminala, będziesz musiał ponownie uruchamiać je w każdej sesji terminala. W szczególności obejmują one polecenia source build/envsetup.sh i lunch .

Skonfiguruj stację roboczą

Zainstaluj niezbędne pakiety na stacji roboczej.
Będąc nadal w terminalu, zainstaluj Repo i uzyskaj poświadczenia do wszystkich repozytoriów Git.

Zainicjuj i zsynchronizuj kod

Przejdź do swojego katalogu domowego:
```
cd ~
```
Utwórz w nim lokalny podkatalog roboczy:
```
mkdir aosp
```
Przejdź do katalogu:
```
cd aosp
```
Zainicjuj gałąź główną kodu źródłowego repozytorium AOSP (ustawienie domyślne):
```
repo init -u https://android.googlesource.com/platform/manifest
```
Wprowadź lub zaakceptuj swoje dane logowania Git (imię i nazwisko, adres e-mail).
Zsynchronizuj kod źródłowy:
```
repo sync -j16
```

Początkowe synchronizacje mogą zająć godzinę lub dłużej. Zobacz instrukcje pobierania, aby uzyskać szczegółowe informacje na czas oczekiwania.

Każde pobranie repozytorium jest reprezentowane przez plik manifestu . Możesz mieć więcej niż jedno pobranie repozytorium na raz, o ile istnieją one w różnych katalogach. Ale pamiętaj, że każda płatność i kompilacja wynosi około 300 GB i rośnie, więc ogranicz się do dwóch lub rozbuduj system o dodatkowy dysk.

Wskazówka: aby zwolnić miejsce, usuń katalog oddziału i zacznij od nowa od utworzenia katalogu:

rm -rf aosp2

Zbuduj kod

Aby zbudować Androida, musisz wybrać docelowy typ urządzenia do kompilacji za pomocą polecenia lunch . Cele to permutacje urządzeń, takie jak określony model lub współczynnik kształtu.

Urządzenie docelowe zawarte poniżej, aosp_cf_x86_64_phone-userdebug , umożliwia zbudowanie wirtualnego urządzenia Cuttlefish z systemem Android do testowania bez fizycznego urządzenia.

Aby zamiast tego zbudować i zaktualizować urządzenie fizyczne, wybierz inny cel i postępuj zgodnie z instrukcjami dotyczącymi urządzeń flashujących .

Skonfiguruj środowisko do tworzenia urządzeń z systemem Android, uruchamiając następujące polecenie z katalogu głównego pobierania kodu źródłowego:
```
source build/envsetup.sh
```
Przekaż cel kompilacji do polecenia lunch, na przykład:
```
lunch aosp_cf_x86_64_phone-userdebug
```
Utwórz kod z dowolnego miejsca w kasie za pomocą:
```
m
```

Spodziewaj się, że pierwsza kompilacja zajmie kilka godzin. Kolejne kompilacje zajmują znacznie mniej czasu.

Utwórz instancję Acloud

Acloud to narzędzie wiersza poleceń w AOSP, które pomaga użytkownikom w tworzeniu wirtualnych urządzeń z Androidem, w tym przypadku Cuttlefish.

Jeśli jesteś w tej samej sesji terminala, w której utworzono kod , kontynuuj. W przeciwnym razie ponownie uruchom skrypt envsetup.sh i envsetup.sh samego polecenia lunchu. Następnie:

Utwórz lokalną instancję Acloud za pomocą:

acloud create --local-image --local-instance

Zaakceptuj aktualizacje wymaganych pakietów.
Jeśli zostanie wyświetlony monit, uruchom ponownie stację roboczą, aby wszystkie zmiany odniosły skutek.
Wybierz urządzenie Mątwy.

Powinieneś zostać powitany sesją VNC zawierającą urządzenie z Androidem!

Możesz wchodzić w interakcje z urządzeniem wirtualnym na stacji roboczej za pomocą myszy i klawiatury. Możesz również śledzić aktywność w dziennikach podczas korzystania z urządzenia za pomocą polecenia Android Debug Bridge (adb) logcat :

adb logcat

Dokonaj zmiany

Zaktualizuj kod źródłowy zgodnie z poniższą przykładową listą zmian .

Z katalogu głównego swojego zamówienia ( aosp/ katalog) przejdź do frameworks/native projektu Git:
```
cd frameworks/native
```
Rozpocznij tymczasowy projekt z:
```
repo start <some-name> .
```
Edytuj SurfaceFlinger.cpp aby uwzględnić aktualizacje z listy zmian w następującej lokalizacji:
```
aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
```
Zbuduj kod:
```
m
```

Zaktualizuj kompilację na urządzeniu:

adb root
adb remount
adb sync
adb reboot
acloud reconnect

Powinieneś zobaczyć zmianę koloru na urządzeniu.

Przetestuj swój kod

W tej części codelab przeprowadzimy przykładowy test, który znajduje się w drzewie źródłowym i już kończy się niepowodzeniem. Aby przeprowadzić test lokalnie, użyjemy Atest do przetestowania kodu.

Aby skorzystać z testu:

Biegać:
```
atest DevCodelabTest
```
Test zakończy się niepowodzeniem; teraz naprawmy to! Znajdź kod źródłowy testu zakończonego niepowodzeniem:
```
atest --info android.test.example.devcodelab.DevCodelabTest#testHelloWorld
```

Następnie spójrz w głąb:

platform_testing/tests/example/devcodelab

Aby edytować plik, podaj nazwę testu i zamień rozszerzenie . z / , na przykład:

android.test.example.devcodelab.DevCodelabTest

Staje się:

src/android/test/example/devcodelab/DevCodelabTest.java

Zatem edytuj:

platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java

Zamienić:

Assert.assertTrue(false)

Assert.assertTrue(true)

Uruchom test ponownie, aby sprawdzić, czy naprawiłeś test:
```
atest DevCodelabTest
```

Prześlij swój kod do sprawdzenia

Repo upraszcza korzystanie z Git, łącząc polecenia, takie jak git clone do pracy w wielu repozytoriach (lub projektach) Git jednocześnie.

Zobacz narzędzia kontroli źródła, aby zapoznać się z przeglądami usług Git i Repo oraz linkami do pełnej dokumentacji dotyczącej pracy z kodem źródłowym systemu Android. Zobacz repozytorium AOSP, aby uzyskać pełną listę projektów Git i poszczególnych projektów (ścieżek) dla oddziałów powiązanych z każdym projektem.

Będziesz używać internetowego systemu przeglądania kodu Gerrit dla projektów w Git.

Zakładając, że wprowadziłeś zmiany w frameworks/native projekcie frameworks/native , uruchom następujące polecenia, aby je przesłać:
```
cd frameworks/native
repo start codelab .
git add .
git commit
```
W komunikacie dotyczącym zatwierdzenia wprowadź:
```
Android codelab change
Test: manual atest
```
Prześlij swoją zmianę:
```
repo upload
```

Jeśli ci się uda, zobaczysz komunikat przypominający:

Upload project frameworks/native/ to remote branch master:
  branch codelab ( 1 commit, Wed Aug 7 09:32:33 2019 -0700):
         ff46b36d android codelab change
to https://android-review.googlesource.com/ (y/N)? y
remote: Processing changes: refs: 1, new: 1, done
remote:
remote: SUCCESS
remote:
remote:   https://android-review.googlesource.com/c/platform/frameworks/native/+/1098432 android codelab change [NEW]
remote:
To https://android-review.googlesource.com/platform/frameworks/native
 * [new branch]          codelab -> refs/for/master

Zobacz swoją zmianę w Gerrit

Przejdź do linku wydrukowanego w terminalu przypominającego:

https://android-review.googlesource.com/c/platform/frameworks/native/+/1098432

Na tym kończy się program startowy codelab do programowania platformy Android. Zobacz Przesyłanie poprawek, aby zapoznać się z następnymi krokami, i pozostałą część tej witryny, aby uzyskać szczegółowe informacje na temat tworzenia Androida.

Cofnij zmianę

Zwykle po przetestowaniu i przejrzeniu / zatwierdzeniu należy przesłać swoją zmianę w Gerrit i scalić ją z repozytorium.

Zamiast tego, na potrzeby codelab, przywróć listę zmian, klikając Porzuć w Gerrit.

Następnie porzuć powiązaną tymczasową gałąź w katalogu frameworks / natywnego projektu (lub jego podrzędnych):

repo abandon codelab .

Pamiętaj również, aby cofnąć zmiany w pliku testowym. Ponieważ nie repo start , git commit i repo upload zmiany, możemy jedynie zresetować sam plik, tak jak (zakładając, że jesteś w aosp/platform_testing directory ):

git reset HEAD tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java
git checkout .

W tym momencie gotowe! Dobra robota!

Wezwać pomoc

Jeśli napotkasz błędy podczas tego kodowania, zgłoś je za pomocą łącza opinii o witrynie na dole dowolnej strony. Wyślij pytania do grupy budującej androidy .