6G- AI
Część 1: Metaheurystyczny protokół optymalizacji płomienia ćmy, energooszczędny protokół klastrowania dla sieci bezzałogowych statków powietrznych obsługujących technologię 6G
W proponowanej pracy autor przedstawia metaheurystyczny algorytm optymalizacji płomienia ćmy dla techniki energooszczędnego klastrowania (MMFO-EEC) dla sieci bezzałogowych statków powietrznych (UAV) z obsługą 6G. Główną intencją techniki MMFO-EEC jest sprawny wybór głowic klastrów (CH) i organizacji klastrów w sieciach 6GenabledUAV. Przedstawiona technika MMFO-EEC wykorzystuje głównie algorytm MFO do skutecznego wybierania odpowiednich UAV jako kanałów CH w sieci.
Część 2 : Nowatorskie przenoszenie danych za pomocą głębokiego uczenia się Model wykrywania cyberataków na potrzeby przetwarzania brzegowego w sieciach 6G
Omówiono nowatorski model odciążania danych z wykorzystaniem głębokiego uczenia się i wykrywania cyberataków (DADL-CAD) na potrzeby przetwarzania brzegowego w sieciach 6G. Proponowana technika DADL-CAD projektuje przede wszystkim model rekurencyjnej sieci neuronowej (RNN) do prognozowania przepływu ruchu w sieciach 6G obsługujących przetwarzanie brzegowe. Walidacja wydajności techniki DADL-CAD jest badana pod różnymi względami, a badanie porównawcze wykazało wyższość techniki DADL-CAD nad najnowszymi podejściami.
Część 3: Optymalizacja rozpuszczalności gazu Henry′ego za pomocą głębokiego uczenia się. Włączone prognozowanie przepływu ruchu w sieciach pojazdów z obsługą 6G
Autor rozwija nowatorską optymalizację rozpuszczalności gazu Henry′ego za pomocą techniki prognozowania przepływu ruchu z wykorzystaniem głębokiego uczenia się (HSGODL-TFF) dla sieci kołowych obsługujących 6G. Zaprezentowana technika HSGODLTFF ma przede wszystkim na celu prognozowanie poziomu ruchu w sieci VANET z obsługą 6G. Algorytm HSGO można zastosować do optymalnej modyfikacji hiperparametrów (takich jak szybkość uczenia się, liczba epok i wielkość partii) modelu DBN, poprawiając w ten sposób wydajność prognozowania. Walidację eksperymentalną modelu HSGODL-TFF przeprowadza się na danych testowych, a wyniki sprawdza się pod kilkoma względami.
Część 4: Metoda kwantyzacji wektorowej oparta na algorytmie Crow Search do kompresji obrazu w przemysłowym środowisku Internetu rzeczy z obsługą 6G
Przedstawiono nowatorskie podejście do kwantyzacji wektorowej oparte na algorytmie wyszukiwania wron, służące do kompresji obrazu w środowisku IIoT z obsługą 6G, zwane modelem CSAVQ-ICIIoT. Proponowany model CSAVQICIIoT ma na celu osiągnięcie efektywnej kompresji obrazu poprzez optymalizację procesu konstruowania książki kodowej na platformie IIoT obsługującej 6G. Technika CSAVQ-ICIIoT obejmuje technikę Linde - Buzo - Graya (LBG) z techniką kwantyzacji wektorowej (VQ) do kompresji obrazu.
Część 5: Projektowanie Optymalizatora Dingo obsługującego sztuczną inteligencję ds. Zarządzania Energią w Sieciach Komunikacyjnych 6G
Przedstawiono optymalizator dingo obsługujący sztuczną inteligencję do zarządzania energią (AIDO-EM) w sieciach 6G. Głównym celem prezentowanej techniki AIDO-EM jest minimalizacja zużycia energii i maksymalizacja żywotności urządzeń IoT obsługujących technologię 6G. Aby to osiągnąć, zastosowano nowy algorytm optymalizacji dingo (DOA) dla routingu z obsługą klastra, aby osiągnąć efektywną dystrybucję danych pomiędzy urządzeniami i wybrać efektywne głowice bram (GWH).
Część 6 : Adaptacyjna optymalizacja wielorybów z możliwością głębokiego uczenia się Sieć RefineDet do wspomagania widzenia w sieciach 6G
Tu omówiono adaptacyjną optymalizację wielorybów z siecią RefineDet z włączoną funkcją głębokiego uczenia (AWO-DLRDN) do wspomagania widzenia w sieciach 6G. Głównym założeniem techniki AWO-DLRDN jest określenie znajdujących się w pobliżu obiektów i ich przybliżonej odległości od osób niewidomych. Proponowana technika AWO-DLRDN podlega przede wszystkim procesowi powiększania danych i adnotacji obrazu jako etapowi wstępnego przetwarzania. Walidacja wydajności techniki AWO-DLRDN została przeprowadzona eksperymentalnie przy użyciu wzorcowego zbioru danych, a badanie porównawcze wykazało ulepszenia techniki AWODLRDN w porównaniu z innymi technikami.
Cześć 7 : Efektywna optymalizacja polowań na jelenie metodą wykrywania widma oparta na algorytmie w sieciach komunikacyjnych 6G
Zaproponowano nowatorskie, wydajne podejście do optymalizacji polowań na jelenie oparte na algorytmie wykrywania widma (EDHO-SSA) dla sieci komunikacyjnych 6G. Zaprezentowana technika EDHO-SSA ma na celu głównie zarządzanie dostępnością widm występujących w sieciach 6G. Technika EDHO-SSA opiera się na łowickim charakterze jeleniowatych. Wyprowadza również funkcję celu określającą wydajność SS, w tym różne parametry, takie jak energia i przepustowość. Przeprowadzono analizę wyników eksperymentów techniki EDHO-SSA i ocenę wyników w odniesieniu do różnych miar.
Cześć 8: Elitarny, opozycyjny program Igrzysk Śmierci oparty na optymalizacji wyszukiwania, oparty na współpracy schemat wykrywania widma dla kognitywnych sieci radiowych 6G
W proponowanej pracy omówiono schemat elitarnego, opozycyjnego igrzysk głodowych, oparty na optymalizacji wyszukiwania w oparciu o wspólne wykrywanie widma (EOHGSO-CSS) dla kognitywnych sieci radiowych 6G (CRN). Technika EOHGSO-CSS ma na celu głównie efektywną alokację widma w sieciach CRN 6G. Proces SS można przeprowadzić przy użyciu różnych parametrów, takich jak zakłócenia, czas wykrywania, wartość progowa, energia, przepustowość i alokacja mocy. Poza tym algorytm EOHSGO powstał w wyniku integracji elitarnego uczenia się opartego na opozycji (EOBL) z tradycyjnym algorytmem HGSO w celu poprawy jego wydajności.
Android 13
Pierwsze kroki z umiejętnościami programowania nowoczesnych systemów Android
System operacyjny Android (OS) to jedna z najpopularniejszych platform dla urządzeń mobilnych, z której korzysta wielu użytkowników na całym świecie. System operacyjny jest używany w samochodach i urządzeniach do noszenia, takich jak inteligentne zegarki, telewizory i telefony, co sprawia, że rynek jest dość szeroki dla programistów Androida. Dlatego nowi programiści muszą nauczyć się tworzyć aplikacje na Androida z wykorzystaniem nowych umiejętności w zakresie nowoczesnego programowania na Androidzie (MAD). Android przeszedł długą drogę od czasu jego premiery w 2008 roku i użycia go w pierwszych zintegrowanych środowiskach programistycznych (IDE), Eclipse i NetBeans. Obecnie zalecanym środowiskiem programistycznym dla systemu Android jest Android Studio. W odróżnieniu od wcześniejszych wersji, gdy preferowanym językiem była Java, obecnie preferowanym językiem jest Kotlin. Android Studio obsługuje Kotlin, Java, C++ i inne języki programowania, dzięki czemu to środowisko IDE jest odpowiednie dla programistów o różnych umiejętnościach. Dlatego pod koniec tego rozdziału, postępując zgodnie z przepisami, będziesz miał zainstalowane Android Studio, zbudujesz swoją pierwszą aplikację na Androida przy użyciu Jetpack Compose i nauczysz się składni Kotlina, wykorzystując preferowany język do programowania Androida. Ponadto to wprowadzenie przygotuje dla Ciebie podstawę do zrozumienia zaawansowanego materiału, który będzie kluczowy dla MAD. W tej części omówimy następujące przepisy:
• Napisanie pierwszego programu w Kotlinie z wykorzystaniem zmiennych i idiomów
• Tworzenie aplikacji Hello, Android Community przy użyciu Android Studio
• Konfigurowanie emulatora w Android Studio
• Tworzenie przycisku w Jetpack Compose
• Używanie poleceń gradlew do czyszczenia i uruchamiania projektu w Android Studio
• Zrozumienie struktury projektu Android
• Debugowanie i logowanie w Android Studio
Wymagania techniczne
Pomyślne uruchomienie Androida IDE i emulatora może być trudne dla Twojego komputera. Być może słyszeliście dowcip o tym, jak maszyny z Androidem Studio mogą służyć zimą jako grzejniki. Cóż, jest w tym trochę prawdy, więc twój komputer powinien mieć następujące specyfikacje, aby mieć pewność, że twój system poradzi sobie z wymaganiami IDE:
• Zainstalowany 64-bitowy system Microsoft Windows, macOS lub Linux i stabilne połączenie internetowe. Przepisy zostały opracowane w systemie macOS. Możesz także używać laptopa z systemem Windows lub Linux, ponieważ nie ma różnicy między używaniem obu.
• Użytkownicy systemów Windows i Linux mogą kliknąć ten link, aby zainstalować Android Studio: https://developer.android.com/studio/install.
• Minimum 8 GB pamięci RAM lub więcej.
• Minimum 8 GB wolnego miejsca na dysku dla Android Studio, zestawu Android Software Development Kit (SDK) i emulatora Androida.
• Preferowana jest minimalna rozdzielczość ekranu 1280 x 800.
• Możesz pobrać Android Studio pod adresem https://developer.android.com/studio
Napisanie pierwszego programu w Kotlinie z wykorzystaniem zmiennych i idiomów
Kotlin jest zalecanym językiem do programowania na Androidzie; nadal możesz używać języka Java jako wybranego języka, ponieważ wiele starszych aplikacji w dalszym ciągu w dużym stopniu opiera się na języku Java. Jednakże będziemy używać Kotlina i jeśli po raz pierwszy tworzysz aplikacje na Androida przy użyciu języka Kotlin, organizacja Kotlin ma doskonałe zasoby, które pomogą Ci rozpocząć od bezpłatnych ćwiczeń praktycznych i samodzielnych ocen zwanych Kotlin Koany (https://play.kotlinlang.org/koans/overview). Ponadto możesz używać języka Kotlin do programowania wieloplatformowego za pomocą Kotlin Multiplatform Mobile (KMM), w którym możesz udostępniać standardowy kod między aplikacjami na iOS i Androida oraz pisać kod specyficzny dla platformy tylko tam, gdzie jest to konieczne. KMM jest obecnie w fazie Alpha.
Przygotowywanie się
W tym przepisie możesz użyć internetowego placu zabaw Kotlin (https://play.kotlinlang.org/), aby uruchomić swój kod, lub uruchomić kod w swoim środowisku IDE Android Studio. Alternatywnie możesz pobrać i używać IntelliJ IDEA IDE, jeśli planujesz wykonywać więcej pytań praktycznych dotyczących Kotlina za pomocą Koans.
Jak to zrobić…
W tym przepisie będziemy eksplorować i modyfikować prosty program, który napiszemy w Kotlinie; możesz pomyśleć o programie jako o instrukcjach, które wydajemy komputerowi lub urządzeniom mobilnym, aby wykonywał określone przez nas czynności. Na przykład utworzymy powitanie w naszym programie, a później napiszemy inny program. W przypadku tego przepisu możesz wybrać Android Studio lub darmowe IDE online, ponieważ omówimy niektóre funkcjonalności Kotlina:
1. Jeśli po raz pierwszy zdecydujesz się skorzystać z internetowego placu zabaw Kotlin, zobaczysz zrzut ekranu podobny do poniższego, z instrukcją println, która mówi Witaj, świecie, ale w naszym przykładzie zmienimy to powitanie na Witaj, społeczność Androida i uruchom kod.
2. Spójrzmy na inny przykład; popularny problem algorytmu stosowany w wywiadach - odwracanie ciągu znaków. Na przykład masz ciąg Społeczność i chcemy odwrócić ciąg, tak aby wynikiem było ytinummoC. Istnieje kilka sposobów rozwiązania tego problemu, ale rozwiążemy go za pomocą idiomatycznego sposobu Kotlina.
3. Wprowadź następujący kod na placu zabaw swojego IDE lub na placu zabaw Kotlina:
fun main() {
val stringToBeReversed = "Community"
println(reverseString(stringToBeReversed))
}
fun reverseString(stringToReverse: String): String {
return stringToReverse.reversed()
}
Jak to działa…
W Kotlinie należy koniecznie wspomnieć, że istnieją unikalne sposoby na utrzymanie czystszego, bardziej precyzyjnego i prostszego kodu poprzez wykorzystanie domyślnej wartości parametru i ustawienie tylko tych parametrów, które chcesz zmienić. zabawa to słowo w języku programowania Kotlin oznaczające funkcję, a funkcja w języku Kotlin to sekcja programu, która wykonuje określone zadanie. Nazwa funkcji w naszym pierwszym przykładzie to main(), a w naszej funkcji main() nie mamy żadnych danych wejściowych. Ogólnie rzecz biorąc, funkcje mają nazwy, abyśmy mogli je od siebie odróżnić, jeśli nasza baza kodu jest złożona. Ponadto w Javie funkcja jest podobna do metody. Nazwa funkcji składa się z dwóch nawiasów i nawiasów klamrowych oraz funkcji println, która informuje system o wydrukowaniu wiersza tekstu. Jeśli korzystałeś z języka Java, możesz zauważyć, że język programowania Kotlin jest bardzo podobny do języka Java. Jednak programiści mówią teraz o tym, jak wspaniały jest język Kotlin dla programistów, ponieważ zapewnia bardziej wyrazistą składnię i wyrafinowane systemy typów oraz radzi sobie z problemem wskaźnika zerowego, z którym Java borykała się przez wiele lat. Aby w pełni wykorzystać możliwości języka Kotlin i napisać bardziej zwięzły kod, korzystna może być znajomość idiomów Kotlina. Idiomy Kotlina to często używane kolekcje, które pomagają manipulować danymi i ułatwiają pracę programistów Androida. W naszym drugim przykładzie mamy dwie funkcje: main() i ReverseString(). main() nie pobiera żadnych danych wejściowych, ale ReverseString() pobiera dane wejściowe typu String. Zauważysz również, że używamy val, które jest unikalnym słowem używanym przez Kotlina w odniesieniu do niezmiennej wartości, którą można ustawić tylko na jedną wartość, w porównaniu do var, który jest zmienną zmienną, co oznacza, że można z niej zrezygnować. Tworzymy wartość stringToBeReversed, która jest ciągiem znaków i nazywamy ją "Społeczność", następnie wywołujemy println w funkcji main() i przekazujemy tekst, który chcemy wydrukować, w naszej funkcji ReversingString(). Co więcej, w tym przykładzie nasza funkcja ReverseString pobiera argument typu string z obiektu String, a następnie zwraca typ ciągu.
Jest jeszcze wiele do nauczenia się i należy przyznać, że to, co omówiliśmy w tym przepisie, to tylko niewielka część tego, co można zrobić z idiomami Kotlina. Ten przepis miał na celu wprowadzenie koncepcji, które moglibyśmy poruszyć lub wykorzystać w późniejszych rozdziałach, jednak nie było to szczegółowe, ponieważ w późniejszych rozdziałach przyjrzymy się bliżej Kotlinowi. Dlatego warto wiedzieć, czym są idiomy Kotlina i dlaczego są obecnie niezbędne.
Tworzenie aplikacji Hello, Android Community przy użyciu Android Studio
Pierwszą aplikację na Androida stworzymy teraz, gdy mamy zainstalowane Android Studio. Ponadto użyjemy funkcji Compose - żeby wspomnieć z góry, w tym przepisie nie będziemy szczegółowo omawiać funkcji Compose, ponieważ mamy poświęcony jej Część
Przygotowywanie się
Zanim zaczniesz, warto wiedzieć, gdzie znajdują się Twoje projekty na Androida, aby zachować spójność. Domyślnie Android Studio tworzy pakiet w Twoim katalogu domowym, a nazwa pakietu to AndroidStudioProjects; tutaj znajdziesz wszystkie projekty, które tworzysz. Możesz także zdecydować, gdzie powinien znajdować się folder, jeśli chcesz go zmienić. Ponadto upewnij się, że używasz najnowszej wersji Android Studio, aby móc korzystać ze wszystkich wspaniałych funkcji. Aby dowiedzieć się, jaka jest najnowsza wersja Androida, możesz skorzystać z poniższego linku: https://developer.android.com/studio/releases.
Jak to zrobić…
W Android Studio IDE szablon projektu to aplikacja na Androida, która zawiera wszystkie niezbędne części do utworzenia aplikacji i pomaga w rozpoczęciu i konfiguracji. Zatem krok po kroku stworzymy naszą pierwszą aplikację na Androida i uruchomimy ją na emulatorze:
1. Uruchom Android Studio, klikając ikonę Android Studio w swoim doku lub w dowolnym miejscu, w którym zapisałeś Android Studio.
2. Otworzy się powitalne okno Android Studio, w którym możesz kliknąć Nowy projekt. Alternatywnie możesz przejść do Plik i kliknąć Nowy projekt.
3. Wybierz opcję Opróżnij czynność tworzenia i kliknij Dalej.
4. Po załadowaniu pustego ekranu aktywności tworzenia zobaczysz pola zawierające nazwę, nazwę pakietu, lokalizację zapisu, język i minimalny pakiet SDK. Na nasze potrzeby możesz nazwać projekt Android Community i pozostawić pozostałe ustawienia bez zmian. Zauważysz również, że domyślnym językiem jest Kotlin. Jeśli chodzi o Minimum SDK, naszym celem jest API 21: Android 5.0 (Lollipop), które wskazuje minimalną wersję Androida, na której może działać Twoja aplikacja, czyli w naszym przypadku około 98,8% urządzeń. Możesz także kliknąć menu rozwijane i dowiedzieć się więcej o minimalnym pakiecie SDK. Kliknij Zakończ i poczekaj, aż Gradle się zsynchronizuje.
5. Śmiało, pobaw się pakietami, a zauważysz klasę MainActivity, która rozszerza metodę ComponentActivity(), która rozszerza Activity(); wewnątrz mamy zabawę w onCreate, która jest nadpisaniem z ComponentActivity. Zobaczysz także setContent{}, która jest funkcją używaną do ustawiania zawartości funkcji Composable. Funkcja setContent{} pobiera wyrażenie lambda zawierające elementy interfejsu użytkownika, które powinny zostać wyświetlone i w naszym przypadku przechowuje motyw naszej aplikacji. W funkcji Powitanie() zmienimy to, co jest zapewnione i dodamy własne powitanie, czyli "Hello, Android Community" i uruchommy, i utworzymy nasze pierwsze powitanie:
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?)
{
super.onCreate(savedInstanceState)
setContent {
AndroidCommunityTheme {
Surface(
modifier = Modifier.fillMaxSize(),
color =
MaterialTheme.colors.background
) {
Greeting("Hello, Android
Community")
}
}
}
}
}
6. Przejdźmy dalej i zmodyfikujmy funkcję Greeting() i przypiszmy argument name do tekstu:
@Composable
fun Greeting(name: String) {
Text(
text = name
)
}
Ponadto możesz po prostu przekazać "Hello, Android Community" do domyślnej implementacji, co spowoduje utworzenie tego samego interfejsu użytkownika.
7. Podobnie jak w widoku XML, możesz łatwo przeglądać tworzony interfejs użytkownika bez uruchamiania aplikacji w emulatorze, używając @Preview(showBackground = true), więc przejdźmy dalej i dodajmy to do naszego kodu, jeśli nie jest on dostępny. Domyślnie projekt zawiera szablon z funkcją Preview():
a Preview():
@Preview(showBackground = true)
@Composable
fun DefaultPreview() {
}
8. Na koniec po uruchomieniu aplikacji powinien pojawić się ekran jak na rysunku. W poniższym przepisie przyjrzymy się, jak krok po kroku skonfigurować emulator, więc nie martw się tym jeszcze.
Jak to działa…
Kluczową zaletą korzystania z Jetpack Compose do tworzenia widoku jest to, że przyspiesza czas programowania, ponieważ używasz tego samego języka do pisania całej bazy kodu (Kotlin) i łatwiej jest go testować. Możesz także tworzyć komponenty wielokrotnego użytku, które możesz dostosować do swoich potrzeb. Dlatego zapewnienie mniejszego ryzyka błędów i konieczność pisania widoków w formacie XML, ponieważ jest to żmudne i kłopotliwe. Funkcja onCreate() jest uważana za punkt wejścia do aplikacji w systemie Android. Ponadto używamy funkcji modyfikujących, aby dodać zachowanie i ozdobić komponowany. O tym, co potrafią modyfikatory i funkcje Surface, porozmawiamy więcej w następnej części.
Konfigurowanie emulatora w Android Studio
Android Studio to niezawodne i dojrzałe IDE. W rezultacie Android Studio jest preferowanym IDE do tworzenia aplikacji na Androida od 2014 roku. Oczywiście nadal możesz używać innych IDE, ale zaletą Android Studio jest to, że nie musisz instalować osobno pakietu Android SDK.
Przygotowywanie się
Aby móc zastosować się do tego przepisu, musisz wykonać poprzedni przepis, ponieważ będziemy konfigurować nasz emulator w celu uruchomienia właśnie utworzonego projektu.
Jak to zrobić…
Ta część ma być przyjazna dla początkujących, a także płynnie przejść do bardziej zaawansowanego Androida w miarę pracy z przepisami. Wykonajmy następujące kroki, aby zobaczyć, jak skonfigurować emulator i uruchomić projekt w przepisie Tworzenie aplikacji społecznościowej Hello, Android przy użyciu Android Studio:
1. Przejdź do Narzędzia | Menadżer urządzeń. Gdy menedżer urządzeń będzie gotowy, masz dwie opcje: wirtualną lub fizyczną. Wirtualny oznacza, że będziesz używać emulatora, a Fizyczny oznacza, że umożliwisz swojemu telefonowi z Androidem debugowanie aplikacji na Androida. Dla naszych celów wybierzemy Wirtualny.
2. Kliknij opcję Utwórz urządzenie. Pojawi się ekran konfiguracji urządzenia wirtualnego.
3. Wybierz telefon. Zauważysz, że Android Studio ma inne kategorie, takie jak telewizor, Wear OS, tablet i motoryzacja. Na razie użyjmy Phone′a, a w następnym rozdziale spróbujemy użyć Wear OS. Kliknij Dalej.
4. Na rysunku zobaczysz listę zalecanych obrazów systemów. Możesz wybrać dowolny lub użyć domyślnego, czyli S w naszym przypadku dla Androida 12, chociaż możesz chcieć użyć najnowszego API 33, a następnie kliknąć Dalej
5. Dojdziesz teraz do ekranu urządzenia wirtualnego Android (AVD), na którym możesz nadać nazwę swojemu urządzeniu wirtualnemu. Możesz wprowadzić nazwę lub po prostu pozostawić domyślną nazwę Pixel 2 API 31, a następnie nacisnąć Zakończ.
6. Przetestuj swoje urządzenie wirtualne, uruchamiając je i upewnij się, że działa zgodnie z oczekiwaniami. Po uruchomieniu aplikacji na emulatorze powinieneś zobaczyć coś podobnego do rysunku.
Ważna uwaga
Aby utworzyć fizyczne urządzenie testujące, przejdź do Ustawień na swoim telefonie z Androidem i wybierz Informacje o telefonie | Informacje o oprogramowaniu | Numer kompilacji i puszczaj przycisk, przytrzymaj go, aż zobaczysz, że dzielą Cię teraz cztery kroki od zostania programistą. Po zakończeniu zliczania zobaczysz powiadomienie z informacją, że opcje programisty zostały pomyślnie włączone. Wszystko, czego teraz potrzebujesz, to użyć uniwersalnej magistrali szeregowej (USB) i włączyć debugowanie USB. Wreszcie zobaczysz, że Twój telefon fizyczny jest gotowy do testów.
Jak to działa…
Testowanie i upewnianie się, że aplikacje wyświetlają oczekiwany wynik, jest bardzo ważne. Dlatego Android Studio używa emulatora, aby pomóc programistom zapewnić działanie aplikacji tak, jak na standardowych urządzeniach. Co więcej, telefony z Androidem są wyposażone w opcję programistyczną gotową do użycia przez programistów, co jeszcze bardziej ułatwia obsługę różnej liczby urządzeń obsługiwanych przez Androida, a także pomaga w odtwarzaniu błędów, które trudno znaleźć w emulatorach.
Tworzenie przycisku w Jetpack Compose
Musimy pamiętać, że nie możemy uwzględnić wszystkich poglądów w jednym przepisie; mamy rozdział poświęcony lepszemu poznaniu Jetpack Compose, więc w stworzonym przez nas projekcie spróbujemy po prostu stworzyć jeszcze dwa dodatkowe widoki dla naszego projektu.
Przygotowywanie się
Otwórz projekt społeczności Androida, ponieważ na nim będziemy opierać się w tym przepisie.
Jak to zrobć…
Zacznijmy od zaimplementowania prostego przycisku w Compose:
1. Przejdźmy dalej i uporządkujmy nasz kod i wyrównajmy tekst do środka, dodając funkcję Column(), aby uporządkować nasze widoki. Należy to dodać do funkcji setContent{}:
Column(
modifier = Modifier
.fillMaxSize()
.wrapContentSize(Alignment.Center),
horizontalAlignment = Alignment.CenterHorizontally
) {
Greeting("Hello, Android Community")
}
}
2. Teraz utwórz funkcję i nazwij ją SampleButton; w tym przykładzie niczego nie przekażemy. Będziemy jednak mieli RowScope{}, który definiuje funkcje modyfikujące mające zastosowanie w tym przypadku do naszego przycisku i nadamy naszemu przyciskowi nazwę: kliknij mnie.
3. Podczas tworzenia przycisku w aplikacji Compose możesz ustawić jego kształt, ikonę i wysokość, sprawdzić, czy jest on włączony, sprawdzić jego zawartość i nie tylko. Możesz sprawdzić, jak dostosować swój przycisk, klikając z wciśniętym klawiszem Command komponent Button():
@Composable
fun SampleButton() {
Button(
onClick = { /*TODO*/ },
modifier = Modifier
.fillMaxWidth()
.padding(24.dp),
shape = RoundedCornerShape(20.dp),
border = BorderStroke(2.dp, Color.Blue),
colors = ButtonDefaults.buttonColors(
contentColor = Color.Gray,
backgroundColor = Color.White
)
) {
Text(
text = stringResource(id =
R.string.click_me),
fontSize = 14.sp,
modifier = Modifier.padding(horizontal =
30.dp, vertical = 6.dp)
)
}
}
W naszym SampleButton onClick nie robi nic; nasz przycisk ma modyfikator maksymalnej szerokości wypełnienia, wypełnienie 24 pikselami niezależnymi od gęstości (dp) i zaokrąglone rogi o promieniu 20 dp. Ustawiliśmy także kolor przycisku i dodaliśmy opcję "kliknij mnie" jako tekst. Ustawiliśmy rozmiar czcionki na 14 pikseli niezależnych od skali (sp), ponieważ pomaga to zapewnić, że tekst będzie dobrze dopasowany zarówno do ekranu, jak i preferencji użytkownika.
4. Kliknij także opcję Podziel w prawym górnym rogu, aby wyświetlić podgląd elementów ekranu, lub możesz kliknąć sekcję Projekt, aby wyświetlić cały ekran bez kodu.
5. Na koniec wywołajmy naszą funkcję SampleButton, w której znajduje się funkcja Powitanie, i uruchommy aplikację:
Column(
modifier = Modifier
.fillMaxSize()
.wrapContentSize(Alignment.Center),
horizontalAlignment = Alignment.CenterHorizontally
) {
Greeting("Hello, Android Community")
SampleButton()
}
6. Skompiluj i uruchom program; Twoja aplikacja powinna wyglądać podobnie do rysunku
Jak to działa…
Aplikacja Composable składa się z kilku funkcji, które można komponować, czyli zwykłych funkcji opatrzonych adnotacją @Composable. Jak wyjaśnia dokumentacja Google, adnotacja informuje funkcję Compose o konieczności dodania wyjątkowej obsługi procedury aktualizacji i konserwacji interfejsu użytkownika w miarę upływu czasu. Funkcja Compose umożliwia także uporządkowanie kodu w małe, łatwe w utrzymaniu fragmenty, które można dostosowywać i ponownie wykorzystywać w dowolnym momencie.
Wykorzystanie poleceń gradlew do czyszczenia i uruchamiania projektu w Android Studio
Polecenie gradlew to solidne opakowanie Gradle, które ma doskonałe zastosowanie. Jednak w Android Studio nie trzeba go instalować, ponieważ jest to skrypt dostarczany w pakiecie z projektem.
Przygotowywanie się
Na razie jednak nie będziemy przyglądać się wszystkim poleceniom Gradle, zamiast tego użyjemy tych najpopularniejszych do czyszczenia, budowania, dostarczania informacji, debugowania i skanowania naszego projektu w celu znalezienia wszelkich problemów podczas uruchamiania naszej aplikacji. Możesz uruchamiać polecenia na terminalu swojego laptopa, o ile jesteś w odpowiednim katalogu lub korzystasz z terminala dostarczonego przez Android Studio.
Jak to zrobić…
Wykonaj poniższe kroki, aby sprawdzić i potwierdzić, czy Gradle działa zgodnie z oczekiwaniami:
1. Możesz sprawdzić wersję, po prostu uruchamiając ./gradlew.
2. Aby zbudować i wyczyścić projekt, możesz uruchomić polecenia ./gradlew clean i ./gradlew build. Jeśli coś jest nie tak z Twoim projektem, kompilacja zakończy się niepowodzeniem i będziesz mógł zbadać błąd. Ponadto w systemie Android zawsze możesz uruchomić projekt bez użycia poleceń Gradle i po prostu skorzystać z opcji uruchamiania i czyszczenia IDE.
3. Poniżej znajduje się kilka bardziej przydatnych poleceń gradlew; na przykład, jeśli kompilacja nie powiedzie się i chcesz wiedzieć, co poszło nie tak, użyj poleceń, aby to sprawdzić, lub kliknij komunikat o błędzie:
• Uruchom z opcją --stacktrace, aby uzyskać ślad stosu
• Uruchom z opcją --info lub --debug, aby uzyskać więcej danych wyjściowych dziennika
• Uruchom z --scan, aby uzyskać pełny wgląd
Jak to działa
Gradle to narzędzie do kompilacji ogólnego przeznaczenia, które okazuje się bardzo przydatne w programowaniu Androida. Ponadto możesz tworzyć i publikować własne wtyczki, aby hermetyzować swoje konwencje i budować funkcjonalność. Zalety Gradle obejmują kompilację przyrostową do wykonywania testów, kompilacji i wszelkich innych zadań wykonywanych w systemie kompilacji.
Zrozumienie struktury projektu Android
Jeśli po raz pierwszy przeglądasz folder projektu Androida, możesz zastanawiać się, gdzie dodać swój kod i co oznaczają pakiety. W tym przepisie omówiono, co zawiera każdy folder i jaki kod trafia gdzie.
Przygotowywanie się
Jeśli otworzysz swój projekt, zauważysz wiele folderów. Główne foldery w Twoim projekcie na Androida są wymienione tutaj:
• Folder manifestu
• Folder Java (test/androidTest)
• Folder Zasoby Res
• Skrypty stopniowe
Jak to zrobić …
Przejrzyjmy każdy folder, dowiadując się, co, gdzie i dlaczego jest przechowywane:
1. Na rysunku możesz zobaczyć listę rozwijaną Pakiety; kliknij to, a pojawi się okno z projektem, pakietami, plikami projektu i innymi elementami.
2. Możesz wyświetlić swój projekt przy użyciu logo Androida, poprzez Projekt lub podświetloną sekcję Projekt obok menu rozwijanego. Widok Projekt jest najlepszy, gdy w aplikacji znajduje się wiele modułów i chcesz dodać konkretny kod. Kliknij sekcje i zobacz, co zawierają.
3. Folder manifestu jest źródłem prawdy dla aplikacji na Androida; zawiera plik AndroidManifest.xml. Kliknij wewnątrz pliku, a zauważysz, że masz program uruchamiający, który uruchamia aplikację na Androida na twoim emulatorze.
4. Ponadto numer wersji jest zwykle ustawiany w Gradle, a następnie łączony z manifestem, a w manifeście dodajemy wszystkie potrzebne uprawnienia. Zauważysz także nazwę pakietu, metadane, zasady ekstrakcji danych, motyw i ikonę; jeśli masz unikalną ikonę, możesz ją tutaj dodać.
5. Folder java zawiera wszystkie pliki Kotlin (.kt) i Java (.java), które tworzymy podczas tworzenia naszych aplikacji na Androida. Na przykład na rysunku mamy pakiet z (androidTest) i (test) i tutaj dodajemy nasze testy. Śmiało, kliknij wszystkie foldery i zobacz, co zawierają
6. W folderze androidTest piszemy nasze testy UI w celu przetestowania funkcjonalności UI, a w folderze test piszemy nasz test jednostkowy. Testy jednostkowe testują małe fragmenty naszego kodu, aby upewnić się, że wymagane zachowanie jest zgodne z oczekiwaniami. Rozwój oparty na testach (TDD) jest doskonały i cenny podczas tworzenia aplikacji. Niektóre firmy przestrzegają tej zasady, inne jednak jej nie egzekwują. Jednakże jest to świetna umiejętność, ponieważ dobrą praktyką jest zawsze testowanie kodu. Folder res zawiera układy XML, ciągi znaków interfejsu użytkownika, obrazy do rysowania i ikony Mipmap. Z drugiej strony folder wartości zawiera wiele przydatnych plików XML, takich jak wymiary, kolory i motywy. Śmiało, kliknij folder res, aby zapoznać się z tym, co tam jest, ponieważ będziemy go używać w następnej części.
Ważna uwaga: jeśli nie budujesz nowego projektu od zera, wiele aplikacji nadal korzysta z układów XML, a programiści decydują się teraz na opracowywanie nowych ekranów za pomocą Jetpack Compose jako udoskonalenia. Dlatego może być konieczne utrzymanie lub wiedza, jak pisać widoki w formacie XML.
7. Na koniec w Gradle Scripts zobaczysz pliki definiujące konfigurację kompilacji, którą możemy zastosować w naszych modułach. Na przykład w build.gradle (Project: AndroidCommunity) zobaczysz plik najwyższego poziomu, w którym możesz dodać opcje konfiguracyjne wspólne dla wszystkich modułów podprojektu.
Jak to działa…
W Android Studio niewiedza, gdzie trafiają pliki i co jest najważniejsze, może być przytłaczająca dla początkujących użytkowników. Dlatego posiadanie przewodnika krok po kroku pokazującego, gdzie dodać testy lub kod, a także zrozumienie struktury projektu Androida jest niezbędne. Ponadto w złożonych projektach możesz znaleźć różne moduły; dlatego pomocne jest zrozumienie struktury projektu. Moduł w Android Studio to zbiór plików źródłowych i ustawień kompilacji, które pozwalają podzielić projekt na odrębne jednostki o określonych celach.
Debugowanie i logowanie w Android Studio
Debugowanie i rejestrowanie mają kluczowe znaczenie w rozwoju Androida. Możesz pisać komunikaty dziennika, które pojawiają się w Logcat, aby pomóc Ci znaleźć problemy w kodzie lub sprawdzić, czy fragment kodu wykonuje się wtedy, gdy powinien. Wprowadzimy ten temat tutaj, ale niesprawiedliwe będzie stwierdzenie, że omówimy to wszystko w jednym przepisie.
Przygotowywanie się
Aby zrozumieć rejestrowanie, użyjmy przykładu. Poniższe metody dziennika są wymienione od najwyższego do najniższego priorytetu. Są one odpowiednie podczas rejestrowania błędów sieciowych, powołań i innych błędów:
• Log.e(): błąd dziennika
• Log.w(): Ostrzeżenie dotyczące dziennika
• Log.i(): Informacje dziennika
• Log.d(): Debugowanie pokazuje programistom krytyczne komunikaty, najczęściej używany dziennik
• Log.v(): szczegółowe
Dobrą praktyką jest powiązanie każdego dziennika z TAGiem, aby szybko zidentyfikować komunikat o błędzie w Logcat. "TAG" oznacza etykietę tekstową, którą można przypisać do widoku lub innego elementu interfejsu użytkownika w aplikacji na Androida. Głównym celem używania tagów w systemie Android jest umożliwienie powiązania dodatkowych informacji lub metadanych z elementem interfejsu użytkownika.
Jak to zrobić…
Przejdźmy dalej i dodajmy komunikat dziennika do naszego małego projektu:
1. Przejdźmy dalej i utworzymy dziennik debugowania, a następnie uruchomimy aplikację:
Log.d(TAG, "asdf Połączenie testowe")
W sekcji Logcat w polu wyszukiwania wpisz asdf i sprawdź, czy możesz znaleźć wiadomość. Zauważysz, że dziennik ma nazwę klasy, nasz TAG (MainActivity) i wyświetlony komunikat dziennika; zobacz strzałkę w prawo na rysunku .
2. Strzałka w lewo pokazuje wymienione typy logów, a korzystając z rozwijanego menu, możesz szybko wyświetlić wiadomość w oparciu o specyfikację.
Jak to działa…
Debugowanie polega na umieszczeniu punktów przerwania w klasach, spowolnieniu emulatora i próbie znalezienia problemów w kodzie. Debugowanie jest bardzo przydatne, jeśli na przykład napotkasz w kodzie sytuację wyścigu lub jeśli kod działa na niektórych urządzeniach, a nie na innych. Dodatkowo, aby skorzystać z debugowania należy najpierw podłączyć do emulatora debuger, a następnie uruchomić w trybie debugowania. Z drugiej strony rejestrowanie pomaga rejestrować informacje, które mogą być pomocne w przypadku napotkania problemów. Czasami debugowanie może być trudne, ale umieszczenie dzienników w kodzie tam, gdzie jest to potrzebne, może być bardzo pomocne. Praktycznym przypadkiem jest ładowanie danych z interfejsu API; możesz chcieć zapisać to w przypadku wystąpienia błędu sieci, aby poinformować Cię, co się stanie, jeśli połączenie sieciowe nie powiedzie się. Dlatego debugowanie przy użyciu punktów przerwania może pomóc spowolnić proces oceny wartości
Tworzenie ekranów przy użyciu deklaratywnego interfejsu użytkownika i odkrywanie zasad tworzenia
Aplikacje mobilne wymagają interfejsu użytkownika (UI) do interakcji użytkownika. Na przykład stary sposób tworzenia interfejsu użytkownika był niezbędny w systemie Android. Oznaczało to posiadanie osobnego prototypu interfejsu użytkownika aplikacji przy użyciu unikalnych układów Extensible Markup Language (XML), a nie tego samego języka, który był używany do budowania logiki. Jednak w przypadku Modern Android Development istnieje potrzeba zaprzestania programowania imperatywnego i rozpoczęcia korzystania z deklaratywnego sposobu tworzenia interfejsu użytkownika, co oznacza, że programiści projektują interfejs użytkownika na podstawie otrzymanych danych. Ten paradygmat projektowania wykorzystuje jeden język programowania do stworzenia całej aplikacji. Trzeba przyznać, że nowym programistom może wydawać się trudno zdecydować, czego się nauczyć podczas tworzenia interfejsu użytkownika: starego sposobu tworzenia widoków czy wybrania nowego Jetpack Compose. Załóżmy jednak, że stworzyłeś aplikację na Androida przed erą Jetpack Compose. W takim przypadku możesz już wiedzieć, że używanie XML jest nieco nudne, szczególnie jeśli baza kodu jest złożona. Jednak wykorzystanie Jetpack Compose jako pierwszego wyboru ułatwia pracę. Ponadto upraszcza tworzenie interfejsu użytkownika, zapewniając programistom użycie mniejszej ilości kodu, ponieważ korzystają z intuicyjnych interfejsów API Kotlin. Dlatego nowi programiści logicznie naciskają, aby podczas tworzenia widoków używać Jetpack Compose zamiast XML. Jednak znajomość obu może być korzystna, ponieważ wiele aplikacji nadal korzysta z układów XML i być może będziesz musiał zachować widok, ale zbudować nowy za pomocą Jetpack Compose.
Implementacja widoków Androida w Jetpack Compose
W każdej aplikacji na Androida posiadanie elementu interfejsu użytkownika jest bardzo istotne. Widok w systemie Android to prosty element konstrukcyjny interfejsu użytkownika. Widok zapewnia użytkownikom możliwość interakcji z aplikacją poprzez dotknięcie lub inny ruch. W tym przepisie przyjrzymy się różnym elementom interfejsu użytkownika aplikacji Compose i zobaczymy, jak możemy je zbudować.
Przygotowywanie się
W tym przepisie utworzymy jeden projekt, który będziemy wykorzystywać przez całą tą część, więc przejdźmy dalej i wykonaj kroki opisane w Części 1, Pierwsze kroki z umiejętnościami nowoczesnego programowania na Androidzie, na temat tworzenia pierwszego projektu na Androida. Utwórz projekt i nadaj mu nazwę Compose Basics. Ponadto sekcji Podgląd będziemy najczęściej używać do przeglądania tworzonego przez nas elementu interfejsu użytkownika.
Jak to zrobić…
Po utworzeniu projektu wykonaj poniższe kroki, aby zbudować kilka elementów interfejsu użytkownika narzędzia Compose:
1. Wewnątrz naszego projektu utwórzmy nowy pakiet i nazwijmy go komponentami. Tutaj dodamy wszystkie utworzone przez nas komponenty.
2. Utwórz plik Kotlin i nazwij go UIComponents.kt; wewnątrz UIComponent utwórz funkcję do komponowania, nazwij ją EditTextExample() i wywołaj funkcję OutlinedTextField(); spowoduje to wyświetlenie monitu o zaimportowanie wymaganego importu, czyli androidx.Compose.material.OutlinedTextField:
@Composable
fun EditTextExample() {
OutlinedTextField()
}
3. Kiedy zajrzysz głębiej w OutlineTextField , zauważysz, że funkcja przyjmuje kilka danych wejściowych, co jest bardzo przydatne, gdy musisz dostosować własne funkcje, które można komponować.
4. W naszym przykładzie nie zrobimy zbyt wiele z interfejsem użytkownika, który tworzymy, a raczej przyjrzymy się, jak go tworzymy.
5. Teraz, aby w pełni utworzyć naszą OutlinedTextField() w oparciu o typy danych wejściowych, które akceptuje, możemy nadać jej tekst i kolor oraz ozdobić ją za pomocą Modifier(); to znaczy podając mu określone instrukcje, takie jak fillMaxWidth(), która ustawia maksymalną szerokość. Kiedy mówimy "wypełnij", po prostu określamy, że powinien on być całkowicie wypełniony. Ustawiamy .padding(top) na 16.dp, co powoduje zastosowanie dodatkowej przestrzeni wzdłuż każdej krawędzi zawartości w dp. Posiada również wartość, która jest wartością, którą należy wprowadzić w OutlinedTextField, oraz lambdę onValueChange, która nasłuchuje zmiany sygnału wejściowego
6. Nadajemy także naszemu OutlinedText kilka kolorów obramowania, gdy jest skupiony i gdy nie jest skupiony, aby odzwierciedlić różne stany. Dlatego jeśli zaczniesz wprowadzać dane, pole zmieni kolor na niebieski, zgodnie z kodem:
@Composable
fun EditTextExample() {
OutlinedTextField(
value = "",
onValueChange = {},
label = { Text(stringResource(id =
R.string.sample)) },
modifier = Modifier
.fillMaxWidth()
.padding(top = 16.dp),
colors =
TextFieldDefaults.outlinedTextFieldColors(
focusedBorderColor = Color.Blue,
unfocusedBorderColor = Color.Black
)
)
}
7. Mamy także inny typ pola TextField, który nie został opisany w zarysie. Jeśli porównasz dane wejściowe OutlinedTextField, zauważysz, że są one dość podobne:
@Composable
fun NotOutlinedEditTextExample() {
TextField(
value = "",
onValueChange = {},
label = { Text(stringResource(id =
R.string.sample)) },
modifier = Modifier
.fillMaxWidth()
.padding(top = 8.dp, bottom = 16.dp),
colors =
TextFieldDefaults.outlinedTextFieldColors(
focusedBorderColor = Color.Blue,
unfocusedBorderColor = Color.Black
)
)
}
8. Możesz uruchomić aplikację, dodając funkcje Compose wewnątrz funkcji komponowalnej @Preview. W naszym przykładzie możemy utworzyć UIElementPreview(), która jest funkcją podglądu służącą do wyświetlania naszego interfejsu użytkownika. Na rysunku widok z góry to OutlinedTextField, podczas gdy drugi to normalne pole TextField.
9. Przejdźmy teraz do przykładów przycisków. Przyjrzymy się różnym sposobom tworzenia przycisków o różnych kształtach. Jeśli najedziesz kursorem na funkcję komponowania Button(), zobaczysz, co akceptuje jako dane wejściowe, jak pokazano na rysunku
W naszym drugim przykładzie spróbujemy utworzyć przycisk z ikoną. Dodatkowo dodamy tekst, który jest kluczowy przy tworzeniu przycisków, ponieważ musimy określić użytkownikowi, jaką akcję lub co zrobi przycisk po kliknięciu.
10. Zatem utwórz funkcję Compose w tym samym pliku Kotlina i nadaj jej nazwę ButtonWithIcon(), a następnie zaimportuj funkcję komponowania Button().
11. Wewnątrz niego będziesz musiał zaimportować Icon() z wejściem painterResource, opisem zawartości, modyfikatorem i odcieniem. Będziemy także potrzebować funkcji Text(), która nada naszemu przyciskowi nazwę. W naszym przykładzie nie użyjemy odcienia:
@Composable
fun ButtonWithIcon() {
Button(onClick = {}) {
Icon(
painterResource(id =
R.drawable.ic_baseline_shopping_bag_24 ),
contentDescription = stringResource(
id = R.string.shop),
modifier = Modifier.size(20.dp)
)
Text(text = stringResource(id = R.string.buy),
Modifier.padding(start = 10.dp))
}
}
12. Stwórzmy także nową funkcję z możliwością komponowania i nazwijmy ją CornerCutShapeButton(); w tym przykładzie spróbujemy utworzyć przycisk ze ściętymi narożnikami:
@Composable
fun CornerCutShapeButton() {
Button(onClick = {}, shape = CutCornerShape(10)) {
Text(text = stringResource(
id = R.string.cornerButton)) }}}}
13. Stwórzmy także nową funkcję z możliwością komponowania i nazwijmy ją RoundCornerShapeButton(); w tym przykładzie spróbujemy utworzyć przycisk z zaokrąglonymi rogami:
@Composable
fun RoundCornerShapeButton() {
Button(onClick = {}, shape =
RoundedCornerShape(10.dp)) {
Text(text = stringResource(
id = R.string.rounded))
}
}
14. Stwórzmy także nową funkcję z możliwością komponowania i nazwijmy ją ElevatedButtonExample(); w tym przykładzie spróbujemy utworzyć przycisk z podniesieniem:
@Composable
fun ElevatedButtonExample() {
Button(
onClick = {},
elevation = ButtonDefaults.elevation(
defaultElevation = 8.dp,
pressedElevation = 10.dp,
disabledElevation = 0.dp
)
) {
Text(text = stringResource(
id = R.string.elevated))
}
}
15. Po uruchomieniu aplikacji powinieneś otrzymać obraz podobny do rysunku 2.4; pierwszy przycisk po TextField to ButtonWithIcon(), drugi to CornerCutShapeButton(), trzeci to RoundCornerShapeButton(), a na koniec mamy ElevatedButtonExample().
16. Spójrzmy teraz na ostatni przykład, ponieważ w całej książce będziemy używać różnych poglądów i stylów, a przy okazji dowiemy się więcej. Przyjrzyjmy się teraz widokowi obrazu; funkcja komponowania Image() pobiera kilka danych wejściowych, jak pokazano na rysunku
17. W naszym przykładzie Image() będzie mieć tylko malarza, który nie dopuszcza wartości null, co oznacza, że musisz dostarczyć obraz dla tej funkcji, którą można komponować, opis treści dotyczący dostępności i modyfikator:
@Composable
fun ImageViewExample() {
Image(
painterResource(id = R.drawable.android),
contentDescription = stringResource(
id = R.string.image),
modifier = Modifier.size(200.dp)
)
}
18. Możesz także spróbować pobawić się innymi rzeczami, na przykład dodać elementy RadioButton() i CheckBox() i dostosować je. Po uruchomieniu aplikacji powinieneś mieć coś podobnego do rysunku
Jak to działa…
Każda funkcja, którą można komponować, jest opatrzona adnotacją @Composable. Ta adnotacja informuje kompilator Compose, że dostarczony kompilator ma na celu konwersję dostarczonych danych na plik Interfejsu użytkownika. Należy również pamiętać, że każda nazwa funkcji, którą można komponować, musi być rzeczownikiem, a nie czasownikiem czy przymiotnikiem, a Google udostępnia te wytyczne. Dowolna funkcja, którą utworzysz, może akceptować parametry, które umożliwiają logice aplikacji opisywanie lub modyfikowanie interfejsu użytkownika. Wspominamy o kompilatorze Compose, co oznacza, że kompilator to dowolny specjalny program, który pobiera napisany przez nas kod, sprawdza go i tłumaczy na coś, co komputer może zrozumieć - lub na język maszynowy. W Icon() painterResouce określa ikonę, którą dodamy do przycisku, opis zawartości pomaga w dostępności, a modyfikator służy do ozdobienia naszej ikony. Możemy wyświetlić podgląd budowanych przez nas elementów interfejsu użytkownika, dodając adnotację @Preview i dodając
showBackground = true:
@Preview(showBackground = true)
@Preview ma ogromne możliwości i w przyszłych rozdziałach przyjrzymy się, jak możesz lepiej go wykorzystać.
Implementacja przewijanej listy w Jetpack Compose
Jedną rzeczą, co do której wszyscy możemy się zgodzić podczas tworzenia aplikacji na Androida, jest to, że musisz wiedzieć, jak zbudować RecyclerView, aby wyświetlić dane. Dzięki naszemu nowemu, nowoczesnemu sposobowi budowania aplikacji na Androida, jeśli potrzebujemy użyć RecyclerView, możemy użyć LazyColumn, który jest podobny. W tym przepisie przyjrzymy się wierszom, kolumnom i LazyColumn i zbudujemy przewijaną listę, korzystając z naszych fikcyjnych danych. Ponadto przy okazji będziemy uczyć się języka Kotlin.
Przygotowywanie się
Będziemy nadal używać projektu Compose Basics do tworzenia przewijanej listy; dlatego, aby rozpocząć, musisz wykonać poprzedni przepis.
Jak to zrobić…
Wykonaj poniższe kroki, aby utworzyć pierwszą przewijaną listę:
1. Przejdźmy dalej i zbudujmy naszą pierwszą przewijaną listę, ale najpierw musimy utworzyć nasze fikcyjne dane i to jest element, który chcemy wyświetlić na naszej liście. Dlatego utwórz pakiet o nazwie ulubionemiasto, w którym będzie znajdować się nasz przewijany przykład.
2. W pakiecie ulubionychcity utwórz nową klasę danych i nazwij ją City; będzie to nasze fikcyjne źródło danych - klasa danych City ().
3. Zamodelujmy naszą klasę danych City. Po dodaniu wartości z adnotacjami pamiętaj o dodaniu niezbędnych importów:
data class City(
val id: Int,
@StringRes val nameResourceId: Int,
@DrawableRes val imageResourceId: Int
)
4. Teraz w naszych fikcyjnych danych musimy utworzyć klasę Kotlin i nazwać ją CityDataSource. W tej klasie utworzymy funkcję o nazwie LoadCities(), która zwróci naszą listę List
class CityDataSource {
fun loadCities(): List
return listOf
City(1, R.string.spain, R.drawable.spain),
City(2, R.string.new_york,
R.drawable.newyork),
City(3, R.string.tokyo, R.drawable.tokyo),
City(4, R.string.switzerland,
R.drawable.switzerland),
City(5, R.string.singapore,
R.drawable.singapore),
City(6, R.string.paris, R.drawable.paris),
)
}
}
5. Mamy już fikcyjne dane i czas wyświetlić je na naszej przewijanej liście. Utwórzmy nowy plik Kotlin w naszym pakiecie komponentów i nazwijmy go CityComponents. W CityComponents utworzymy naszą funkcję @Preview:
@Preview(showBackground = true)
@Composable
private fun CityCardPreview() {
CityApp()
}
6. Wewnątrz naszej funkcji @Preview znajduje się kolejna funkcja, którą można komponować, CityApp(); wewnątrz tej funkcji wywołamy naszą funkcję komponowania CityList, która ma listę jako parametr. Dodatkowo w tej funkcji komponowalnej wywołamy LazyColumn, a elementami będą CityCard(miasta). Więcej informacji na temat LazyColumn i elementów znajdziesz w sekcji Jak to działa:
@Composable
fun CityList(cityList: List
LazyColumn {
items(cityList) { cities ->
CityCard(cities)
}
}
}
7. Na koniec skonstruujmy funkcję komponowalną CityCard(city):
@Composable
fun CityCard(city: City) {
Card(modifier = Modifier.padding(10.dp),
elevation = 4.dp) {
Column {
Image(
painter = painterResource(
city.imageResourceId),
contentDescription = stringResource(
city.nameResourceId),
modifier = Modifier
.fillMaxWidth()
.height(154.dp),
contentScale = ContentScale.Crop
)
Text(
text = LocalContext.current.getString(
city.nameResourceId),
modifier = Modifier.padding(16.dp),
style = MaterialTheme.typography.h5
)
}
}
}
8. Po uruchomieniu funkcji komponowania CityCardPreview powinna pojawić się przewijalna lista, jak pokazano na rysunku
Jak to działa…
W Kotlinie lista ma dwa typy: niezmienną i zmienną. Listy niezmienne to elementy, których nie można modyfikować, natomiast listy zmienne to elementy na liście, które można modyfikować. Aby zdefiniować listę, możemy powiedzieć, że lista jest ogólnym uporządkowanym zbiorem elementów, a elementy te mogą mieć postać liczb całkowitych, ciągów znaków, obrazów itd., co jest głównie zależne od rodzaju danych, jakie chcemy uzyskać na naszych listach zawierać. Na przykład w naszym przykładzie mamy ciąg znaków i obraz, które pomagają zidentyfikować nasze ulubione miasta według nazwy i obrazu. W naszej klasie danych City używamy @StringRes i @DrawableRes, aby po prostu łatwo pobrać to bezpośrednio z folderów res dla Drawable i String, a także reprezentują one identyfikator obrazów i ciągu znaków. Stworzyliśmy CityList i opatrzyliśmy ją adnotacją za pomocą funkcji composable i zadeklarowaliśmy listę obiektów miejskich jako nasz parametr w tej funkcji. Przewijalna lista w Jetpack Compose jest tworzona przy użyciu LazyColumn. Główna różnica między LazyColumn i Column polega na tym, że podczas korzystania z Column można wyświetlać tylko małe elementy, ponieważ Compose ładuje wszystkie elementy na raz. Ponadto kolumna może zawierać tylko stałe funkcje, które można komponować, podczas gdy LazyColumn, jak sama nazwa wskazuje, ładuje zawartość zgodnie z wymaganiami na żądanie, dzięki czemu dobrze nadaje się do ładowania większej liczby elementów, gdy zajdzie taka potrzeba. Ponadto LazyColumn ma wbudowaną funkcję przewijania, która ułatwia pracę programistom. Stworzyliśmy także funkcję komponowalną CityCard, do której importujemy element Card() z Compose. Karta zawiera treść i działania dotyczące pojedynczego obiektu; w naszym przykładzie na naszej karcie znajduje się zdjęcie i nazwa miasta. Element Card() w Compose ma w swoim parametrze następujące dane wejściowe:
@Composable
fun Card(
modifier: Modifier = Modifier,
shape: Shape = MaterialTheme.shapes.medium,
backgroundColor: Color = MaterialTheme.colors.surface,
contentColor: Color = contentColorFor(backgroundColor),
border: BorderStroke? = null,
elevation: Dp = 1.dp,
content: @Composable () -> Unit
),
Oznacza to, że możesz łatwo wymodelować swoją kartę tak, aby była najlepiej dopasowana; nasza karta ma dopełnienie i podniesienie, a zakres ma kolumnę. W tej kolumnie mamy obraz i tekst, który pomaga opisać obraz w celu uzyskania większego kontekstu.
Implementowanie układu pierwszej karty za pomocą pagera widoku przy użyciu Jetpack Compose
W programowaniu na Androida bardzo często zdarza się, że slajd między stronami jest wyświetlany, a znaczącym przypadkiem użycia jest wdrażanie lub nawet wtedy, gdy próbujesz wyświetlić określone dane w formie karuzeli z zakładkami. W tym przepisie zbudujemy prosty poziomy pager w Compose i zobaczymy, jak możemy wykorzystać nową wiedzę do tworzenia lepszych i nowocześniejszych aplikacji na Androida.
Przygotowywanie się
W tym przykładzie zbudujemy poziomy pager, który zmienia kolory po wybraniu, aby pokazać wybrany stan. Dla lepszego zrozumienia stanom przyjrzymy się w rozdziale 3, Obsługa stanu interfejsu użytkownika w Jetpack Compose i Używanie Hilt. Aby rozpocząć, otwórz projekt Compose Basics.
Jak to zrobić…
Wykonaj poniższe kroki, aby zbudować karuzelę kart:
1. Dodaj następujące zależności pagera do build.gradle(Module:app):
implementation "com.google.accompanist:accompanist-pager:0.x.x"
implementation "com.google.accompanist:accompanist-pagerindicators: 0.x.x"
implementation 'androidx.Compose.material:material:1.x.x'
Jetpack Compose oferuje Accompanist, grupę bibliotek, których celem jest wspieranie go w powszechnie wymaganych przez programistów funkcjach - na przykład w naszym przypadku pager.
2. W tym samym projekcie z poprzednich przepisów utwórzmy pakiet i nazwijmy go pagereprzykład; w nim utwórz plik Kotlin i nazwij go CityTabExample; w tym pliku utwórz funkcję umożliwiającą komponowanie i nazwij ją CityTabCarousel:
@Composable
fun CityTabCarousel(){}
3. Teraz przejdźmy dalej i zbudujmy naszą CityTabCarousel; dla naszego przykładu utworzymy fikcyjną listę stron z naszymi miastami z poprzedniego projektu:
@Composable
fun CityTabCarousel(
pages: MutableList
"Spain",
"New York",
"Tokyo",
"Switzerland",
"Singapore",
"Paris" )) {…}
4. Będziemy musieli zmienić kolor przycisku w zależności od stanu i aby to zrobić; musimy użyć LocalContext, który zapewnia kontekst, którego możemy użyć. Będziemy musieli także utworzyć zmienną var pagerState = RememberPagerState(), która zapamięta stan naszego pagera i na koniec, po kliknięciu, będziemy musieli przejść do następnego miasta w naszym pagerze, co będzie bardzo pomocne. Dlatego śmiało dodaj następujące elementy do funkcji komponowania CityTabCarousel:
val context = LocalContext.current
var pagerState = rememberPagerState()
val coroutineScope = rememberCoroutineScope()
5. Teraz utwórzmy element Column i dodajmy naszą funkcję komponowania ScrollableTabRow():
Column {
ScrollableTabRow(
selectedTabIndex = pagerState.currentPage,
indicator = { tabPositions ->
TabRowDefaults.Indicator(…)
},
edgePadding = 0.dp,
backgroundColor = Color(
context.resources.getColor(R.color.white,
null)),
) {
pages.forEachIndexed { index, title ->
val isSelected =
pagerState.currentPage == index
TabHeader(
title,
isSelected,
onClick = { coroutineScope.launch {
pagerState.animateScrollToPage(index)
} },
)
}
}
6. Dodaj Text() i TabHeader() dla HorizontalPager:
HorizontalPager(
count = pages.size,
state = pagerState,
modifier = Modifier
.fillMaxWidth()
.fillMaxHeight()
.background(Color.White)
) { page ->
Text(
text = "Display City Name:
${pages[page]}",
modifier = Modifier.fillMaxWidth(),
style = TextStyle(
textAlign = TextAlign.Center
)
)
}
7. Proszę pobrać cały kod tego przepisu, klikając link podany w sekcji Wymagania techniczne, aby dodać cały wymagany kod. Na koniec uruchom funkcję @Preview, a Twoja aplikacja powinna wyglądać jak Rysunek
Jak to działa…
Accompanist zawiera kilka znaczących bibliotek - na przykład Kontroler interfejsu użytkownika systemu, Adapter motywu AppCompact Compose, Adapter motywu materiału, Pager, Malarz do rysowania i Układy przepływu, żeby wymienić tylko kilka. Funkcja ScrollableTabRow(), której używamy wewnątrz Column w funkcji CityTabCarousel, zawiera rząd zakładek i pomaga wyświetlić wskaźnik pod aktualnie zaznaczoną lub wybraną zakładką. Dodatkowo, jak sama nazwa wskazuje, umożliwia przewijanie i nie trzeba wdrażać dalszych narzędzi przewijania. Umieszcza również przesunięcia tabulatorów na krawędzi początkowej i można szybko przewijać karty znajdujące się poza ekranem, co zobaczysz po uruchomieniu funkcji @Preview i zabawie się nią. Kiedy wywołujemy funkcję Remember() w Compose, oznacza to, że zachowujemy spójność wartości podczas rekompozycji. Compose udostępnia tę funkcję, aby pomóc nam przechowywać pojedyncze obiekty w pamięci. Kiedy uruchamiamy naszą aplikację, Remember() przechowuje wartość początkową. Jak to słowo oznacza, po prostu zachowuje wartość i zwraca przechowywaną wartość, aby funkcja komponowalna mogła z niej skorzystać. Co więcej, za każdym razem, gdy przechowywana wartość ulegnie zmianie, możesz ją zaktualizować, a funkcja Remember() ją zachowa. Następnym razem, gdy uruchomimy kolejne uruchomienie w naszej aplikacji i nastąpi rekompozycja, funkcja Remember() zapewni najnowszą zapisaną wartość. Zauważysz również, że nasza MutableList
onClick = { coroutineScope.launch { pagerState.
animateScrollToPage(index) } }
HorizontalPager to układ przewijany w poziomie, który umożliwia naszym użytkownikom przełączanie elementów od lewej do prawej. Pobiera kilka danych wejściowych, ale dostarczamy mu liczbę, stan i modyfikator, aby ozdobić go w naszym przypadku użycia. W Lambdzie wyświetlamy tekst - w naszym przykładzie pokazujący na której stronie się znajdujemy, co pomaga w nawigacji, jak pokazano na rysunku
Nasza funkcja komponowania TabHeader ma Box(); pudełko w Jetpack Compose zawsze dopasuje się do zawartości i podlega to określonym ograniczeniom. W naszym przykładzie dekorujemy nasze pudełko modyfikatorem selekcji, który konfiguruje komponenty tak, aby można je było wybierać jako część wzajemnie wykluczającej się grupy, dzięki czemu każdy element może zostać wybrany tylko raz w danym momencie.
Implementacja animacji w Compose
Animacja w systemie Android to proces dodawania efektów ruchu do widoków. Można to osiągnąć za pomocą obrazów, tekstu lub nawet rozpoczynając nowy ekran, na którym przejście jest zauważalne, dzięki efektom ruchu. Animacje są niezbędne w rozwoju nowoczesnego Androida, ponieważ nowoczesne interfejsy użytkownika są bardziej interaktywne i dostosowują się do płynniejszych wrażeń, a użytkownicy je lubią. Co więcej, obecnie aplikacje są oceniane na podstawie tego, jak świetny jest ich interfejs użytkownika i doświadczenia użytkownika, dlatego należy upewnić się, że aplikacja jest nowoczesna i solidna. W tym przykładzie zbudujemy zwijany pasek narzędzi, animację szeroko stosowaną w świecie Androida.
Przygotowywanie się
Będziemy nadal korzystać z projektu Compose Basics.
Jak to zrobić…
W tym przepisie będziemy budować zwijany pasek narzędzi; istnieją inne wspaniałe animacje, które możesz teraz zbudować, korzystając z możliwości tworzenia. Moc jest w Twoich rękach:
1. Nie będziemy musieli dodawać żadnej zależności do tego przepisu. Wszystko mamy już na miejscu. Przejdźmy więc dalej i utwórz nowy pakiet i dodaj plik Kotlin, collapsingtoolbar.
2. W pliku Kotlin utwórz nową funkcję, którą można komponować, CollapsingTool BarExample():
@Composable
fun CollapsingToolbarExample() {…}
3. Będziemy mieć wszystkie potrzebne funkcje komponowalne w pudełku; możesz odwołać się do poprzedniego przepisu, żeby odświeżyć sobie pamięć. Będziemy musieli także określić wysokość, na której zaczniemy zawijać nasz widok, może to być oparte na preferencjach; w naszym przykładzie możemy ustawić wysokość na 260.dp:
private val height = 260.dp
private val titleToolbar = 50.dp
4. Dodajmy więcej funkcji, które można komponować, z fikcyjnymi danymi tekstowymi wyświetlanymi podczas przewijania naszej zawartości. Możemy założyć, że ta aplikacja służy do odczytywania informacji o wyświetlanych przez nas miastach:
@Composable
fun CollapsingToolbarExample() {
val scrollState: ScrollState =
rememberScrollState(0)
val headerHeight = with(LocalDensity.current) {
height.toPx() }
val toolbarHeight = with(LocalDensity.current) {
titleToolbar.toPx() }
Box(
modifier = Modifier.fillMaxSize()
) {
CollapsingHeader(scrollState, headerHeight)
FactsAboutNewYork(scrollState)
OurToolBar(scrollState, headerHeight,
toolbarHeight)
City()
}
}
5. W naszej funkcji CollapsingHeader przekazujemy stan przewijania, a wysokość nagłówka jako wartość zmiennoprzecinkową. Dekorujemy Boxa Modifier.graphicLayer, gdzie ustawiamy efekt paralaksy, aby wyglądał dobrze i reprezentacyjnie.
6. Upewnij się również, że dodaliśmy metodę Brush() i ustawiliśmy potrzebne kolory oraz określimy, gdzie powinno się to zaczynać:
Box(
Modifier
.fillMaxSize()
.background(
brush = Brush.verticalGradient(
colors = listOf(Color.Transparent,
Color(0xFF6D38CA)),
startY = 1 * headerHeight / 5
)
)
)
…
7. FactsAboutNewYork nie jest złożoną funkcją, którą można komponować, jest po prostu fikcyjnym tekstem; następnie w końcu na pasku narzędzi wykorzystujemy AnimatedVisibility i deklarujemy nasze przejście do wejścia i wyjścia:
AnimatedVisibility(
visible = showToolbar,
enter = fadeIn(animationSpec = tween(200)),
exit = fadeOut(animationSpec = tween(200))
) {
…
8. Na koniec uruchom funkcję @Preview, a otrzymasz składany pasek narzędzi, który zapewni płynność interfejsu użytkownika.
Jak to działa…
W Modern Android Development biblioteka Jetpack Compose zawiera wiele interfejsów API animacji, które są dostępne jako funkcje komponowalne. Na przykład możesz chcieć, aby obraz lub tekst pojawiał się i znikał. Dlatego też, jeśli animujesz pojawianie się i znikanie, co może dotyczyć obrazu, tekstu, grupy opcji, przycisku itd., możesz w tym celu użyć AnimatedVisibility. W przeciwnym razie, jeśli zamieniasz zawartość w zależności od stanu i chcesz, aby zawartość przenikała, możesz użyć funkcji CrossFade lub AnimatedContent. val headerHeight = with(LocalDensity.current) { height.toPx() } zapewnia gęstość, która zostanie wykorzystana do przekształcenia jednostek DP i SP i możemy to wykorzystać, gdy zapewnimy DP, co zrobimy, a później przekształcimy w treść naszego układu. Możesz wywołać modyfikator i użyć GraphicLayer, aby niezależnie zaktualizować dowolną treść powyżej, aby zminimalizować nieważną treść. Ponadto GraphicLayer można wykorzystać do zastosowania efektów, takich jak skalowanie, obrót, krycie, cień, a nawet przycinanie. TranslationY = scroll.value.toFloat() / 2f zasadniczo ustawia pionowe przesunięcie pikseli warstwy względem jej górnej granicy. Wartość domyślna to zawsze zero, ale można ją dostosować do własnych potrzeb. Zapewniamy również, że gradient jest stosowany tylko do zawijania tytułu w startY = 1 * headerHeight / 5. EnterTransition definiuje, jak powinna wyglądać docelowa treść; celem może być obraz, tekst lub nawet grupa radiowa. Z drugiej strony ExitTransition definiuje, w jaki sposób początkowa treść docelowa powinna zniknąć podczas wychodzenia z aplikacji lub nawigacji. AnimatedContent oferuje slideIntoContainer i slideOutOfContainer i animuje swoją zawartość w miarę jej zmian w zależności od stanu docelowego, co jest niezwykłe. Ponadto możesz także hermetyzować przejście i umożliwić jego ponowne użycie, tworząc klasę przechowującą wszystkie wartości animacji oraz funkcję Update(), która zwraca instancję tej klasy. Warto również wspomnieć, że podobnie jak w przypadku starych sposobów tworzenia animacji w systemie Android przy użyciu MotionLayout, istnieje wiele sposobów wykonywania przejść w Jetpack Compose. Na przykład w tabeli zobaczysz różne typy przejść:
EnterTransition : ExitTransition
SlideIn : SlideOut
FadeIn : FadeOut
SlideInHorizontally : SlideOutHorizontally
SlideInVertically : SlideOutVertically
ScaleIn : SlaceOut
ExpandIn : ShrinkOut
ExpandHorizontally : ShinkHorizontally
ExpandVertically : ShrinkVertically
Ponadto możesz dodawać własne, niestandardowe efekty animacji w Jetpack Compose poza już wbudowanymi animacjami wejścia i wyjścia, po prostu uzyskując dostęp do instancji przejścia elementarnego za pośrednictwem właściwości przejścia wewnątrz lambda treści dla AnimatedVisibility. Zauważysz także wszelkie dodane stany animacji.
Implementacja ułatwień dostępu w Jetpack Compose
Tworząc aplikacje na Androida, zawsze musimy mieć na uwadze dostępność, ponieważ dzięki temu technologia jest włączająca i zapewnia, że podczas tworzenia aplikacji uwzględnimy wszystkie osoby o specjalnych potrzebach. Dostępność powinna być dziełem zespołowym. Jeśli będziesz dobrze obsługiwany, korzyścią będzie to, że z aplikacji będzie korzystać więcej osób. Przystępna aplikacja jest lepsza dla każdego. Zmniejszasz także ryzyko bycia pozwanym. Istnieją różne rodzaje niepełnosprawności, takie jak upośledzenie wzroku, słuchu i motoryki. Jeśli otworzysz ustawienia dostępności, zobaczysz różne opcje, z których korzystają osoby niepełnosprawne na swoich urządzeniach.
Podobnie jak w przypadku poprzednich przepisów, będziemy nadal korzystać z naszego przykładowego projektu z poprzednich przepisów; nie musisz niczego instalować.
Jak to zrobić…
W tym przepisie opiszemy elementy wizualne, które są bardzo istotne:
1. Domyślnie, gdy dodamy funkcję Obraz, możesz zauważyć, że ma ona dwa parametry: malarza obrazu i opis zawartości, który wizualnie opisuje element:
Image(painter = , contentDescription = )
2. Kiedy ustawisz opis treści na null, wskazujesz platformie Android, że z tym elementem nie jest powiązana żadna akcja ani stan. Przejdźmy więc dalej i zaktualizujmy wszystkie nasze opisy treści:
Image(
modifier = modifier
painter = painterResource(city.imageResourceId),
contentDescription =
stringResource(R.string.city_images))
)
3. Upewnij się, że dodałeś ciąg znaków do folderu string res:
4. Zatem pamiętaj o dodaniu opisu treści do każdego obrazu, który tego wymaga.
5. W programie Compose możesz łatwo wskazać, czy tekst jest nagłówkiem, określając to w modyfikatorze i używając semantyki, aby pokazać, że jest to nagłówek. Dodajmy to w naszym ozdobnym tekście:
...
modifier = Modifier
.padding(18.dp)
.semantics { heading() }
...
6. Wreszcie możemy przystąpić do kompilacji, uruchomienia i sprawdzenia, czy nasza aplikacja jest dostępna, klikając ten link, aby dowiedzieć się, jak ręcznie przetestować za pomocą funkcji talkback lub testów automatycznych: https://developer.android.com/guide/topics/ interfejs użytkownika/dostępność/testowanie.
Jak to działa…
Jetpack Compose został stworzony z myślą o dostępności; to znaczy, że komponenty materialne, takie jak RadioButton, Switch i tak dalej, mają swój rozmiar ustawiony wewnętrznie, ale tylko wtedy, gdy te komponenty mogą odbierać interakcje użytkownika. Co więcej, każdy element ekranu, na który użytkownicy mogą kliknąć lub z którym można wejść w interakcję, powinien być wystarczająco duży, aby zapewnić niezawodną interakcję. Standardowy format ustawia te elementy na rozmiar co najmniej 48 dp dla szerokości i wysokości. Na przykład przełącznik ma ustawiony parametr onCheckChanged na wartość różną od null, obejmującą szerokość i wysokość co najmniej 48 dp; mielibyśmy CheckableSwitch() i NonCheckableSwitch():
@Composable
fun CheckableSwitch(){
var checked by remember { mutableStateOf(false) }
Switch(checked = checked, onCheckedChange = {} )
}
@Composable
fun NonCheckableSwitch(){
var checked by remember { mutableStateOf(false) }
Switch(checked = checked, onCheckedChange = null )
}
Gdy już zaimplementujesz dostępność w swoich aplikacjach, możesz ją łatwo przetestować, instalując narzędzia analityczne ze Sklepu Play - uiautomatorviewer i lint. Możesz także zautomatyzować testy za pomocą Espresso lub Roboelectric, aby sprawdzić obsługę dostępności. Na koniec możesz ręcznie przetestować aplikację pod kątem obsługi ułatwień dostępu, przechodząc do Ustawień, następnie do Dostępności i wybierając opcję Talkback. Znajduje się ono w górnej części ekranu; następnie naciśnij przycisk Włącz lub Wyłącz, aby włączyć lub wyłączyć funkcję TalkBack. Następnie przejdź do okna dialogowego z potwierdzeniem i kliknij OK, aby potwierdzić pozwolenie.
Więcej…
Jest więcej kwestii związanych z dostępnością, które programiści powinni wziąć pod uwagę podczas tworzenia swoich aplikacji, w tym stanu, w którym powinni być w stanie powiadomić swoich użytkowników o tym, czy został wybrany przycisk Przełącz. Dzięki temu ich aplikacje obsługują dostępność i odpowiadają standardom.
Implementacja grafiki deklaratywnej przy użyciu Jetpack Compose
W przypadku programowania na Androida Twoja aplikacja może mieć inne potrzeby, a tą potrzebą może być tworzenie własnej, niestandardowej grafiki zgodnie z zamierzonym celem. Jest to bardzo powszechne w wielu stabilnych i dużych bazach kodów Androida. Istotną częścią każdego niestandardowego widoku jest jego wygląd. Co więcej, niestandardowy rysunek może być bardzo łatwym lub złożonym zadaniem w zależności od potrzeb Twojej aplikacji. W Modern Android Development Jetpack Compose ułatwia pracę z niestandardową grafiką po prostu dlatego, że zapotrzebowanie jest ogromne. Na przykład wiele aplikacji może wymagać dokładnego kontrolowania tego, co dzieje się na ekranie; przypadek użycia może być tak prosty, jak umieszczenie okręgu na ekranie lub zbudowanie bardziej złożonej grafiki do obsługi znanych przypadków użycia.
Przygotowywanie się
Otwórz projekt Compose Basics, aby rozpocząć korzystanie z tego przepisu. Cały kod znajdziesz w sekcji Wymagania techniczne.
Jak to zrobić…
W naszym projekcie utwórzmy nowy pakiet i nazwijmy go roundexample; wewnątrz tego pakietu utwórz plik Kotlin i nazwij go DrawCircleCompose; wewnątrz pliku utwórz funkcję komponowalną CircleProgressIndicatorExample. Na razie nie będziesz musiał niczego importować:
1. Przejdźmy teraz dalej i zdefiniujmy naszą funkcję komponowalną. Ponieważ w naszym przykładzie chcemy wyświetlić tracker w okręgu, musimy unosić się w powietrzu, aby wypełnić nasze koło. Zdefiniujemy również kolory, które pomogą nam zidentyfikować postęp:
@Composable
fun CircleProgressIndicatorExample(tracker: Float, progress:
Float) {
val circleColors = listOf(
colorResource(id = R.color.purple_700),
colorResource(id = R.color.teal_200)
)
2. Teraz wywołajmy Canvas, aby narysować nasz łuk. Nadajemy naszemu okręgowi rozmiar 200.dp z wypełnieniem 8.dp. Ciekawie robi się w onDraw. startAngle jest ustawiony na -90; kąt początkowy jest ustawiony w stopniach, aby lepiej go zrozumieć. Zero oznacza godzinę trzecią. Możesz także pobawić się kątem początkowym, aby zobaczyć, jak przekłada się -90. Wartość logiczna useCenter wskazuje, czy łuk ma zamykać środek granic. Dlatego w naszym przypadku ustawiliśmy go na false. Następnie na koniec ustalamy styl, który może być dowolny, w zależności od naszych preferencji:
Canvas(
modifier = Modifier
.size(200.dp)
.padding(8.dp),
onDraw = {
this.drawIntoCanvas {
drawArc(
color = colorSecondary,
startAngle = -90f,
sweepAngle = 360f,
useCenter = false,
style = Stroke(width = 55f, cap =
StrokeCap.Butt),
size = Size(size.width, size.height)
)
colorResource(id = R.color.teal_200)
…
3. Właśnie narysowaliśmy pierwszą część okręgu; teraz musimy narysować postęp za pomocą pędzla, który wykorzystuje linearGradient:
drawArc(
brush = Brush.linearGradient(colors =
circleColors),
startAngle = -90f,
sweepAngle = progress(tracker, progress),
useCenter = false,
style = Stroke(width = 55f, cap =
StrokeCap.Round),
size = Size(size.width, size.height)
) …
…
4. Na koniec nasza funkcja postępu informuje SweaAngle, gdzie powinien opierać się nasz postęp, na podstawie naszych możliwości śledzenia:
private fun progress(tracker: Float, progress: Float): Float {
val totalProgress = (progress * 100) / tracker
return ((360 * totalProgress) / 100)
}
…
5. Uruchom funkcję podglądu. Powinieneś zobaczyć okrągły wskaźnik postępu, jak na rysunku
Ważna uwaga: Funkcja komponowania Canvas wykorzystuje Canvas do komponowania obiektu, który z kolei tworzy Canvas oparty na widoku i pomaga nim zarządzać. Należy również wspomnieć, że Compose ułatwia programistom utrzymanie stanu oraz tworzenie i zwalnianie wszelkich niezbędnych obiektów pomocniczych.
Jak to działa…
Ogólnie rzecz biorąc, Canvas pozwala określić obszar na ekranie, w którym chcesz narysować. W starym sposobie tworzenia aplikacji na Androida korzystaliśmy również z Canvas, a teraz w Compose jest on potężniejszy i cenniejszy. linearGradient tworzy gradient liniowy o określonych kolorach wzdłuż podanych współrzędnych początkowych i końcowych. Dla naszego przykładu nadajemy mu prostą kolorystykę, która jest dołączona do projektu. Funkcje rysujące mają domyślne parametry instrumentalne, których można użyć. Na przykład, jak widać, domyślnie DrawArc pobiera kilka danych wejściowych:
SweepAngle w naszym przykładzie, który jest rozmiarem łuku w stopniu narysowanym zgodnie z ruchem wskazówek zegara względem startAngle, zwraca funkcję obliczającą postęp. Funkcję tę można dostosować do własnych potrzeb. W naszym przykładzie przekazujemy moduł śledzący, postęp i zwracamy wartość zmiennoprzecinkową. Ponieważ chcemy zapełnić okrąg tworzymy cal totalProgress, który sprawdza postęp * 100 podzielony przez tracker i zwraca 360 (kółko) * nasz postęp podzielony przez 100. Możesz dostosować tę funkcję do swoich potrzeb. Możesz także napisać kod, aby nasłuchiwać, gdzie jesteś, i sterować postępem w oparciu o wartość wejściową z utworzonego przez Ciebie słuchacza.
Więcej…
Dzięki Canvas i rysunkom niestandardowym możesz zrobić więcej. Niezwykłym sposobem na poszerzenie wiedzy na ten temat jest przejrzenie starych rozwiązań opublikowanych na Stack Overflow, takich jak rysowanie serca lub innego kształtu, i sprawdzenie, czy możesz zrobić to samo w aplikacji Compose.
Obsługa stanu interfejsu użytkownika w Jetpack Compose i używanie Hilt
Wszystkie aplikacje na Androida wyświetlają stan użytkownikom, co pomaga informować użytkowników o wyniku i czasie. Stan w aplikacji na Androida to dowolna wartość, która zmienia się w czasie, a dobrym przykładem jest toast wyświetlający komunikat w przypadku wystąpienia błędu. W tym rozdziale czytelnicy dowiedzą się, jak lepiej obsługiwać stan interfejsu użytkownika dzięki nowej bibliotece Jetpack. Można śmiało powiedzieć, że z wielką mocą wiąże się wielka odpowiedzialność, a zarządzanie stanem dowolnego komponentu Composable wymaga innego podejścia w porównaniu ze starszym sposobem tworzenia widoków Androida lub, jak wielu może to nazwać, sposobem imperatywnym. Oznacza to, że biblioteka Jetpack, Compose, całkowicie różni się od układów XML. Obsługa stanu interfejsu użytkownika w systemie widoku XML jest bardzo prosta. Proces ten obejmuje ustawienie właściwości widoków tak, aby odzwierciedlały bieżący stan - czyli odpowiednie pokazywanie lub ukrywanie widoków. Na przykład podczas ładowania danych z interfejsu API możesz ukryć widok ładowania, wyświetlić widok treści i wypełnić go żądanymi widokami. Jednakże w Compose nie można zmienić komponentu Composable po jego narysowaniu przez aplikację. Możesz jednak zmienić wartości przekazywane do każdego obiektu Composable, zmieniając stan otrzymywany przez każdy obiekt Composable. Dlatego przydaje się wiedza o lepszym zarządzaniu stanem podczas tworzenia solidnych aplikacji na Androida.
Implementacja DI za pomocą Jetpack Hilt
W programowaniu obiektowym DI jest niezbędne. Niektórzy ludzie go używają, a niektórzy wolą go nie używać z własnych powodów. Jednak DI to praktyka projektowania obiektów w taki sposób, że otrzymują instancje obiektu z innych fragmentów kodu, zamiast konstruować je wewnętrznie. Jeśli znasz zasady SOLID, wiesz, że ich głównym celem jest ułatwienie projektowania oprogramowania w utrzymaniu, czytaniu, testowaniu i rozwijaniu. Ponadto DI pomaga nam przestrzegać niektórych zasad SOLID. Zasada inwersji zależności pozwala na łatwą rozbudowę bazy kodu i poszerzanie jej o nowe funkcjonalności oraz poprawia możliwość ponownego wykorzystania. W nowoczesnym rozwoju Androida DI jest niezbędne i w tym przepisie zaimplementujemy go w naszej aplikacji. Istnieją różne typy bibliotek, których można używać w systemie Android do DI, takie jak Koin, Dagger i Hilt; Hilt wykorzystuje moc Daggera i czerpie korzyści z poprawności kompilacji, dobrej wydajności w czasie wykonywania, obsługi studia Android i skalowalności. Do tego przepisu użyjemy Hilt, który udostępnia kontenery dla każdej klasy Androida w naszym projekcie i automatycznie zarządza ich cyklem życia.
Przygotowywanie się
Podobnie jak w poprzednich przepisach, do dodania DI wykorzystamy projekt, z którego korzystaliśmy w poprzednich przepisach.
Jak to zrobić…
Hilt korzysta z funkcji Java; upewnij się, że Twój projekt znajduje się w pliku app/build.gradle i że masz następujące opcje kompilacji:
android {
…
compileOptions {
sourceCompatibility JavaVersion.VERSION_11
targetCompatibility JavaVersion.VERSION_11
}
}
Ta opcja jest już dodawana automatycznie, ale na wszelki wypadek sprawdź, czy ją masz. Zacznijmy:
1. Najpierw musimy dodać wtyczkę Hilt-android-gradle-plugin do pliku głównego naszego projektu build.gradle(Project:SampleLogin):
plugins {
id 'com.google.dagger.Hilt.android' version '2.44'
apply false
}
2. Następnie w naszym pliku app/build.gradle dodaj te zależności i zsynchronizuj projekt. Powinno działać bez żadnych problemów:
plugins {
id 'kotlin-kapt'
id 'dagger.Hilt.android.plugin'
}
dependencies {
implementation "com.google.dagger:Hiltandroid:
2.44"
kapt "com.google.dagger:Hilt-compiler:2.44"
}
3. Teraz przejdźmy dalej i dodajmy klasę Application. Wszystkie aplikacje korzystające z Hilt muszą mieć klasę Application z adnotacją @HiltAndroidApp i musimy wywołać klasę Application, którą tworzymy w Manifeście:
@HiltAndroidApp
class LoginApp : Application()
4. In our Manifest folder, let′s add LoginApp:
…
5. Teraz, gdy mamy już za sobą konfigurację, musimy rozpocząć pracę z Hiltem, dodając wymagane adnotacje do naszej klasy. W MainActivity.kt musimy dodać adnotację @AndroidEntryPoint:
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
…
6. Przejdźmy dalej i wyświetlmy to, co zrobiliśmy, uruchamiając polecenie ./gradlew :app: zależnośći, a zobaczymy coś podobnego do rysunku
Możesz także wyświetlić zależność w Android Studio. Można to zrobić, klikając kartę Gradle po prawej stronie i wybierając opcję rozwiń:twójmoduł | Zadania | android. Na koniec kliknij dwukrotnie androidDependencies, aby go uruchomić. Na koniec skompiluj i uruchom projekt; powinno działać pomyślnie.
Jak to działa…
@HiltAndroidApp wyzwala generację kodu Hilt, w tym klasy bazowej dla naszej aplikacji, która działa jako kontener zależności na poziomie aplikacji. Adnotacja @AndroidEntryPoint dodaje kontener DI do oznaczonej nim klasy Androida. W przypadku korzystania z Hilt wygenerowany komponent Hilt jest dołączany do cyklu życia obiektu Application i udostępnia jego zależności. Hilt obecnie obsługuje następujące klasy Androida:
• ViewModel z adnotacją @HiltViewModel
• Aplikacja oznaczona jako @HiltAndroidApp
• Działalność
• Fragment
• Pogląd
• Praca
• Odbiornik transmisji
Później użyjemy innych niezbędnych adnotacji w Hilt, na przykład adnotacji @Module, @InstallIn i @Provides. Adnotacja @Module oznacza klasę, w której można dodać powiązanie dla typów, których nie można wstrzyknąć do konstruktora. @InstallIn wskazuje, który kontener DI Hiltgenerated (lub komponent singleton) musi być dostępny w powiązaniu modułu kodu. Na koniec @Provides wiąże typ, którego nie można wstrzyknąć do konstruktora. Jego typem zwracanym jest typ powiązania, może przyjmować parametry zależności i za każdym razem, gdy potrzebujesz instancji, treść funkcji jest wykonywana, jeśli typ nie ma zakresu.
Implementowanie narzędzia Compose w istniejącym projekcie opartym na układzie XML
Ponieważ Compose to nowa platforma interfejsu użytkownika, wiele baz kodu nadal w dużym stopniu opiera się na układach XML. Jednak wiele firm decyduje się na budowanie nowych ekranów przy użyciu narzędzia Compose, co można osiągnąć poprzez wykorzystanie istniejących układów XML i dodanie unikalnych widoków przy użyciu znaczników XML ComposeView. W tym przepisie omówimy dodanie widoku tworzenia do układu XML.
Przygotowywanie się
W tym przepisie możemy utworzyć nowy projekt lub zdecydować się na użycie istniejącego projektu, który nie opiera się w dużym stopniu na Compose. Spróbujemy wyświetlić powitanieDialog i użyć układu XML, aby pokazać, jak możemy użyć tagu ComposeView w układach XML. Jeśli masz już projekt, nie musisz go konfigurować; możesz przejść do kroku 4 w poprzedniej sekcji Jak to zrobić….
Jak to zrobić…
Przejdźmy teraz dalej i zbadajmy, w jaki sposób możemy wykorzystać istniejące układy XML za pomocą narzędzia Compose:
1. Zacznijmy od stworzenia nowego projektu lub wykorzystania już istniejącego; jeśli utworzysz nowe działanie inne niż Compose, możesz użyć opcji DesertActivity i nadać mu dowolną nazwę.
2. Jeśli masz już skonfigurowany projekt, możesz pominąć ten krok. Jeśli zdecydujesz się na utworzenie nowego projektu, będziesz mieć MainActivity, a ponieważ jest to stary sposób tworzenia widoków, zauważysz układ XML w folderze zasobów z TextView, który ma Hello world. Możemy to usunąć, ponieważ nie będziemy go używać.
3. Jeśli masz już gotowy projekt, możesz uruchomić PowitanieDialog na dowolnym ekranie. Ponadto, jeśli zdecydujesz się utworzyć przycisk zamiast okna dialogowego, to też jest w porządku, ponieważ chodzi o pokazanie, jak możemy używać tagów XML w Jetpack Compose.
4. Teraz przejdźmy dalej i dodajmy tag XML do pliku Activity_main.xml i nadajmy naszemu widokowi Compose wartość identyfikatora. Gdy dodasz ComposeView po raz pierwszy, pojawi się komunikat o błędzie, jeśli nadal będziesz musiał dodać zależność. Śmiało i kliknij Dodaj zależność od Android.compose. ui:ui, a projekt zostanie zsynchronizowany, jak pokazano na rysunku
5. Po zsynchronizowaniu projektu błąd zniknie i powinieneś móc używać tego widoku w MainActivity lub tam, gdzie chcesz używać ComposeView:
android:layout_width="match_parent"
android:layout_height="match_parent"/>
6. Dodajmy także viewBinding do naszego build.gradle(Module:app), abyśmy mogli łatwo uzyskać dostęp do naszego widoku w MainActivity. Ponadto, jeśli masz już skonfigurowane viewBinding, możesz pominąć tę część:
buildFeatures{
viewBinding true
}
7. Po zsynchronizowaniu projektu możemy przejść dalej i w MainActivity uzyskać dostęp do ComposeView poprzez powiązanie. Co więcej, będzie zawierała metodę setContent{}, w której możesz ustawić wszystkie swoje obiekty Composable i zawinąć je w swój motyw:
class MainActivity : AppCompatActivity() {
private lateinit var activityBinding:
ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?)
{
super.onCreate(savedInstanceState)
activityBinding =
ActivityMainBinding.inflate(layoutInflater)
setContentView(activityBinding.root)
activityBinding.alertDialog.setContent {
GreetingAlertDialog()
}
}
}
8. Nasza PowitanieAlertDialog() będzie miała AlertDialog() Composable, tytuł i tekst, który dostarczy naszą wiadomość jako prosty element tekstowy. Tytuł będzie brzmieć "Witam", ponieważ jest to powitanie, a wiadomość będzie brzmieć "Witam i dziękuję za bycie częścią społeczności Androida". Możesz dostosować to do swoich potrzeb:
@Composable
fun SimpleAlertDialog() {
AlertDialog(
onDismissRequest = { },
confirmButton = {
TextButton(onClick = {})
{ Text(text = "OK") }
},
dismissButton = {
TextButton(onClick = {})
{ Text(text = "OK") }
},
title = { Text(text = "Hello") },
text = { Text(text = "Hello, and thank you for
being part of the Android community") }
)
}
9. Aby utworzyć komponenty Compose, musisz dodać zależność Compose Material Design do swojej aplikacji gradle. W zależności od tego, co obsługuje Twoja aplikacja, możesz wykorzystać komponenty Compose Material 3, które stanowią kolejną ewolucję Material Design i mają zaktualizowany motyw.
10. Możesz łatwo dostosować funkcje, takie jak dynamiczny kolor i inne. Dlatego na razie, ponieważ aplikacja, z której korzystam, nie została zmigrowana do Material 3, skorzystam z tego importu - implementacji "androidx.Compose. material:material:1.x.x". Tutaj możesz użyć dowolnego importu, który odpowiada Twoim potrzebom.
11. Możesz także utworzyć niestandardowy widok, który stanowi kontynuację AbstractComposeView:
class ComposeAlertDialogComponent @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null,
defStyle: Int = 0
) : AbstractComposeView(context, attrs, defStyle) {
@Composable
override fun Content() {
GreetingAlertDialog()
}
}
12. Na koniec, po uruchomieniu aplikacji, powinno pojawić się okno dialogowe z tytułem i tekstem; Rysunek przedstawia okno dialogowe z już istniejącego projektu, więc na pewno będzie się różnić w zależności od wykonanych kroków:
Jak to działa…
Najpierw powiększamy układ XML, który definiujemy w naszym folderze zasobów układu. Następnie, używając wiązania, otrzymaliśmy ComposeView przy użyciu utworzonego identyfikatora XML, ustawiliśmy strategię Compose, która najlepiej sprawdza się w przypadku naszego widoku hosta, i wywołaliśmy setContent, aby użyć Compose. Aby w swojej działalności móc utworzyć dowolny ekran oparty na Compose, musisz upewnić się, że wywołałeś metodę setContent{} i przekazałeś dowolną utworzoną funkcję Composable. Aby dokładniej poznać metodę setContent, została ona napisana jako funkcja rozszerzenia ComponentActivity i oczekuje funkcji Composable jako ostatniego parametru. Istnieje również lepszy sposób zademonstrowania działania setContent{} w celu zintegrowania drzewa Composable z aplikacją na Androida.
ViewCompositionStrategy pomaga określić, kiedy pozbyć się kompozycji; stąd widoki interfejsu użytkownika Compose, takie jak ComposeView i AbstractComposeView, korzystają z ViewCompositonStrategy, która pomaga zdefiniować to zachowanie.
Zrozumienie i obsługa rekompozycji w Jetpack Compose
Jetpack Compose jest wciąż bardzo nowym rozwiązaniem i wiele firm zaczyna z niego korzystać. Co więcej, Google wykonało świetną robotę, udostępniając programistom obszerną dokumentację pomagającą im wdrożyć nowy zestaw narzędzi interfejsu użytkownika. Jednak pomimo całej dokumentacji, jedno pojęcie wymaga wyjaśnienia. I to jest rekompozycja. To prawda, każde nowe oprogramowanie ma swoje zalety i wady, a im więcej osób zaczyna z niego korzystać, tym więcej osób zaczyna przekazywać opinie - stąd potrzeba dalszych ulepszeń. Rekompozycja w aplikacji Compose polega na ponownym wywołaniu funkcji Composable po zmianie danych wejściowych. Możesz też o tym pomyśleć, gdy zmieni się struktura kompozycji i relacja. O ile jej parametry nie ulegną zmianie, chcemy uniknąć ponownego wywoływania funkcji Composable w większości przypadków użycia. Zatem w tym przepisie przyjrzymy się, jak zachodzi rekompozycja oraz w jaki sposób można debugować i rozwiązywać wszelkie rekompozycje w aplikacji.
Jak to zrobić…
Ponieważ nasz system widoków jest prosty, sprawdzimy, czy w naszym projekcie Login mamy jakąś rekompozycję:
1. Możemy spojrzeć na prosty przykład i zobaczyć, jak nastąpi rekompozycja:
@Composable
fun UserDetails(
name: String,
gender: String,
) {
Box() {
Text(name)
Spacer()
Text(gender)
}}
W naszym przykładzie funkcja Tekst zostanie ponownie ułożona po zmianie imienia, a nie po zmianie płci. Ponadto wartość wejściowa gender:String zostanie ponownie ułożona tylko w przypadku zmiany płci.
2. Możesz także uruchomić Inspektora układu i wykorzystać go do debugowania rekompozycji. Jeśli nie ma go w stacji dokującej Android Studio, możesz go uruchomić, przechodząc do Widok | Okna narzędziowe | Inspektor układu. Zajrzymy do LoginContent i sprawdzimy, czy mamy jakąś rekompozycję.
3. Po uruchomieniu Inspektora układu upewnij się, że masz podłączony do niego emulator.
4. Śmiało, rozwiń punkt wejściowy SampleLoginTheme, a zauważysz, że nasz obecny system widoku nie jest skomplikowany. Jak widać, Inspektor układu nie pokazuje żadnych liczników rekompozycji. Oznacza to, że gdyby nasza aplikacja zawierała jakiekolwiek liczniki rekompozycji, wyświetliłyby się one w Inspektorze układu.
5. Wreszcie, jak zauważyłeś, w naszej aplikacji nie zachodzi żadna rekompozycja, ale zawsze warto sprawdzić aplikację, aby dowiedzieć się, co może być przyczyną rekompozycji i ją naprawić.
Ważna uwaga
Korzystanie z efektów ubocznych może spowodować, że użytkownicy Twojej aplikacji doświadczą dziwnego i nieprzewidywalnego zachowania w Twojej aplikacji. Ponadto efektem ubocznym jest każda zmiana widoczna w pozostałej części aplikacji. Na przykład zapisywanie właściwości obiektu współdzielonego, aktualizacja obserwowalnego w ViewModel i aktualizacja współdzielonych preferencji to niebezpieczne skutki uboczne.
Jak to działa…
Aby ułatwić adaptację, Compose pomija wywołania lambda i wszelkie funkcje podrzędne, które nie mają żadnych zmian na wejściu. Lepsza obsługa zasobów ma sens, ponieważ w aplikacji Compose animacje i inne elementy interfejsu użytkownika mogą powodować rekompozycję w każdej klatce. Możemy zagłębić się w szczegóły i użyć diagramu, aby pokazać, jak działa cykl życia kompozycji Jetpack. Krótko mówiąc, cykl życia funkcji Composable jest definiowany przez trzy istotne zdarzenia:
• Bycie opanowanym
• Ponowne skomponowanie lub brak przekomponowania
• Nie jest już skomponowany
Aby zrozumieć, jak działa Compose, warto wiedzieć, co składa się na warstwę architektoniczną Compose. Ogólny przegląd warstwy architektonicznej Jetpack Compose obejmuje aspekty Material, Foundation, UI i Runtime.
W Material ten moduł implementuje system Material Design dla interfejsu użytkownika Compose. Ponadto zapewnia system motywów, stylizowane komponenty i wiele więcej. Fundament to miejsce, w którym mamy elementy składowe systemu projektowania, takie jak interfejs użytkownika, wiersz, kolumna i inne. Warstwa interfejsu użytkownika składa się z wielu modułów, które implementują podstawy zestawu narzędzi interfejsu użytkownika.
iOS 16
Zapoznanie się z Xcode
Mam nadzieję, że uznasz to za przydatne wprowadzenie do tworzenia i publikowania aplikacji na iOS 16 w App Store. Tu dowiesz się, jak pobrać i zainstalować Xcode na komputerze Mac. Zapoznasz się z różnymi częściami interfejsu użytkownika Xcode, utworzysz swoją pierwszą aplikację na iOS i uruchomisz ją w symulatorze iOS. Następnie dowiesz się, jak podłączyć urządzenie iOS do Xcode przez USB, aby móc na nim uruchomić aplikację, jak dodać Apple ID do Xcode, aby można było utworzyć i zainstalować niezbędne certyfikaty cyfrowe na swoim urządzeniu oraz jak ufać certyfikat na swoim urządzeniu. Na koniec dowiesz się, jak połączyć się z urządzeniem przez Wi-Fi, dzięki czemu nie musisz już podłączać urządzenia za każdym razem, gdy chcesz uruchomić aplikację. Pod koniec tego rozdziału będziesz wiedział, jak tworzyć i uruchamiać aplikacje na symulatorze lub urządzeniu iOS, co będzie potrzebne podczas tworzenia własnych aplikacji. W tej części zostaną poruszone następujące tematy:
• Pobieranie i instalowanie Xcode z App Store
• Zrozumienie interfejsu użytkownika Xcode
• Uruchomienie aplikacji w symulatorze iOS
• Używanie urządzenia iOS do programowania
Wymagania techniczne
Do wykonania ćwiczeń potrzebne będą:
• Komputer Apple Mac (Apple Silicon lub Intel) z systemem macOS 12 Monterey lub macOS 13 Ventura
• Apple ID
• Opcjonalnie urządzenie iOS z systemem iOS 16
Pobieranie i instalowanie Xcode ze sklepu App Store
Xcode to zintegrowane środowisko programistyczne (IDE) firmy Apple do tworzenia aplikacji na iOS. Zanim zaczniesz pisać swoją pierwszą aplikację na iOS, musisz pobrać i zainstalować Xcode ze sklepu App Store na komputerze Mac. Aby to zrobić, wykonaj następujące kroki:
1. Wybierz App Store z menu Apple.
2. W polu wyszukiwania w prawym górnym rogu wpisz Xcode i naciśnij klawisz Return.
3. Powinieneś zobaczyć Xcode w wynikach wyszukiwania. Kliknij Pobierz, a następnie Zainstaluj.
4. Jeśli masz Apple ID, wpisz go w polu tekstowym Apple ID. Jeśli go nie masz, kliknij przycisk Utwórz Apple ID i postępuj zgodnie ze szczegółowymi instrukcjami, aby go utworzyć
5. Po zainstalowaniu Xcode uruchom go. Powinieneś zobaczyć ekran Umowy licencyjnej. Kliknij Zgadzam się
6. Zostaniesz poproszony o podanie nazwy użytkownika i hasła administratora komputera Mac. Gdy już to zrobisz, kliknij OK
7. Zobaczysz ekran pokazujący dostępne platformy programistyczne. Na razie potrzebujesz tylko komputera Mac i systemu iOS. Pozostaw ustawienia na wartości domyślne i kliknij Zainstaluj
8. Jeśli używasz komputera Apple Silicon Mac i nie zainstalowałeś jeszcze aplikacji Rosetta, która umożliwia uruchamianie aplikacji Mac z procesorem Intel na komputerach Apple Silicon Mac, zostaniesz poproszony o jej teraz zainstalowanie. Kliknij Zainstaluj
9. Powinieneś zobaczyć następujący ekran Witamy w Xcode. Kliknij opcję Utwórz nowy projekt Xcode w lewym panelu
10. Zobaczysz ekran nowego projektu w następujący sposób. W sekcji Wybierz szablon dla swojego nowego projektu: wybierz iOS. Następnie wybierz Aplikacja i kliknij Dalej
11. Zobaczysz ekran Wybierz opcje dla swojego nowego projektu:
Skonfiguruj opcje pokazane na poprzednim zrzucie ekranu w następujący sposób:
• Nazwa produktu: nazwa Twojej aplikacji. Wpisz ExploringXcode w polu tekstowym.
• Identyfikator organizacji: używany do tworzenia unikalnego identyfikatora aplikacji w App Store. Na razie wpisz com.yourname. Nazywa się to formatem odwrotnej notacji nazwy domeny i jest powszechnie używany przez programistów iOS.
• Interfejs: Metoda używana do tworzenia interfejsu użytkownika aplikacji. Ustaw to na Storyboard.
• Język: używany język programowania. Ustaw to na Swift.
Pozostaw pozostałe ustawienia jako wartości domyślne i upewnij się, że wszystkie pola wyboru są odznaczone. Po zakończeniu kliknij Dalej.
12. Zobaczysz okno dialogowe Zapisz. Wybierz lokalizację, w której chcesz zapisać projekt, na przykład folder Pulpit lub Dokumenty, i kliknij Utwórz
13. Zobaczysz okno dialogowe z informacją, że utworzenie repozytorium Git nie powiodło się, kliknij Napraw.
14. Zobaczysz ekran ustawień kontroli źródła
Wprowadź następujące informacje:
• Imię autora: Twoje własne imię i nazwisko
• E-mail autora: Twój adres e-mail
Po zakończeniu zamknij ekran ustawień Kontroli źródła, klikając czerwony przycisk Zamknij w lewym górnym rogu. Pojawi się główne okno Xcode. Fantastyczny! Pomyślnie pobrałeś i zainstalowałeś Xcode oraz utworzyłeś swój pierwszy projekt. W następnej sekcji poznasz interfejs użytkownika Xcode.
Zrozumienie interfejsu użytkownika Xcode
Właśnie stworzyłeś swój pierwszy projekt Xcode! Jak widać, interfejs użytkownika Xcode jest podzielony na kilka odrębnych części, jak pokazano tutaj:
Przyjrzyjmy się każdej części bardziej szczegółowo. Poniższy opis odpowiada numerom pokazanym na powyższym zrzucie ekranu:
• Pasek narzędzi (1) - służy do tworzenia i uruchamiania aplikacji oraz przeglądania postępu uruchomionych zadań.
• Obszar nawigatora (2) - zapewnia szybki dostęp do różnych części projektu. Domyślnie wyświetlany jest nawigator projektu.
• Obszar edytora (3) - umożliwia edycję kodu źródłowego, interfejsów użytkownika i innych zasobów.
• Obszar inspektora (4) - umożliwia przeglądanie i edycję informacji o elementach wybranych w obszarze nawigatora lub obszarze edytora.
• Obszar debugowania (5) - zawiera pasek debugowania, widok zmiennych i konsolę. Obszar debugowania można przełączać, wpisując Shift + Command + Y.
Następnie przyjrzyjmy się bliżej Paskowi narzędzi. Lewa strona paska narzędzi jest pokazana tutaj:
Przyjrzyjmy się każdej części bardziej szczegółowo. Poniższy opis odpowiada numerom pokazanym na powyższym zrzucie ekranu:
• Przycisk Nawigatora (1) - włącza i wyłącza obszar Nawigatora.
• Przycisk Stop (2) - pojawia się obok przycisku Odtwórz tylko wtedy, gdy aplikacja jest uruchomiona. Zatrzymuje aktualnie uruchomioną aplikację.
• Przycisk Odtwórz (3) - służy do tworzenia i uruchamiania aplikacji.
• Menu Schemat (4) - pokazuje konkretny schemat tworzenia projektu (ExploringXcode) i miejsce docelowe, na którym można uruchomić aplikację (iPhone SE (3. generacji)).
Schematy i miejsca docelowe są różne. Schematy określają ustawienia dotyczące budowania i uruchamiania projektu. Miejsca docelowe określają lokalizacje instalacji aplikacji i istnieją dla urządzeń fizycznych i symulatorów.
• Widok aktywności (5) - Wyświetla postęp uruchomionych zadań. Prawa strona paska narzędzi jest pokazana tutaj:
Przyjrzyjmy się każdej części bardziej szczegółowo. Poniższy opis odpowiada numerom pokazanym na powyższym zrzucie ekranu:
• Przycisk Biblioteka (1) - wyświetla elementy interfejsu użytkownika, fragmenty kodu i inne zasoby.
• Przycisk Inspektora (2) - włącza i wyłącza obszar Inspektora.
Nie daj się przytłoczyć różnymi częściami, ponieważ dowiesz się o nich bardziej szczegółowo w późniejszych częściach. Teraz, gdy znasz już interfejs Xcode, uruchomisz właśnie utworzoną aplikację w symulatorze iOS, który wyświetli reprezentację Twojego urządzenia iOS.
Uruchamianie aplikacji w symulatorze iOS
Symulator systemu iOS jest instalowany podczas instalacji Xcode. Zapewnia symulowane urządzenie z systemem iOS, dzięki czemu możesz zobaczyć, jak wygląda Twoja aplikacja i jak się zachowuje, bez konieczności posiadania fizycznego urządzenia z systemem iOS. Może modelować wszystkie rozmiary i rozdzielczości ekranów zarówno dla iPada, jak i iPhone′a, dzięki czemu możesz łatwo testować swoją aplikację na wielu urządzeniach. Aby uruchomić aplikację w symulatorze, wykonaj następujące kroki:
1. Kliknij menu Schemat na pasku narzędzi, a zobaczysz listę symulatorów. Z tego menu wybierz iPhone′a SE (3. generacji).
2. Kliknij przycisk Odtwórz, aby zainstalować i uruchomić aplikację na aktualnie wybranym symulatorze. Możesz także użyć skrótu klawiaturowego Command + R.
3. Symulator uruchomi się i wyświetli reprezentację iPhone′a SE (3. generacji). Twoja aplikacja wyświetla biały ekran, ponieważ nie dodałeś jeszcze niczego do swojego projektu
4. Wróć do Xcode i kliknij przycisk Stop (lub naciśnij Command + .), aby zatrzymać aktualnie uruchomiony projekt.
Właśnie utworzyłeś i uruchomiłeś w symulatorze swoją pierwszą aplikację na iOS! Dobra robota! Jeśli spojrzysz na menu Schemat, możesz się zastanawiać, do czego służą sekcje Urządzenia i Kompilacja. Przyjrzyjmy się im w następnej sekcji.
Zrozumienie sekcji Urządzenia i Budowa
W poprzedniej sekcji dowiedziałeś się, jak wybrać symulator w menu Schemat, aby uruchomić aplikację. Umożliwia uruchamianie aplikacji na rzeczywistych urządzeniach z systemem iOS i przygotowywanie aplikacji do przesłania do App Store. Kliknij menu Schemat na pasku narzędzi, aby wyświetlić sekcje Urządzenia i Kompilacja u góry menu. Jeśli masz komputer Mac Apple Silicon, w sekcji Urządzenia zostanie wyświetlony tekst Mój Mac (zaprojektowany dla iPada), ponieważ na komputerach Apple Silicon Mac można uruchamiać aplikacje dla systemu iOS. W przeciwnym razie zostanie wyświetlony komunikat Brak urządzeń. Jeśli podłączysz urządzenie z systemem iOS, pojawi się ono w tej sekcji i będziesz mógł uruchamiać opracowane na nim aplikacje w celu przetestowania. Zaleca się uruchamianie aplikacji na rzeczywistym urządzeniu, ponieważ symulator nie będzie dokładnie odzwierciedlał charakterystyki wydajności rzeczywistego urządzenia z systemem iOS i nie ma niektórych funkcji sprzętowych ani interfejsów API oprogramowania, które
mają rzeczywiste urządzenia. Sekcja Kompilacja zawiera tylko jedną pozycję menu: Dowolne urządzenie iOS. Jest to używane, gdy musisz zarchiwizować aplikację przed przesłaniem jej do App Store. Dowiesz się, jak to zrobić w rozdziale 27, Testowanie i przesyłanie aplikacji do App Store. Zobaczmy teraz, jak zbudować i uruchomić aplikację na prawdziwym urządzeniu z systemem iOS. Zdecydowana większość instrukcji zawartych w tym tekście nie wymaga jednak posiadania urządzenia z systemem iOS, więc jeśli go nie masz, możesz pominąć następną sekcję i przejść od razu do Części 2, Proste wartości i typy.
Używanie urządzenia iOS do programowania
Chociaż większość ćwiczeń będzie można wykonać za pomocą symulatora, zaleca się tworzenie i testowanie aplikacji na rzeczywistym urządzeniu z systemem iOS, ponieważ symulator nie będzie w stanie symulować niektórych komponentów sprzętowych ani interfejsów API oprogramowania . Oprócz urządzenia będziesz potrzebować Apple ID lub płatnego konta Apple Developer, aby zbudować i uruchomić aplikację na swoim urządzeniu. Na razie będziesz używać tego samego Apple ID, którego użyłeś do pobrania Xcode z App Store. Wykonaj następujące kroki:
1. Użyj kabla dostarczonego z urządzeniem iOS, aby podłączyć urządzenie do komputera Mac i upewnij się, że urządzenie iOS jest odblokowane.
2. Twoje urządzenie iOS wyświetli alert Zaufaj temu komputerowi. Kliknij Zaufaj i po wyświetleniu monitu wprowadź hasło urządzenia.
3. Twój Mac wyświetli powiadomienie Zezwól akcesorium na połączenie. Kliknij Zezwalaj. Twoje urządzenie iOS powinno być teraz podłączone do komputera Mac i pojawi się w menu Schemat Xcode.
Możesz przeglądać podłączone urządzenia wybierając Okno | Urządzenia i symulatory na pasku menu Xcode
4. Zwróć uwagę, że w menu Schemat Twoje urządzenie z systemem iOS nie ma włączonego trybu programisty:
Tryb programisty został wprowadzony przez firmę Apple podczas konferencji programistów World Wide Developer w 2022 r. (WWDC 2022) i jest wymagany do instalowania, uruchamiania i debugowania aplikacji na urządzeniach z systemem iOS 16.
5. Jeśli spróbujesz zbudować i uruchomić aplikację na urządzeniu z systemem iOS, zobaczysz następujący alert:
6. Aby włączyć tryb programisty na swoim urządzeniu iOS, przejdź do Ustawienia | Prywatność i bezpieczeństwo, przewiń w dół do elementu Tryb programisty i dotknij go.
7. Włącz przełącznik Tryb programisty:
8. Pojawi się alert ostrzegający, że tryb programisty zmniejsza bezpieczeństwo Twojego urządzenia iOS. Stuknij przycisk Uruchom ponownie alertu.
9. Po ponownym uruchomieniu urządzenia iOS i jego odblokowaniu potwierdź, że chcesz włączyć tryb programisty, dotykając opcji Włącz i wprowadzając hasło urządzenia iOS.
10. Sprawdź, czy (Tryb programisty wyłączony) nie jest już wyświetlany obok urządzenia iOS w menu Schemat. Twoje urządzenie z systemem iOS jest teraz gotowe do instalowania i uruchamiania aplikacji z Xcode:
11. Poczekaj, aż Xcode zakończy indeksowanie i przetwarzanie, co zajmie trochę czasu. Po zakończeniu tej czynności w oknie stanu zostanie wyświetlony komunikat Gotowy
12. Uruchom projekt klikając przycisk Odtwórz (lub użyj Command + R). Pojawi się następujący błąd: Signing for "ExploringXcode" requires a development team:
Dzieje się tak, ponieważ do uruchomienia aplikacji na urządzeniu z systemem iOS wymagany jest certyfikat cyfrowy i musisz dodać identyfikator Apple ID lub płatne konto Apple Developer do Xcode, aby można było wygenerować certyfikat cyfrowy. Korzystanie z Apple ID umożliwi testowanie aplikacji na urządzeniu z systemem iOS, ale do rozpowszechniania aplikacji w App Store potrzebne będzie płatne konto Apple Developer. Certyfikaty zapewniają, że na Twoim urządzeniu działają tylko te aplikacje, które autoryzowałeś. Pomaga to chronić przed złośliwym oprogramowaniem
13. Kliknij przycisk Dodaj konto…:
14. Pojawi się okno Ustawienia Xcode z wybranym panelem Konta. Wprowadź swój Apple ID i kliknij Dalej:
Pamiętaj, że możesz utworzyć inny identyfikator Apple ID, jeśli chcesz, korzystając z przycisku Utwórz Apple ID. Dostęp do ustawień Xcode można także uzyskać, wybierając opcję Ustawienia w menu Xcode.
15. Po wyświetleniu monitu wprowadź hasło. Po kilku minutach w panelu Konta zostaną wyświetlone ustawienia Twojego konta:
16. Po zakończeniu zamknij okno Ustawienia, klikając czerwony przycisk Zamknij w lewym górnym rogu.
17. W obszarze Edytora Xcode kliknij Podpisywanie i możliwości. Upewnij się, że jest zaznaczona opcja Automatycznie zarządzaj podpisywaniem i wybierz opcję Zespół osobisty z wyskakującego menu Zespół:
18. Jeśli nadal widzisz błędy na tym ekranie, spróbuj zmienić identyfikator pakietu, wpisując w niego kilka losowych znaków, na przykład com.myname4352.ExploringXcode.
19. Po zbudowaniu i uruchomieniu wszystko powinno działać, a Twoja aplikacja zostanie zainstalowana na Twoim urządzeniu z systemem iOS. Jednak nie uruchomi się i zobaczysz następujący komunikat:
Oznacza to, że musisz zaufać certyfikatowi zainstalowanemu na Twoim urządzeniu. Dowiesz się, jak to zrobić w następnej sekcji.
Zaufanie certyfikatowi aplikacji deweloperskiej na urządzeniu z systemem iOS
Certyfikat aplikacji dla programistów to specjalny plik instalowany na urządzeniu z systemem iOS wraz z aplikacją.
Zanim Twoja aplikacja będzie mogła działać, musisz jej zaufać. Wykonaj następujące kroki:
1. Na urządzeniu z systemem iOS dotknij Ustawienia| Ogólne | Zarządzanie VPN i urządzeniami:
2. Stuknij opcję Apple Development:
3. Stuknij Trust "Apple Development":
4. Stuknij Trust:
5. Powinieneś zobaczyć następujący tekst, który oznacza, że aplikacja jest teraz zaufana:
6. Kliknij przycisk Odtwórz w Xcode, aby skompilować i uruchomić ponownie. Zobaczysz, jak aplikacja uruchamia się i działa na urządzeniu z systemem iOS.
Gratulacje! Pamiętaj, że aby skompilować i uruchomić aplikację, musisz podłączyć urządzenie iOS do komputera Mac za pomocą kabla. W następnej sekcji dowiesz się, jak połączyć się z urządzeniem przez Wi-Fi.
Podłączanie urządzenia iOS bezprzewodowo
Odłączanie i ponowne podłączanie urządzenia iOS do komputera Mac może po pewnym czasie stać się dość kłopotliwe, dlatego teraz skonfigurujesz Xcode tak, aby łączył się z urządzeniem iOS przez Wi-Fi. Wykonaj następujące kroki:
1. Upewnij się, że urządzenie iOS jest podłączone do komputera Mac oraz że zarówno Mac, jak i urządzenie iOS znajdują się w tej samej sieci bezprzewodowej.
2. Wybierz Okno | Urządzenia i symulatory z paska menu Xcode:
3. Kliknij pole wyboru Connect via network:
Wspaniale! Twoje urządzenie iOS jest teraz połączone bezprzewodowo z Xcode i nie potrzebujesz już kabla USB, aby go podłączyć.
Streszczenie
Nauczyłeś się, jak pobrać i zainstalować Xcode na komputerze Mac. Zapoznałeś się z różnymi częściami interfejsu użytkownika Xcode. Utworzyłeś swoją pierwszą aplikację na iOS, wybrałeś symulator, zbudowałeś i uruchomiłeś aplikację. Dowiedziałeś się, do czego służą pozycje menu Urządzenia i Kompilacja. Możesz teraz tworzyć i uruchamiać aplikacje na iOS na komputerze Mac bez konieczności posiadania urządzenia z systemem iOS. Nauczyłeś się, jak podłączyć urządzenie iOS do Xcode przez USB, aby móc uruchomić na nim aplikację. Dodałeś identyfikator Apple ID do Xcode, aby można było utworzyć i zainstalować niezbędne certyfikaty cyfrowe na swoim urządzeniu oraz zaufać certyfikatowi na swoim urządzeniu. Dzięki temu możesz uruchamiać aplikacje na rzeczywistym urządzeniu, dzięki czemu możesz dokładniej określić ich wydajność i skorzystać z funkcji niedostępnych w symulatorze iOS. Wreszcie nauczyłeś się, jak łączyć się z urządzeniem przez Wi-Fi, więc nie musisz już podłączać urządzenia za każdym razem, gdy chcesz uruchomić aplikację. Dzięki temu tworzenie i testowanie aplikacji na urządzeniu z systemem iOS jest znacznie wygodniejsze, ponieważ wszelkie nowe kompilacje można natychmiast przesyłać bezprzewodowo.
Proste wartości i typy
Teraz, gdy odbyłeś już krótką wycieczkę po Xcode, przyjrzyjmy się językowi programowania Swift. Najpierw poznasz place zabaw Swift, interaktywne środowisko, w którym możesz wpisać kod Swift i natychmiast wyświetlić wyniki. Następnie dowiesz się, jak Swift reprezentuje i przechowuje różne typy danych. Następnie zapoznasz się z kilkoma fajnymi funkcjami Swifta, takimi jak wnioskowanie o typie i bezpieczeństwo typów, które pomogą Ci pisać kod w sposób bardziej zwięzły i unikać typowych błędów. Na koniec dowiesz się, jak wykonywać typowe operacje na danych i jak drukować komunikaty w obszarze debugowania, aby pomóc w rozwiązywaniu problemów. Pod koniec tej części powinieneś umieć pisać proste programy przechowujące i przetwarzające litery i cyfry.
Zrozumienie placów zabaw Swift
Place zabaw to interaktywne środowiska kodowania. Wpisujesz kod w lewym panelu, a wyniki są natychmiast wyświetlane w prawym panelu. To świetny sposób na eksperymentowanie z kodem i odkrywanie systemowych interfejsów API. Zacznijmy od stworzenia nowego placu zabaw i sprawdzenia jego interfejsu użytkownika. Wykonaj następujące kroki:
1. Aby utworzyć plac zabaw, uruchom Xcode i wybierz Plik | Nowy | Plac zabaw... z paska menu Xcode:
2. Pojawi się ekran szablonu. iOS powinien być już wybrany. Wybierz opcję Puste i kliknij Dalej:
3. Nazwij swój plac zabaw SimpleValues i zapisz go w dowolnym miejscu. Po zakończeniu kliknij Utwórz:
4. Na ekranie powinieneś zobaczyć plac zabaw:
Jak widać, jest to znacznie prostsze niż projekt Xcode. Przyjrzyjmy się interfejsowi bardziej szczegółowo:
• Przycisk Nawigatora (1) - Pokazuje lub ukrywa obszar Nawigatora
• Widok aktywności (2) - Pokazuje bieżącą operację lub stan
• Przycisk Biblioteka (3) - wyświetla fragmenty kodu i inne zasoby
• Przycisk Inspektora (4) - Pokazuje lub ukrywa obszar Inspektora
• Obszar nawigatora (5) - zapewnia szybki dostęp do różnych części projektu. Domyślnie wyświetlany jest nawigator projektu
• Obszar edytora (6) - tutaj piszesz kod
• Obszar wyników (7) - zapewnia natychmiastową informację zwrotną na temat napisanego kodu
• Przycisk Play (8) - Wykonuje kod z wybranej linii
• Obramowanie (9) - Ta ramka oddziela obszary Edytora i Wyniki. Jeśli stwierdzisz, że wyniki wyświetlane w obszarze Wyniki są obcięte, przeciągnij ramkę w lewo, aby zwiększyć jej rozmiar
• Przycisk Odtwórz/Zatrzymaj (10) - Wykonuje lub zatrzymuje wykonywanie całego kodu na placu zabaw
• Obszar debugowania (11) - Wyświetla wyniki polecenia print().
• Przycisk Debug (12) - Pokazuje i ukrywa obszar Debug
Kod na placu zabaw może okazać się zbyt mały i trudny do odczytania.
Dostosowywanie czcionek i kolorów
Xcode oferuje rozbudowane opcje dostosowywania. Dostęp do nich można uzyskać w menu Ustawienia… Jeśli okaże się, że tekst jest mały i słabo widoczny, wykonaj następujące kroki:
1. Wybierz Ustawienia…z menu Xcode, aby wyświetlić okno preferencji.
2. W oknie ustawień kliknij Motywy i wybierz Prezentacja (Lekka), aby powiększyć kod i uczynić go łatwiejszym do odczytania:
3. Zamknij okno ustawień, aby powrócić do placu zabaw. Zwróć uwagę, że tekst na placu zabaw jest większy niż wcześniej. Jeśli chcesz, możesz także wypróbować inne motywy. Teraz, gdy już dostosowałeś czcionki i kolory do swoich upodobań, zobaczmy, jak uruchomić kod na placu zabaw w następnej sekcji.
Uruchamianie kodu placu zabaw
Twój plac zabaw zawiera już instrukcję. Aby wykonać instrukcję, wykonaj następujące kroki:
1. Kliknij przycisk Odtwórz/Zatrzymaj w lewym dolnym rogu placu zabaw. W obszarze wyników wyświetli się komunikat "Witaj, placu zabaw":
Możesz użyć skrótu klawiaturowego Command + Shift + Return, aby uruchomić kod na swoim placu zabaw.
Aby przygotować plac zabaw do użycia w pozostałej części , usuń z placu zabaw instrukcję var pozdrowienia = "Witam, plac zabaw". W trakcie gry wpisz kod pokazany w tej części na placu zabaw i kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić. W następnej sekcji zajmiemy się prostymi typami danych używanymi w Swift.
Eksploracja typów danych
Wszystkie języki programowania mogą przechowywać liczby, stany logiczne i słowa, a Swift nie jest wyjątkiem. Nawet jeśli jesteś doświadczonym programistą, może się okazać, że Swift reprezentuje te obiekty inaczej niż inne języki, które możesz znać. W następnych sekcjach omówimy wersje Swift liczb całkowitych, liczb zmiennoprzecinkowych, wartości logicznych i ciągów znaków.
Reprezentowanie liczb całkowitych
Załóżmy, że chcesz przechowywać następujące informacje:
• Liczba restauracji w mieście
• Pasażerowie samolotu
• Pokoje w hotelu
Można by użyć liczb całkowitych, czyli liczb bez elementu ułamkowego (w tym liczb ujemnych). Liczby całkowite w języku Swift są reprezentowane przez typ Int.
Reprezentowanie liczb zmiennoprzecinkowych
Załóżmy, że chcesz przechowywać następujące informacje:
• Pi (3.14159…)
• Zero absolutne (-273,15°°C)
Można użyć liczb zmiennoprzecinkowych, które są liczbami ze składnikiem ułamkowym. Domyślnym typem liczb zmiennoprzecinkowych w języku Swift jest Double, który wykorzystuje 64 bity, w tym liczby ujemne. Możesz także użyć Float, który używa 32 bitów, ale Double jest reprezentacją domyślną.
Reprezentowanie wartości logicznych
Załóżmy, że chcesz przechowywać odpowiedzi na proste pytania typu "tak/nie", takie jak następujące:
• Czy pada deszcz?
• Czy w restauracji są wolne miejsca?
W tym celu używasz wartości logicznych. Swift udostępnia typ Bool, który można przypisać jako prawdziwy lub fałszywy.
Reprezentowanie ciągów
Załóżmy, że chcesz przechowywać następujące informacje:
• Nazwa restauracji, np. "Bombay Palace"
• Opis stanowiska, np. "Księgowy" lub "Programista"
• Rodzaj owocu, np. "banan"
Można użyć typu String Swifta, który reprezentuje sekwencję znaków i jest w pełni zgodny z Unicode. Ułatwia to reprezentowanie różnych czcionek i języków. Teraz, gdy już wiesz, jak Swift reprezentuje te popularne typy danych, wypróbujmy je na placu zabaw, który utworzyłeś wcześniej w następnej sekcji.
Używanie popularnych typów danych na placu zabaw
Wszystko, co wpiszesz na placu zabaw, zostanie wykonane, a wyniki pojawią się w obszarze Wyniki. Zobaczmy, co się stanie, gdy wpiszesz liczby, wartości logiczne i ciągi znaków na swoim obszarze i wykonaj to. Wykonaj następujące kroki:
1. Wpisz następujący kod w obszarze edytora swojego placu zabaw:
// Proste wartości
42
-23
3.14159
0,1
-273,15
PRAWDA
FAŁSZ
"Witaj świecie"
"albatros"
Należy pamiętać, że komentarze nie są wyświetlane w obszarze Wyniki.
Fajnie! Właśnie stworzyłeś i uruchomiłeś swój pierwszy plac zabaw. Przyjrzyjmy się, jak przechowywać różne typy danych w następnej sekcji.
Badanie stałych i zmiennych
Teraz, gdy wiesz już o prostych typach danych obsługiwanych przez Swift, przyjrzyjmy się, jak je przechowywać, tzw. możesz później wykonywać na nich operacje. Do przechowywania danych można używać stałych lub zmiennych. Obydwa są kontenerami, które mają nazwę, ale stałą wartość można ustawić tylko raz i nie można jej zmienić po ich ustawieniu, podczas gdy wartość zmiennej można zostać zmieniona w dowolnym momencie. Musisz zadeklarować stałe i zmienne przed ich użyciem. Stałe deklaruje się za pomocą słowa kluczowego let , podczas gdy zmienne są deklarowane za pomocą słowa kluczowego var. Przyjrzyjmy się, jak działają stałe i zmienne, wdrażając je na swoim placu zabaw. Podążać za tymi krokami:
1. Dodaj następujący kod do swojego placu zabaw, aby zadeklarować trzy stałe:
niechAnswerToTheUltimateQuestion = 42
niech pi = 3,14159
niech mojeNazwa = "Ahmad Sahar"
2. Kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić. W każdym przypadku tworzony jest kontener, nazwany i zapisana przypisana mu wartość.
Być może zauważyłeś, że nazwy stałych i zmiennych zaczynają się od małej litery, a jeśli w nazwie znajduje się więcej niż jedno słowo, każde kolejne słowo zaczyna się od dużej litery. Nazywa się to etui na wielbłąda. Nie musisz tego robić, ale jest to zalecane, ponieważ większość doświadczonych programistów Swift przestrzega tej konwencji. Należy zauważyć, że do przypisania wartości myName używana jest sekwencja znaków ujęta w podwójny cudzysłów "Ahmad Sahar". Są one znane jako literały łańcuchowe.
3. Dodaj następujący kod po deklaracjach stałych, aby zadeklarować trzy zmienne:
var bieżąca temperatura w stopniach Celsjusza = 27
var mój wiek = 50
var mojaLokalizacja = "dom"
Podobnie jak w przypadku stałych, w każdym przypadku tworzony jest kontener i nazwany, a przypisana wartość jest przechowywana. Zapisane wartości zostaną wyświetlone w obszarze Wyniki.
4. Po ustawieniu wartości stałej nie można zmienić. Aby to przetestować, dodaj następujący kod po deklaracjach zmiennych:
let niech pada deszcz = prawda
isRaining = fałsz
Podczas wpisywania drugiej linii kodu pojawi się wyskakujące menu z sugestiami:
Użyj klawiszy strzałek w górę i w dół, aby wybrać stałą isRaining i naciśnij klawisz Tab, aby ją wybrać. Ta funkcja nazywa się autouzupełnianiem i pomaga zapobiegać błędom podczas wprowadzania kodu.
5. Po zakończeniu pisania poczekaj kilka sekund. W drugiej linii powinieneś zobaczyć czerwone kółko z białą kropką pośrodku:
Oznacza to, że w Twoim programie wystąpił błąd i Xcode uważa, że można go naprawić. Błąd pojawia się, ponieważ próbujesz przypisać nową wartość do stałej po ustawieniu jej wartości początkowej.
6. Kliknij czerwone kółko, aby rozwinąć komunikat o błędzie. Powinieneś zobaczyć następujące pole z przyciskiem Napraw:
Xcode informuje Cię, na czym polega problem (nie można przypisać do wartości: "isRaining" jest stałą "let") i sugeruje korektę (zmień "let" na "var", aby można było go modyfikować).
7. Kliknij przycisk Napraw.
8. Powinieneś zobaczyć, że deklaracja stałej isRaining została zmieniona na deklarację zmiennej:
Ponieważ do zmiennej można przypisać nową wartość po jej utworzeniu, błąd został rozwiązany. Pamiętaj jednak, że sugerowana korekta może nie być najlepszym rozwiązaniem. Gdy zdobędziesz więcej doświadczenia w programowaniu na iOS, będziesz w stanie określić najlepszy sposób działania. Jeśli spojrzysz na wpisany kod, możesz się zastanawiać, skąd Xcode zna typ danych przechowywanych w zmiennej lub stałej. Jak to się robi, dowiesz się w następnej sekcji.
Zrozumienie wnioskowania o typie i bezpieczeństwa typu
W poprzedniej sekcji zadeklarowałeś stałe i zmienne oraz przypisałeś im wartości. Swift automatycznie określa typ stałej lub zmiennej na podstawie podanej wartości. Nazywa się to wnioskowaniem o typie. Typ stałej lub zmiennej można zobaczyć, przytrzymując klawisz Opcja i klikając jej nazwę. Aby zobaczyć to w akcji, wykonaj następujące kroki:
1. Dodaj następujący kod do swojego placu zabaw, aby zadeklarować ciąg znaków:
let kuchnia = "amerykańska"
2. Kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić.
3. Przytrzymaj klawisz Opcja i kliknij kuchnia, aby wyświetlić stały typ. Powinieneś zobaczyć następujący komunikat:
Jak widać, typ kuchni to String.
Co się stanie, jeśli chcesz ustawić konkretny typ zmiennej lub stałej? Zobaczysz, jak to zrobić w następnej sekcji.
Użycie adnotacji typu do określenia typu
Widziałeś, że Xcode próbuje automatycznie określić typ danych zmiennej lub stałej na podstawie podanej wartości. Czasami jednak możesz chcieć określić typ, zamiast pozwolić Xcode zrobić to za Ciebie. Aby to zrobić, wpisz dwukropek (:) po nazwie stałej lub zmiennej, a następnie żądany typ. Nazywa się to adnotacją typu.
Dodaj następujący kod do swojego placu zabaw, aby zadeklarować zmienną określonego typu, a następnie kliknij przycisk Odtwórz/Zatrzymaj, aby ją uruchomić:
var restaurantRating: Double = 3
Tutaj określono, że ocena restauracji ma określony typ, Double. Nawet jeśli do restauracjiRating przypisano liczbę całkowitą, będzie ona przechowywana jako liczba zmiennoprzecinkowa. W następnej sekcji dowiesz się, jak Xcode pomaga zmniejszyć liczbę błędów w programie poprzez egzekwowanie bezpieczeństwa typów.
Korzystanie z zabezpieczeń typu do sprawdzania wartości
Swift jest językiem bezpiecznym dla typów. Sprawdza, czy przypisujesz wartości prawidłowego typu do zmiennych i oznacza niedopasowane typy jako błędy. Zobaczmy, jak to działa, wykonując następujące kroki:
1. Dodaj następujący kod do swojego placu zabaw, aby przypisać ciąg do restauracjiRating:
restauracjaRating = "Dobry"
2. Kliknij przycisk Odtwórz/Zatrzymaj, aby uruchomić kod.
3. Powinieneś zobaczyć czerwone kółko z x w środku. X oznacza, że Xcode nie może zasugerować rozwiązania tego problemu. Kliknij czerwone kółko.
4. Ponieważ próbujesz przypisać ciąg znaków do zmiennej typu Double, wyświetlany jest następujący komunikat o błędzie:
5. Skomentuj linię, wpisując // przed nią, jak pokazano:
// restauracjaRating = "Dobry"
Czerwone kółko zniknie, ponieważ w programie nie ma już błędów. Teraz, gdy wiesz, jak przechowywać dane w stałych i zmiennych, przyjrzyjmy się, jak wykonywać na nich operacje w następnej sekcji.
Eksploracja operatorów
W Swift możesz wykonywać operacje arytmetyczne, porównawcze i logiczne. Operatory arytmetyczne służą do typowych operacji matematycznych. Operatory porównania i operatory logiczne sprawdzają wartość wyrażenia i zwracają wartość prawda lub fałsz. Przyjrzyjmy się bardziej szczegółowo każdemu typowi operatora. W następnej sekcji zaczniesz od operatorów arytmetycznych (dodawanie, odejmowanie, mnożenie i dzielenie).
Stosowanie operatorów arytmetycznych
Możesz wykonywać operacje matematyczne na liczbach całkowitych i zmiennoprzecinkowych, używając pokazanych tutaj standardowych operatorów arytmetycznych:
+ : dodawanie
- odejmowanie
* mnożenie
/ : dzielenie
Zobaczmy, jak używane są te operatory. Wykonaj następujące kroki:
1. Dodaj następujący kod, aby dodać operacje arytmetyczne do swojego placu zabaw:
niech suma = 23 + 20
niech wynik = 32 - suma
niech suma = wynik * 5
niech dzieli = suma / 10
2. Kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić. Wyniki wyświetlone w obszarze Wyniki będą wynosić odpowiednio 43, -11, -55 i -5. Należy zauważyć, że 55 podzielone przez 10 zwraca 5 zamiast 5,5, ponieważ obie liczby są liczbami całkowitymi. 3. Operatory mogą pracować tylko z operandami tego samego typu. Wpisz następujący kod i uruchom go, aby zobaczyć, co się stanie, jeśli operandy będą różnych typów:
let a = 12
let b = 12,0
let c = a + b
Otrzymasz komunikat o błędzie (operatora binarnego "+" nie można zastosować do operandów typu "Int" i "Double"). Dzieje się tak, ponieważ a i b to różne typy. Pamiętaj, że Xcode nie może tego naprawić automatycznie, więc nie wyświetla żadnych sugestii dotyczących naprawy.
4. Aby naprawić błąd, zmodyfikuj program w następujący sposób:
niech c = Double(a) + b Double(a) pobiera wartość zapisaną w a i tworzy z niej liczbę zmiennoprzecinkową. Oba operandy są teraz tego samego typu i teraz możesz dodać do nich wartość z b. Wartość zapisana w c wynosi 24,0, a w obszarze Wyniki zostanie wyświetlona liczba 24. Teraz, gdy wiesz, jak używać operatorów arytmetycznych, w następnej sekcji przyjrzysz się złożonym operatorom przypisania (+=, -=, *= i /=).
Używanie złożonych operatorów przypisania
Możesz wykonać operację na wartości i przypisać wynik do zmiennej, używając przedstawionych tutaj złożonych operatorów przypisania:
+= Dodaje wartość i przypisuje wynik do zmiennej
-= Odejmuje wartość i przypisuje wynik do zmiennej
*= Mnoży wartość i przypisuje wynik do zmiennej
/= Dzieli wartość i przypisuje wynik do zmiennej
Zobaczmy, jak używane są te operatory. Dodaj następujący kod do swojego placu zabaw i kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić:
var d = 1
d += 2
d -= 1
Wyrażenie d += 2 jest skrótem dla d = d + 2, więc wartość w d wynosi teraz 1 + 2, a 3 zostanie przypisane do d. W ten sam sposób d -= 1 jest skrótem od d = d - 1, więc wartość w d wynosi teraz 3 - 1, a 2 zostanie przypisane do d. Teraz, gdy znasz już złożone operatory przypisania, przyjrzyjmy się operatorom porównania (==, /=, >, <, >= i <=) w następnej sekcji.
Korzystanie z operatorów porównania
Możesz porównać jedną wartość z drugą za pomocą operatorów porównania, a wynik będzie prawdziwy lub fałszywy. Możesz użyć następujących operatorów porównania:
== Równe
!= Nierówne
> Większe niż
< Mniejsze niż
>= Większe niż lub równe
<= Mniejsze niż lub równe
Zobaczmy, jak używane są te operatory. Dodaj następujący kod do swojego placu zabaw i kliknij przycisk Odtwórz/Przycisk Stop, aby go uruchomić:
1 == 1
2!= 1
2 > 1
1 < 2
1 >= 1
2 <= 1
Zobaczmy jak to działa:
• 1 == 1 zwraca wartość true, ponieważ 1 jest równe 1
• 2 != 1 zwraca wartość true, ponieważ 2 nie jest równe 1
• 2 > 1 zwraca prawdę, ponieważ 2 jest większe niż 1
• 1 < 2 zwraca prawdę, ponieważ 1 jest mniejsze niż 2
• 1 >= 1 zwraca wartość true, ponieważ 1 jest większe lub równe 1
• 2 <= 1 zwraca wartość false, ponieważ 2 jest nie mniejsze lub równe 1
Zwrócone wartości logiczne zostaną wyświetlone w obszarze Wyniki.
Co się stanie, jeśli chcesz sprawdzić więcej niż jeden warunek? Tutaj właśnie pojawiają się operatory logiczne (AND, OR i NOT). Przeanalizujesz je w następnej sekcji.
Używanie operatorów logicznych
Operatory logiczne są przydatne, gdy mamy do czynienia z dwoma lub większą liczbą warunków. Na przykład, jeśli jesteś w sklepie ogólnospożywczym, możesz zapłacić za produkty, jeśli masz gotówkę lub kartę kredytową. OR jest w tym przypadku operatorem logicznym. Można używać następujących operatorów logicznych:
&& Logiczne AND - zwraca true jeśli wszystkie warunki są true
|| Logiczne OR - zwraca true jeśli dowolny warunek jest true
! Logiczne NOT - zwraca przeciwieństwo wartości boolowskiej
Aby zobaczyć, jak korzystają z tych operatorów, dodaj następujący kod do swojego placu zabaw i kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić:
(1 == 1) && (2 == 2)
(1 == 1) && (2 != 2)
(1 == 1) || (2 == 2)
(1 == 1) || (2!= 2)
(1 != 1) || (2!= 2)
!(1 == 1)
Zobaczmy jak to działa:
• (1 == 1) && (2 == 2) zwraca prawdę, ponieważ oba operandy są prawdziwe, więc prawda ORAZ prawda zwraca prawdę
• (1 == 1) && (2 != 2) zwraca fałsz, ponieważ jeden operand jest fałszywy, więc prawda ORAZ fałsz zwraca fałsz
• (1 == 1) || (2 == 2) zwraca prawdę, ponieważ oba operandy są prawdziwe, więc prawda LUB prawda zwraca prawdę
• (1 == 1) || (2 != 2) zwraca prawdę, jeśli jeden z operandów jest prawdziwy, więc prawda LUB fałsz zwraca prawdę
• (1 != 1) || (2 != 2) zwraca wartość false, ponieważ oba operandy są fałszywe, więc wartość false OR false zwraca wartość false
• !(1 == 1) zwraca fałsz, ponieważ 1==1 jest prawdą, zatem NIE prawda zwraca fałsz
Zwrócone wartości logiczne zostaną wyświetlone w obszarze Wyniki. Do tej pory pracowałeś tylko z liczbami. W następnej sekcji zobaczysz, jak możesz wykonywać operacje na słowach i zdaniach, które są przechowywane jako ciągi znaków przy użyciu typu String Swifta.
Wykonywanie operacji na ciągach
Jak widzieliśmy wcześniej, ciąg znaków to ciąg znaków. Są one reprezentowane przez typ String i są w pełni zgodne z Unicode. Poznajmy niektóre typowe operacje na ciągach znaków. Wykonaj następujące kroki:
1. Możesz połączyć dwa ciągi znaków za pomocą operatora +. Dodaj następujący kod do swojego placu zabaw i kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić:
let greeting = "Good" + " Morning"
Wartości literałów łańcuchowych "Dobry" i "Poranny" są łączone, a w obszarze Wyniki wyświetlana jest wartość "Dzień dobry".
2. Można łączyć ciągi znaków ze stałymi i zmiennymi innych typów, rzutując je na ciągi znaków. Aby rzutować stałą ocenę na ciąg znaków, wprowadź następujący kod i uruchom go:
let rating = 3.5
var ratingResult = "The restaurant rating is " +
String(rating)
Stała oceny zawiera 3,5, wartość typu Double. Umieszczenie oceny w nawiasach funkcji String() powoduje pobranie wartości zapisanej w ocenie i utworzenie na jej podstawie nowego ciągu "3,5", który jest łączony z ciągiem znaków w zmiennej ratingResult, zwracając ciąg "Ocena restauracji to 3,5"
3. Istnieje prostszy sposób łączenia ciągów, zwany interpolacją ciągów. Interpolację ciągów wykonuje się poprzez wpisanie nazwy stałej lub zmiennej pomiędzy "\(" i ")" w ciągu. Wpisz następujący kod i uruchom go:
ratingResult = "The restaurant rating is \(rating)"
Podobnie jak w poprzednim przykładzie, wartość oceny jest używana do utworzenia nowego ciągu "3,5", zwracając ciąg "Ocena restauracji to 3,5". Dotychczasowe wyniki swoich instrukcji możesz zobaczyć w obszarze Wyniki. Jeśli jednak napiszesz aplikację przy użyciu Xcode, nie będziesz mieć dostępu do obszaru Wyniki widocznego na placu zabaw. Aby wyświetlić zawartość zmiennych i stałych podczas działania programu, w następnej sekcji dowiesz się, jak wydrukować je w obszarze Debugowanie.
Korzystanie z instrukcji print().
Jak widziałeś w Rozdziale 1, Zapoznanie się z Xcode, projekt Xcode nie ma obszaru wyników, który ma plac zabaw, ale zarówno projekt, jak i plac zabaw mają obszar debugowania. Użycie instrukcji print() spowoduje wydrukowanie zawartości zawartej w nawiasach w obszarze debugowania. Dodaj następujący kod do swojego placu zabaw i kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić:
print(ratingResult)
Wartość ratingResult pojawi się w obszarze Debugowanie:
Jeśli dopiero zaczynasz, możesz używać dowolnej liczby instrukcji print(). To naprawdę dobry sposób, aby zrozumieć, co dzieje się w programie.
Streszczenie
W tej lekcji nauczyłeś się tworzyć i używać plików zabaw, które pozwalają odkrywać i eksperymentować ze Swiftem. Widziałeś, jak Swift reprezentuje różne typy danych oraz jak używać stałych i zmiennych. Umożliwia to przechowywanie w programie liczb, wartości logicznych i ciągów znaków. Poznałeś także wnioskowanie o typie, adnotację typu i bezpieczeństwo typów, które pomogą Ci pisać kod zwięźle i z mniejszą liczbą błędów. Przyjrzałeś się sposobowi wykonywania operacji na liczbach i ciągach znaków, co umożliwia wykonywanie prostych zadań przetwarzania danych. Nauczyłeś się, jak naprawiać błędy i jak drukować w obszarze Debugowanie, co jest przydatne, gdy próbujesz znaleźć i naprawić błędy w pisanych programach. W następnym rozdziale przyjrzysz się warunkom i opcjom. Warunki warunkowe dotyczą dokonywania logicznych wyborów w programie, a opcje opcjonalne dotyczą przypadków, w których zmienna może mieć wartość lub nie.
Warunki i opcje
Przyjrzałeś się typom danych, stałym, zmiennym i operacjom. W tym momencie możesz już pisać proste programy przetwarzające litery i cyfry. Jednak programy nie zawsze działają po kolei. Często będziesz musiał wykonać różne instrukcje w zależności od warunku. Swift pozwala to zrobić za pomocą warunków warunkowych, a w tej części dowiesz się, jak z nich korzystać. Kolejną rzeczą, którą mogłeś zauważyć, jest to, że w ostatniej części każdej zmiennej lub stałej została natychmiast przypisana wartość. Co się stanie, jeśli potrzebujesz zmiennej, której wartość może początkowo nie być obecna? Będziesz potrzebował sposobu na utworzenie zmiennej, która może mieć wartość lub nie. Swift pozwala to zrobić za pomocą opcji, o których również dowiesz się w tym rozdziale. Pod koniec tego rozdziału powinieneś potrafić pisać programy wykonujące różne czynności w oparciu o różne warunki oraz obsługiwać zmienne, które mogą mieć wartość lub nie.
Omówione zostaną następujące tematy:
• Wprowadzenie warunków
• Wprowadzenie opcji i opcjonalnego wiązania
Poświęć trochę czasu na zrozumienie opcji. Mogą być zniechęcające dla początkującego programisty.
Przedstawiamy warunki
Czasami będziesz chciał wykonać różne bloki kodu w oparciu o określony warunek, na przykład w następujących scenariuszach:
• Wybór pomiędzy różnymi rodzajami pokoi w hotelu. Cena za większe pokoje byłaby wyższa.
• Przełączanie pomiędzy różnymi metodami płatności w sklepie internetowym. Różne metody płatności wymagają różnych procedur.
• Podejmowanie decyzji, co zamówić w restauracji typu fast-food. Procedury przygotowania każdego artykułu spożywczego będą inne.
Aby to zrobić, użyj warunków. W Swift jest to realizowane za pomocą instrukcji if (dla pojedynczego warunku) i instrukcji switch (dla wielu warunków). Zobaczmy, jak instrukcje if są używane do wykonywania różnych zadań w zależności od wartości warunku w następnej sekcji.
Używanie instrukcji if
Instrukcja if wykonuje blok kodu, jeśli warunek jest prawdziwy, i opcjonalnie inny blok kodu, jeśli warunek jest fałszywy. Instrukcja if wygląda następująco:
if condition {
code1
} else {
code2
}
Zaimplementujmy teraz instrukcję if, aby zobaczyć to w działaniu. Wyobraź sobie, że programujesz aplikację dla restauracji. Aplikacja pozwoli Ci sprawdzić, czy restauracja jest otwarta, wyszukać ją i sprawdzić, czy klient nie przekroczył wieku uprawniającego do spożywania alkoholu. Wykonaj następujące kroki:
1. Aby sprawdzić, czy restauracja jest otwarta, dodaj następujący kod do swojego placu zabaw, aby utworzyć stałą i wykonać instrukcję, jeśli wartość stałej jest prawdziwa. Kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić:
let isRestaurantOpen = true
if isRestaurantOpen {
print("Restaurant is open.")
}
Najpierw utworzyłeś stałą isRestaurantOpen i przypisałeś jej wartość true. Następnie masz instrukcję if, która sprawdza wartość przechowywaną w isRestaurantOpen. Ponieważ wartość jest prawdziwa, wykonywana jest instrukcja print(), a w obszarze Debugowanie wyświetlana jest informacja Restauracja jest otwarta.
2. Spróbuj zmienić wartość isRestaurantOpen na false i ponownie uruchom kod. Ponieważ warunek jest teraz fałszywy, w obszarze debugowania nic nie zostanie wydrukowane.
3. Możesz także wykonywać instrukcje, jeśli wartość jest fałszywa. Załóżmy, że klient szukał konkretnej restauracji, której nie ma w bazie aplikacji, więc aplikacja powinna wyświetlić komunikat, że restauracji nie znaleziono. Wpisz następujący kod, aby utworzyć stałą i wykonać instrukcję, jeśli wartość stałej jest fałszywa:
let isRestaurantFound = false
if isRestaurantFound == false {
print("Restaurant was not found")
}
Stała isRestaurantFound ma wartość false. Następnie sprawdzana jest instrukcja if. Warunek isRestaurantFound == false zwraca wartość true, a w obszarze debugowania wyświetlana jest informacja: Nie znaleziono restauracji.
4. Spróbuj zmienić wartość isRestaurantFound na true. Ponieważ warunek jest teraz fałszywy, w obszarze debugowania nic nie zostanie wydrukowane.
5. Aby wykonać jeden zestaw instrukcji, jeśli warunek jest prawdziwy, i inny zestaw instrukcji, jeśli warunek jest fałszywy, użyj słowa kluczowego else. Wpisz poniższy kod, który sprawdzi, czy klient baru nie przekroczył wieku uprawniającego do spożycia alkoholu:
let drinkingAgeLimit = 21
let customerAge = 23
if customerAge < drinkingAgeLimit {
print("Under age limit")
} else {
print("Over age limit")
}
Tutaj DrinkAgeLimit ma przypisaną wartość 21, a klientAge ma przypisaną wartość 23. W instrukcji if sprawdzany jest klientAge < DrinkAgeLimit. Ponieważ 23 < 21 zwraca wartość false, wykonywana jest instrukcja else, a w obszarze Debugowanie wyświetlany jest limit wieku Over. Jeśli zmienisz wartość CustomerAge na 19, CustomerAge < DrinkAgeLimit zwróci wartość true, więc w obszarze Debug zostanie wyświetlony limit poniżej wieku.
Do tej pory miałeś do czynienia tylko z pojedynczymi warunkami. A co jeśli warunków jest wiele? W tym miejscu pojawiają się instrukcje switch, o których dowiesz się w następnej sekcji.
Korzystanie z instrukcji switch
Aby zrozumieć instrukcje switch, zacznijmy od zaimplementowania instrukcji if z wieloma warunkami. Wyobraź sobie, że programujesz sygnalizację świetlną. Istnieją trzy możliwe kolory sygnalizacji świetlnej - czerwony, żółty lub zielony - i chcesz, aby w zależności od koloru światła wydarzyło się coś innego. Aby to zrobić, możesz połączyć ze sobą wiele instrukcji if. Wykonaj następujące kroki:
1. Dodaj następujący kod do swojego placu zabaw, aby zaimplementować sygnalizację świetlną za pomocą wielu instrukcji if i kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić:
var trafficLightColor = "Yellow"
if trafficLightColor == "Red" {
print("Stop")
} else if trafficLightColor == "Yellow" {
print("Caution")
} else if trafficLightColor == "Green" {
print("Go")
} else {
print("Invalid color")
}
Pierwszy warunek if, TrafficLightColor == "Red", zwraca wartość false, więc wykonywana jest instrukcja else. Drugi warunek if, TrafficLightColor == "Yellow", zwraca wartość true, więc w obszarze debugowania wyświetlana jest informacja Uwaga, a nie więcej, jeśli oceniane są warunki. Spróbuj zmienić wartość TrafficLightColor, aby zobaczyć inne wyniki. Zastosowany tutaj kod działa, ale jest trochę trudny do odczytania. W tym przypadku instrukcja switch byłaby bardziej zwięzła i łatwiejsza do zrozumienia. Instrukcja switch wygląda następująco:
switch value {
case firstValue:
code1
case secondValue:
code2
default:
code3
}
Wartość jest sprawdzana i dopasowywana do przypadku, po czym wykonywany jest kod dla tego przypadku. Jeśli żaden z przypadków nie pasuje, wykonywany jest kod w przypadku domyślnym.
2. Oto jak zapisać pokazaną wcześniej instrukcję if jako instrukcję switch. Wpisz następujący kod:
trafficLightColor = "Yellow"
switch trafficLightColor {
case "Red":
print("Stop")
case "Yellow":
print("Caution")
case "Green":
print("Go")
default:
print("Invalid color")
}
Kod tutaj jest znacznie łatwiejszy do odczytania i zrozumienia w porównaniu do poprzedniej wersji. Wartością w TrafficLightColor jest "Yellow", więc wielkość liter "Yellow" jest dopasowana, a w obszarze Debugowanie zostanie wydrukowana uwaga. Spróbuj zmienić wartość TrafficLightColor, aby zobaczyć inne wyniki. Są dwie rzeczy do zapamiętania na temat instrukcji switch:
• Instrukcje switch w Swift domyślnie nie przechodzą na dół każdego przypadku i przechodzą do następnego. W przykładzie pokazanym wcześniej, po dopasowaniu przypadku "Czerwony": przypadek "Żółty": przypadek "Zielony" i wartość domyślna: nie zostanie wykonana.
• Instrukcje switch muszą obejmować wszystkie możliwe przypadki. W powyższym przykładzie dowolna wartość TrafficLightColor inna niż "Red", "Yellow" lub "Green" zostanie dopasowana do wartości domyślnej, a w obszarze debugowania zostanie wydrukowany nieprawidłowy kolor.
Na tym kończy się sekcja dotycząca instrukcji if i switch. W następnej sekcji dowiesz się o opcjach, które pozwalają tworzyć zmienne bez wartości początkowych, oraz opcjonalnym wiązaniu, które pozwala na wykonanie instrukcji, jeśli opcja ma wartość.
Przedstawiamy opcje i opcjonalne wiązanie
Do tej pory za każdym razem, gdy deklarowałeś zmienną lub stałą, natychmiast przypisywałeś jej wartość. Ale co, jeśli chcesz najpierw zadeklarować zmienną, a później przypisać jej wartość? W tym przypadku użyłbyś opcji. Nauczmy się, jak tworzyć i używać opcji oraz zobaczmy, jak są one wykorzystywane w programie. Wyobraź sobie, że piszesz program, w którym użytkownik musi wpisać imię i nazwisko współmałżonka. Oczywiście, jeśli użytkownik nie jest żonaty, nie będzie to miało żadnej wartości. W takim przypadku możesz użyć opcji, aby przedstawić imię i nazwisko współmałżonka. Opcja opcjonalna może mieć jeden z dwóch możliwych stanów. Może zawierać wartość lub nie zawierać wartości. Jeśli opcja zawiera wartość, możesz uzyskać dostęp do wartości znajdującej się w niej. Proces uzyskiwania dostępu do wartości opcji nazywany jest rozpakowywaniem opcji. Zobaczmy, jak to działa. Wykonaj następujące kroki:
1. Dodaj następujący kod do swojego placu zabaw, aby utworzyć zmienną i wydrukować jej zawartość:
var spouseName: String
print(spouseName)
2. Kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić. Ponieważ Swift jest bezpieczny pod względem typu, wyświetli błąd (zmienna "nazwa współmałżonka" użyta przed inicjalizacją).
3. Aby rozwiązać ten problem, możesz przypisać pusty ciąg do współmałżonkaName. Zmodyfikuj swój kod, jak pokazano:
var spouseName: String = ""
To sprawia, że błąd znika, ale pusty ciąg znaków nadal jest wartością, a małżonkaName nie powinna mieć wartości.
4. Ponieważ nazwa małżonka początkowo nie powinna mieć wartości, uczyńmy ją opcjonalną. Aby to zrobić, wpisz znak zapytania po adnotacji typu i usuń przypisanie pustego ciągu:
var spouseName: String?
Zobaczysz ostrzeżenie, ponieważ współmałżonekName jest teraz opcjonalną zmienną łańcuchową zamiast zwykłej zmiennej łańcuchowej, a instrukcja print() oczekuje zwykłej zmiennej łańcuchowej.
Nawet jeśli pojawi się ostrzeżenie, program zostanie wykonany. Na razie zignoruj ostrzeżenie. Wartość małżonkaName jest wyświetlana jako "nil\n" w obszarze Wyniki, a zero jest drukowane w obszarze Debugowanie. nil to specjalne słowo kluczowe, które oznacza, że opcjonalna zmienna małżonka imienia nie ma wartości.
5. Pojawia się ostrzeżenie, ponieważ instrukcja print traktuje małżonkaName jako typ Any zamiast String?. Kliknij żółty trójkąt, aby wyświetlić możliwe poprawki i wybierz pierwszą poprawkę:
Instrukcja zmieni się na print(nazwa współmałżonka? wartość domyślna). Zwróć uwagę na użycie ?? operator. Oznacza to, że jeśli małżonkaName nie zawiera wartości, w instrukcji print zostanie użyta podana przez Ciebie wartość domyślna.
6. Zamień symbol zastępczy wartości domyślnej na "Brak wartości w współmałżonku", jak pokazano. Ostrzeżenie zniknie. Uruchom program ponownie, a w obszarze Wyniki pojawi się informacja "Brak wartości w współmałżonku":
7. Przypiszmy wartość małżonkowiName. Zmodyfikuj kod, jak pokazano:
var spouseName: String?
spouseName = "Nia"
print(spouseName ?? "No value in spouseName")
Po uruchomieniu programu Nia pojawi się w obszarze debugowania.
8. Dodaj jeszcze jedną linię kodu, aby połączyć małżonkaName z innym ciągiem, jak pokazano:
print(spouseName ?? "No value in spouseName")
let greeting = "Hello, " + spouseName
Pojawi się błąd, a w obszarze Debugowanie zostaną wyświetlone informacje o błędzie i miejsce jego wystąpienia. Stało się tak, ponieważ nie można połączyć zwykłej zmiennej typu String z opcjonalną za pomocą operatora +. Najpierw musisz rozpakować opcję opcjonalną.
9. Kliknij czerwone kółko, aby wyświetlić możliwe poprawki, a zobaczysz następujące informacje:
Druga poprawka zaleca wymuszenie rozpakowania, aby rozwiązać ten problem. Wymuszone rozpakowywanie powoduje rozpakowanie opcji niezależnie od tego, czy zawiera ona wartość, czy nie. Działa dobrze, jeśli współmałżonekName ma wartość, ale jeśli małżonekName ma wartość zero, program ulegnie awarii.
10. Kliknij drugą poprawkę, a po nazwie małżonka w ostatnim wierszu kodu pojawi się wykrzyknik, co oznacza, że opcja jest wymuszona:
let greeting = "Hello, " + spouseName!
11. Po uruchomieniu programu powitanie zostanie przypisane do powitania, jak pokazano w obszarze Wyniki. Oznacza to, że małżonkaName została pomyślnie rozpakowana.
12. Aby zobaczyć efekt wymuszonego rozpakowania zmiennej zawierającej zero, ustaw współmałżonkaName na nil:
spouseName = nil
Twój program ulega awarii i możesz zobaczyć, co było przyczyną awarii w obszarze Debugowanie:
Ponieważ współmałżonekName ma teraz wartość zero, program uległ awarii podczas próby wymuszenia rozpakowania małżonkaName. Lepszym sposobem poradzenia sobie z tym jest użycie opcjonalnego powiązania. W opcjonalnym wiązaniu próbujesz przypisać wartość opcjonalną do zmiennej tymczasowej (możesz nadać jej dowolną nazwę). Jeśli przypisanie się powiedzie, wykonywany jest blok kodu.
13. Aby zobaczyć efekt opcjonalnego powiązania, zmodyfikuj swój kod w następujący sposób:
spouseName = "Nia"
print(spouseName ?? "No value in spouseName")
if let spouseTempVar = spouseName {
let greeting = "Hello, " + spouseTempVar
print(greeting)
}
Witaj, Nia pojawi się w obszarze debugowania. Oto jak to działa. Jeśli małżonkName ma wartość, zostanie ona rozpakowana i przypisana do tymczasowej stałej, małżonkTempVar, a instrukcja if zwróci wartość true. Instrukcje zawarte w nawiasach klamrowych zostaną wykonane, a stałemu powitaniu zostanie przypisana wartość Witaj, Nia. Następnie w obszarze debugowania zostanie wydrukowana wiadomość Witaj, Nia. Należy pamiętać, że zmienna tymczasowa małżonkaTempVar nie jest opcjonalna. Jeśli małżonkName nie ma wartości, nie można przypisać żadnej wartości do współmałżonkaTempVar, a instrukcja if zwróci wartość fałszywą. W takim przypadku instrukcje w nawiasach klamrowych w ogóle nie zostaną wykonane.
14. Aby zobaczyć efekt opcjonalnego powiązania, gdy opcja zawiera zero, przypisz nil jeszcze raz do małżonka:
spouseName = nil
Zauważysz, że w obszarze Debugowanie nic się nie pojawia, a Twój program nie ulega już awariom, mimo że nazwa małżonka ma wartość zero. Na tym kończy się sekcja poświęcona opcjom i opcjonalnym powiązaniom. Możesz teraz tworzyć i używać zmiennych opcjonalnych. Wspaniale!
Streszczenie
Świetnie sobie radzisz! Nauczyłeś się używać instrukcji if i switch, co oznacza, że możesz teraz pisać własne programy, które wykonują różne czynności w oparciu o różne warunki. Dowiedziałeś się także o opcjach i opcjonalnym wiązaniu. Oznacza to, że możesz teraz reprezentować zmienne, które mogą mieć wartość lub nie, i wykonywać instrukcje tylko wtedy, gdy wartość zmiennej jest obecna. W następnym rozdziale dowiesz się, jak używać zakresu wartości zamiast pojedynczych wartości i jak powtarzać instrukcje programu za pomocą pętli.
Operatory zakresu i pętle
W poprzedniej części zapoznałeś się z warunkami warunkowymi, które pozwalają wykonywać różne czynności w oparciu o różne warunki, oraz opcjami, które umożliwiają tworzenie zmiennych, które mogą mieć wartość lub nie. W tej części dowiesz się o operatorach zakresu i pętlach. Operatory zakresu pozwalają reprezentować zakres wartości poprzez określenie wartości początkowej i końcowej zakresu. Dowiesz się także o różnych typach operatorów zakresu. Pętle umożliwiają wielokrotne powtarzanie instrukcji lub sekwencji instrukcji. Możesz powtórzyć sekwencję określoną liczbę razy lub powtarzać sekwencję, aż spełniony zostanie warunek. Dowiesz się o różnych typach pętli używanych do osiągnięcia tego celu. Pod koniec tego rozdziału dowiesz się, jak korzystać z zakresów oraz jak tworzyć i używać różnych typów pętli (for-in, while i powtarzaj-while).
Odkrywanie operatorów zakresu
Operatory zakresu pozwalają reprezentować zakres wartości. Załóżmy, że chcesz przedstawić sekwencję liczb zaczynającą się od pierwszego numeru i kończącą się na ostatnim numerze. Nie musisz podawać każdej wartości; możesz po prostu określić zakres w ten sposób:
firstNumber … lastNumber
Wyobraź sobie, że musisz napisać program dla domu towarowego, który automatycznie wysyła kupon rabatowy klientom w wieku od 18 do 30 lat. Byłoby bardzo kłopotliwe, gdybyś musiał skonfigurować instrukcję if lub switch dla każdego wieku. W tym przypadku o wiele wygodniej jest użyć operatora zakresu. Wypróbujmy to na placu zabaw. Wykonaj następujące kroki:
1. Dodaj następujący kod do swojego placu zabaw i kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić:
let myRange = 10...20
Spowoduje to przypisanie sekwencji liczb zaczynającej się od 10 i kończącej się na 20, włączając obie liczby, do stałej myRange. Nazywa się to operatorem zamkniętego zasięgu. Wartości LowerBound i UpperBound dla myRange zostaną wyświetlone w obszarze Wyniki.
2. Wynik wyświetlany w obszarze Wyniki może zostać obcięty. Kliknij kwadratową ikonę po prawej stronie wyniku. Zostanie wyświetlony w obszarze Edytora:
Możesz teraz zobaczyć pełny wynik w polu pod linią kodu. Jeśli chcesz, możesz przeciągnąć prawą krawędź, aby powiększyć pole.
Pamiętaj, że możesz przeciągnąć granicę pomiędzy obszarami Wyniki i Edytor, aby zwiększyć rozmiar obszaru Wyniki.
3. Jeśli nie chcesz uwzględniać ostatniej cyfry ciągu w zakresie, użyj ..< zamiast .... Wpisz i uruchom następujący kod:
let myRange2 = 10..<20
4. Spowoduje to zapisanie sekwencji zaczynającej się od 10 i kończącej się na 19 w stałej myRange2 i jest to znane jako operator zakresu półotwartego.
Istnieje jeszcze jeden rodzaj operatora zakresu, jednostronny operator zakresu, o którym dowiesz się w następnej części.
Teraz, gdy już wiesz, jak tworzyć zakresy i z nich korzystać, w następnej sekcji dowiesz się o pętlach, różnych typach pętli i sposobach ich używania.
Implementacja klas ViewModel i zrozumienie stanu w Compose
W Androidzie ViewModel to klasa odpowiedzialna za świadome zarządzanie cyklem życia danych związanych z interfejsem użytkownika. W społeczności toczy się również wiele debat na temat tego, czy programiści powinni używać ViewModel w Compose, czy nie. Jednak Manuel Vivo, starszy inżynier ds. relacji z programistami Androida w Google, mówi: "Uwzględniłbym je, jeśli ich zalety dotyczą Twojej aplikacji. Nie ma potrzeby ich używać, jeśli sam zajmujesz się wszystkimi zmianami konfiguracji i nie korzystasz z funkcji tworzenia nawigacji. W przeciwnym razie użyj ViewModels, aby nie wymyślać koła na nowo. "Z drugiej strony debata na temat tego, dlaczego nie należy używać ViewModels, opiera się na argumencie, że w czystym Compose, ponieważ Compose obsługuje zmiany konfiguracji, odwoływanie się funkcji Composable do ViewModel jest niepotrzebne".
Implementacja klas ViewModel i zrozumienie stanu w Compose
W Androidzie ViewModel to klasa odpowiedzialna za świadome zarządzanie cyklem życia danych związanych z interfejsem użytkownika. W społeczności toczy się również wiele debat na temat tego, czy programiści powinni używać ViewModel w Compose, czy nie. Jednak Manuel Vivo, starszy inżynier ds. relacji z programistami Androida w Google, mówi: "Uwzględniłbym je, jeśli ich zalety dotyczą Twojej aplikacji. Nie ma potrzeby ich używać, jeśli sam zajmujesz się wszystkimi zmianami konfiguracji i nie korzystasz z funkcji tworzenia nawigacji. W przeciwnym razie użyj ViewModels, aby nie wymyślać koła na nowo. "Z drugiej strony debata na temat tego, dlaczego nie należy używać ViewModels, opiera się na argumencie, że w czystym Compose, ponieważ Compose obsługuje zmiany konfiguracji, odwoływanie się funkcji Composable do ViewModel jest niepotrzebne". Oznacza to, że użycie ViewModel do obsługi stanu aplikacji będzie kwestią osobistego wyboru w przypadku Jetpack Compose. Obecnie zalecanym wzorcem architektury w systemie Android jest Model-View-View-Model (MVVM) i korzysta z niego wiele aplikacji. Jetpack Compose wykorzystuje jednokierunkowy wzorzec projektowania przepływu danych; oznacza to, że dane lub stan są przesyłane strumieniowo w dół, podczas gdy zdarzenia są przesyłane strumieniowo. Dlatego pomocne będzie jasne zrozumienie, w jaki sposób możemy wykorzystać wzorzec jednokierunkowy, aby uczynić nasz kod bardziej czytelnym, łatwiejszym w utrzymaniu i testowaniu przy użyciu klasy ViewModel. Ponadto ViewModel nadaje się do zapewnienia aplikacji dostępu do logiki biznesowej, przygotowania danych do prezentacji na ekranie i umożliwienia testowania kodu.
Przygotowywanie się
W tym przepisie będziemy pracować z gotowym szkieletowym projektem SampleLogin, który możesz pobrać z sekcji Wymagania techniczne. Będziemy używać Hilt w tym przepisie, ponieważ projekt wykorzystuje Hilt, ale wyjaśnimy Hilt w następnym przepisie.
Jak to zrobić…
Utworzysz teraz klasę ViewModel i zmodyfikujesz większość kodu w pliku LoginContent Kotlin:
1. Aby nasze zajęcia i pliki były dobrze zorganizowane, utwórzmy najpierw pakiet do przechowywania naszego interfejsu użytkownika i przeglądania modeli. Przejdź do głównego folderu Pakietu, kliknij prawym przyciskiem myszy, aby otworzyć monit, a następnie przejdź do opcji Pakiet. Pojawi się okno dialogowe z nazwą pakietu.
2. Nazwij pakiet Login; wewnątrz Login przeniesiemy nasz plik LoginContent i dodamy tam nową klasę LoginViewModel. Śmiało, utwórz klasę ViewModel:
class LoginViewModel {…}
3. Teraz, gdy stworzyliśmy klasę LoginViewModel, musimy dodać adnotację DI HiltViewModel i upewnić się, że rozszerzamy klasę ViewModel:
@HiltViewModel
class LoginViewModel @Inject constructor(
): ViewModel(){…}
4. W naszym konstruktorze ViewModel będziemy musieli dodać stateHandle: SavedStateHandle, co pomoże nam w utrzymaniu i pobieraniu obiektów do i z zapisanego stanu. Wartości te utrzymują się nawet po zakończeniu procesu przez system i pozostają dostępne za pośrednictwem tego samego obiektu:
@HiltViewModel
class LoginViewModel @Inject constructor(
stateHandle: SavedStateHandle
) : ViewModel() {…}
5. Zanim zbudujemy nasz ViewModel, utwórzmy klasę danych AuthenticationState(). Ta klasa przyda się podczas naszych testów, ponieważ musimy być w stanie przetestować większość naszych przypadków walidacyjnych. Klasa stanu View oraz posiadanie jednego źródła prawdy ma wiele zalet i jest jedną z zasad Model-View-Intent MVI):
data class AuthenticationState(
val userName: String = "",
val password: String = "",
val loading: Boolean = false,
var togglePasswordVisibility: Boolean = true
) {
companion object {
val EMPTY_STATE = AuthenticationState()
}
}
6. Teraz przejdźmy dalej i utwórzmy klasę pomocniczą MutableSavedState
class MutableSavedState
private val savedStateHandle: SavedStateHandle,
private val key: String,
defValue: T,
) {
…
}
7. Teraz przejdźmy dalej i utwórzmy wywołania zwrotne, które zostaną wywołane, gdy użytkownik wprowadzi swoją nazwę użytkownika i hasło w LoginViewModel:
private val username = MutableSavedState(
stateHandle,
"UserName",
defValue = ""
)
fun userNameChanged(userName: String){
username.value = userName
}
8. Śmiało, zrób to samo dla widoczności hasła i przełączania hasła.
9. Teraz musimy utworzyć klasę pomocniczą CombineFlows. W Kotlinie możesz łączyć więcej niż dwa przepływy; przepływ współprogramowy to typ, który emituje sekwencyjnie wiele wartości, w przeciwieństwie do funkcji zawieszenia, która zwraca pojedynczą wartość. Więcej szczegółów na temat łączenia przepływów można znaleźć w Combine(flow1, flow2, flow3, flow4) {t1, t2, t3, t4 ->resultMapper}.stateIn(scope):
fun
flow: Flow
flow2: Flow
flow3: Flow
flow4: Flow
flow5: Flow
flow6: Flow
transform: suspend (T1, T2, T3, T4, T5, T6) -> R
): Flow
combine(flow, flow2, flow3, ::Triple),
combine(flow4, flow5, flow6, ::Triple)
) { t1, t2 ->
transform(
t1.first,
t1.second,
t1.third,
t2.first,
t2.second,
t2.third
)
}
val state = combineFlows(
username.flow,
password.flow,
passwordVisibilityToggle.flow,
loadingProgress.flow
) { username, password, passwordToggle, isLoading ->
AuthenticationState(
userName = username,
password = password,
togglePasswordVisibility = passwordToggle,
loading = isLoading
)
}.stateIn(…)
10. Teraz stwórzmy naszą klasę pomocniczą do korzystania z współprogramów i nazwijmy ją SampleLoginDispatchers(); pomoże nam to w testowaniu naszego kodu i upewnieniu się, że jest on czytelny. Ponadto używamy dyspozytorów współprogramów, które pomagają określić, jakiego wątku powinna użyć odpowiednia współprogram do wykonania:
.stateIn(
coroutineScope = viewModelScope + dispatchers.main,
initialValue = AuthenticationState.EMPTY_STATE
)
SharedFlow reprezentuje stan tylko do odczytu z pojedynczą wartością danych, którą można aktualizować, która emituje wszelkie aktualizacje do swoich modułów zbierających. Z drugiej strony przepływ stanu jest przepływem gorącym, ponieważ jego aktywna instancja istnieje niezależnie od obecności kolektorów.
11. Operator przepływu współprogramu SharingStarted w systemie Android służy do współdzielenia wykonania przepływu pomiędzy wieloma kolektorami. Jest powszechnie używany do tworzenia "gorącego" przepływu, co oznacza, że przepływ zaczyna emitować dane zaraz po utworzeniu, a dane są udostępniane wszystkim aktywnym kolektorom przepływu. Mogą to być emisje tego samego polecenia i nie mają żadnego efektu:
fun
coroutineScope: CoroutineScope,
initialValue: T
): StateFlow
scope = coroutineScope,
started = SharingStarted.WhileSubscribed(5000),
initialValue = initialValue
)
12. Istnieją cztery typy dyspozytorów. W naszym przykładzie użyjemy tylko trzech. Ponadto możesz wstrzyknąć pojedynczego dyspozytora i osiągnąć ten sam wynik bez klasy; dlatego może to być oparte na preferencjach. Zobacz jak to działa w przypadku czterech typów dyspozytorów:
class SampleLoginDispatchers(
val default: CoroutineDispatcher,
val main: CoroutineDispatcher,
val io: CoroutineDispatcher
) {
companion object {
fun createTestDispatchers(coroutineDispatcher:
CoroutineDispatcher): SampleLoginDispatchers {
return SampleLoginDispatchers(
default = coroutineDispatcher,
main = coroutineDispatcher,
io = coroutineDispatcher
)
}
}
}
Teraz, gdy stworzyliśmy naszą klasę pomocniczą, musimy udostępnić dyspozytora poprzez DI. Mamy cały przepis poświęcony Hiltowi, więc przyjrzymy się konceptom i znaczeniu adnotacji w przepisie Hilt.
13. Utwórz nowy pakiet i wywołaj pakiet di. W tym pakiecie utwórz nowy obiekt i nazwij go AppModule; przekażemy naszego dyspozytora konstruktorowi ViewModel poprzez graf zależności:
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
@Provides
fun provideSlimeDispatchers():
SampleLoginDispatchers {
return SampleLoginDispatchers(
default = Dispatchers.Default,
main = Dispatchers.Main,
io = Dispatchers.IO
)
}
}
14. Pozostaje nam teraz udać się do LoginContent i zmodyfikować kod - czyli dodając wywołania zwrotne, które będą odpowiadać naszemu ViewModelowi, a gdy już będziemy mieli widok - np. UserNameField() - skorzystamy z wywołania zwrotnego. Zobacz przykładowy kod:
@Composable
fun LoginContent(
modifier: Modifier = Modifier,
uiState: AuthenticationState,
onUsernameUpdated: (String) -> Unit,
onPasswordUpdated: (String) -> Unit,
onLogin: () -> Unit,
passwordToggleVisibility: (Boolean) -> Unit
){
…
UserNameField(authState = uiState, onValueChanged =
onUsernameUpdated)
PasswordInputField(
text = stringResource(id = R.string.password),
authState = uiState,
onValueChanged = onPasswordUpdated,
passwordToggleVisibility =
passwordToggleVisibility
)
LoginButton(
text = stringResource(id = R.string.sign_in),
enabled = if (uiState.isValidForm()) {
!uiState.loading
} else {
false
},
onLoginClicked = {
onLogin.invoke()
},
isLoading = uiState.loading
)…}
15. Teraz w naszej funkcji LoginContentScreen Composable przekażemy nasz LoginViewModel:
@Composable
fun LoginContentScreen(
loginViewModel: LoginViewModel,
onRegisterNavigateTo: () -> Unit
) {
val viewState by
loginViewModel.state.collectAsState()
LoginContent(
uiState = viewState,
onUsernameUpdated =
loginViewModel::userNameChanged,
onPasswordUpdated =
loginViewModel::passwordChanged,
onLogin = loginViewModel::login,
passwordToggleVisibility =
loginViewModel::passwordVisibility,
onRegister = onRegisterNavigateTo
)
}
16. Na koniec w MainActivity możemy teraz wywołać LoginContentScreen, przekazać nasz ViewModel i określić, jaką akcję chcemy wykonać, gdy użytkownik kliknie przycisk Zarejestruj:
LoginContentScreen(loginViewModel = HiltViewModel(),
onRegisterNavigateTo = {…}
Jak to działa…
Jetpack Compose wykorzystuje jednokierunkowy wzorzec projektowy przepływu danych. Oznacza to, że dane lub stan są przesyłane strumieniowo w dół, podczas gdy zdarzenia są przesyłane w górę, jak pokazano na rysunku
Oznacza to, że funkcje komponowalne odbierają stan, a następnie wyświetlają go na ekranie. Z drugiej strony zdarzenie może spowodować konieczność aktualizacji stanu i pochodzić z obiektu Composable lub dowolnej innej części aplikacji. Co więcej, cokolwiek obsługuje stan, w naszym przypadku ViewModel, odbiera zdarzenie i dostosowuje za nas stan. Używamy również współprogramów, które są niczym innym jak lekkimi wątkami i pomagają nam łatwo obsługiwać programowanie synchroniczne i asynchroniczne. Co więcej, współprogramy umożliwiają zawieszenie i wznowienie wykonywania później. Główne zalety to to, że są lekkie, mają wbudowaną obsługę anulowania, mają mniejsze ryzyko wycieków pamięci, a biblioteki Jetpack zapewniają obsługę współprogramów. Istnieją cztery typy dyspozytorów:
• Główny moduł rozsyłający: Główny moduł rozsyłający działa w głównym wątku, który jest zwykle używany, gdy aplikacja musi wykonać pewne operacje interfejsu użytkownika w ramach współprogramu. Dzieje się tak, ponieważ interfejs użytkownika można zmienić tylko z poziomu głównego wątku. Inną nazwą głównego wątku jest wątek interfejsu użytkownika.
• Dyspozytor IO: Dyspozytor IO uruchamia współprogram w wątku I/O; We/Wy oznacza po prostu wejście i wyjście w programowaniu. Służy to również do wykonywania wszelkich prac związanych z danymi, takich jak łączenie się z siecią, odczytywanie lub zapisywanie z bazy danych. Można po prostu powiedzieć, że pobieranie danych z operacji we/wy odbywa się w wątku we/wy.
• Domyślny dyspozytor: Domyślny dyspozytor uruchamia się w stanie domyślnym. Twoja aplikacja może to wykorzystać, jeśli planujesz wykonywać złożone, długotrwałe obliczenia, które mogą zablokować interfejs użytkownika/główny wątek i spowodować zawieszenie interfejsu użytkownika lub spowodować błąd aplikacji nie odpowiada (ANR). Dodatkowo w GlobalScope uruchamiane są domyślne dyspozytory, z których można skorzystać po prostu wywołując GlobalScope.launch{…}.
• Dyspozytor Unconfined: Wreszcie, Unconfined, jak sama nazwa wskazuje, jest dyspozytorem, który nie jest ograniczony do żadnego konkretnego wątku. Spowoduje to wykonanie programu dyspozytorskiego w celu wykonania jego pracy w bieżącej ramce wywołania i umożliwienie współprogramowi wznowienia wszelkich wątków używanych przez odpowiednią funkcję.
Odkrywanie pętli
W programowaniu często trzeba robić to samo w kółko. Na przykład co miesiąc firma będzie musiała generować paski płac dla każdego pracownika. Jeśli firma zatrudnia 10 000 pracowników, nieefektywne byłoby pisanie 10 000 instrukcji tworzenia pasków płac. Lepsze byłoby powtórzenie pojedynczej instrukcji 10 000 razy i używa się do tego pętli. Istnieją trzy typy pętli: pętla for-in, pętla while i pętla powtarzania-while. Pętla for-in będzie powtarzana znaną liczbę razy, natomiast pętle while i Repeat-while będą się powtarzać tak długo, jak warunek pętli będzie spełniony. Przyjrzyjmy się kolejno każdemu typowi, zaczynając od pętli for-in, której używamy, gdy wiemy, ile razy pętla powinna zostać powtórzona.
Korzystanie z pętli for-in
Pętla for-in przechodzi przez każdą wartość w sekwencji i za każdym razem wykonywany jest zestaw instrukcji w nawiasach klamrowych, zwany treścią pętli. Każda wartość jest kolejno przypisana do zmiennej tymczasowej, a zmienna tymczasowa może zostać użyta w treści pętli. Oto jak to wygląda:
for item in sequence { code
}
Liczba powtórzeń pętli zależy od liczby elementów w sekwencji. Zacznijmy od utworzenia pętli for-in, która wyświetli wszystkie liczby w myRange. Wykonaj następujące kroki:
1. Dodaj następujący kod do swojego placu zabaw i kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić:
for number in myRange {
print(number)
}
Powinieneś zobaczyć każdy numer w sekwencji wyświetlony w obszarze Debugowanie. Należy zauważyć, że instrukcje wewnątrz pętli są wykonywane 11 razy, ponieważ myRange zawiera ostatnią liczbę z zakresu.
2. Spróbujmy tego samego programu, ale tym razem z myRange2. Zmodyfikuj kod w następujący sposób i uruchom go:
for number in myRange2 {
print(number)
}
Instrukcje wewnątrz pętli są wykonywane 10 razy, a ostatnia wartość wydrukowana w obszarze Debug to 19.
3. Możesz nawet użyć operatora zakresu bezpośrednio po słowie kluczowym in. Wpisz i uruchom następujący kod:
for number in 0…5 {
print(number)
}
Każda liczba od 0 do 5 jest wyświetlana w obszarze debugowania.
4. Jeśli chcesz, aby sekwencja została odwrócona, użyj funkcji Reversed(). Zmodyfikuj kod w następujący sposób i uruchom go:
for number in (0…5).reversed() {
print(number)
}
Każda liczba od 5 do 0 jest wyświetlana w obszarze debugowania.
Dobra robota! W następnej sekcji przyjrzyjmy się pętlom while, które są używane, gdy sekwencja pętli powinna być powtarzana, dopóki warunek jest spełniony.
Korzystanie z pętli while
Pętla while zawiera warunek i zestaw instrukcji w nawiasach klamrowych, zwanych treścią pętli. Najpierw sprawdzany jest warunek; jeśli prawda, wykonywany jest korpus pętli i pętla jest powtarzana, aż warunek stanie się fałszywy. Oto przykład, jak wygląda pętla while:
while condition == true {
code
}
Dodaj następujący kod, aby utworzyć zmienną, zwiększ ją o 5 i rób to tak długo, aż wartość zmiennej będzie mniejsza niż 50. Kliknij przycisk Odtwórz/Zatrzymaj, aby ją uruchomić:
var y = 0
while y < 50 {
y += 5
print("y is \(y)")
}
Przejdźmy przez kod. Początkowo y jest ustawione na 0. Warunek y < 50 jest sprawdzany i zwraca wartość true, zatem wykonywane jest ciało pętli. Wartość y jest zwiększana o 5, a wartość y wynosi 5 jest drukowana w obszarze Debugowanie. Pętla się powtarza i ponownie sprawdzane jest y < 50. Ponieważ y wynosi teraz 5, a 5 < 50 nadal zwraca wartość true, ciało pętli jest wykonywane ponownie. Powtarza się to, aż wartość y osiągnie 50, w którym to momencie y < 50 zwróci wartość false i pętla się zatrzyma. Jeśli na początku warunek pętli while jest fałszywy, treść pętli nigdy nie zostanie wykonana. Aby to zobaczyć, spróbuj zmienić wartość y na 100. W następnej części zapoznasz się z pętlami powtarzania-while. Spowodują one wykonanie najpierw instrukcji z treści pętli przed sprawdzeniem warunku pętli.
Pętla repeat- while
Podobnie jak pętla while, pętla powtarzania while również zawiera warunek i treść pętli, ale treść pętli jest wykonywana najpierw przed sprawdzeniem warunku. Jeśli warunek jest prawdziwy, pętla jest powtarzana, aż warunek zwróci wartość false. Oto przykład, jak wygląda pętla powtarzania podczas:
repeat {
code
} while condition == true
Dodaj następujący kod, aby utworzyć zmienną, zwiększ ją o 5 i rób to tak długo, aż wartość zmiennej będzie mniejsza niż 50. Kliknij przycisk Odtwórz/Zatrzymaj, aby ją uruchomić:
var x = 0
repeat {
x += 5
print("x is \(x)")
} while x < 50
Przejdźmy przez kod. Początkowo x jest ustawione na 0. Wykonywany jest korpus pętli. Wartość x jest zwiększana o 5, więc teraz x zawiera 5, a x wynosi 5 jest wypisywane w obszarze debugowania. Sprawdzany jest warunek x < 50, a ponieważ zwraca wartość true, pętla się powtarza. Wartość x jest zwiększana o 5, więc teraz x zawiera 10, a x wynosi 10 i jest wypisywane w obszarze debugowania. Pętla jest powtarzana, aż x będzie zawierało 50, w którym to momencie x < 50 zwróci wartość false i pętla się zatrzyma. Treść pętli zostanie wykonana co najmniej raz, nawet jeśli na początku warunek jest fałszywy. Aby to zobaczyć, spróbuj zmienić wartość x na 100. Teraz wiesz, jak tworzyć i używać różnych typów pętli. Wspaniale!
Streszczenie
Przyjrzałeś się operatorom zakresu zamkniętego i półotwartego, które pozwalają określić zakres liczb zamiast dyskretnego określania każdej pojedynczej liczby. Poznałeś także trzy różne typy pętli: pętlę for-in, pętlę while i pętlę powtarzania. Pętla for-in umożliwia powtarzanie zestawu instrukcji określoną liczbę razy, natomiast pętle while i Repeat-while umożliwiają powtarzanie zestawu instrukcji, dopóki warunek jest spełniony.
Dobra robota!
W następnej części zapoznasz się z typami kolekcji, które umożliwiają przechowywanie kolekcji danych, do których odwołuje się indeks, kolekcji par klucz-wartość oraz kolekcji danych bez struktury.
Typy kolekcji
W tym momencie nauczyłeś się całkiem sporo! Możesz teraz utworzyć program przechowujący dane w stałych lub zmiennych i wykonujący na nich operacje, a także możesz kontrolować przepływ za pomocą warunków i pętli. Jednak do tej pory przechowywałeś głównie pojedyncze wartości. W tym rozdziale dowiesz się, jak przechowywać kolekcje wartości. Swift ma trzy typy kolekcji: tablice, które przechowują uporządkowaną listę wartości; słowniki przechowujące nieuporządkowaną listę par klucz-wartość; i zestawy, które przechowują nieuporządkowaną listę wartości. Pod koniec tego rozdziału dowiesz się, jak tworzyć tablice, słowniki i zbiory oraz jak wykonywać na nich operacje. Pierwszym typem kolekcji, o którym się dowiesz, są tablice, które umożliwiają przechowywanie informacji w postaci uporządkowanej listy.
Zrozumienie tablic
Załóżmy, że chcesz przechowywać następujące informacje:
o Lista artykułów do kupienia w sklepie ogólnospożywczym
o Obowiązki, które musisz wykonywać co miesiąc
Do tego odpowiednie będą tablice. Tablica przechowuje wartości na uporządkowanej liście. Oto jak to wygląda:
Index : Wartość
0 : wartość 1
1 : wartość 2
2 : wartość 3
Wartości muszą być tego samego typu. Dostęp do dowolnej wartości w tablicy można uzyskać za pomocą indeksu tablicy, który zaczyna się od 0. Jeśli utworzysz tablicę za pomocą słowa kluczowego let, jej zawartości nie będzie można zmienić po jej utworzeniu. Jeśli chcesz zmienić zawartość tablicy po utworzeniu, użyj słowa kluczowego var. Zobaczmy, jak pracować z tablicami. W następnej sekcji utworzysz tablicę, przypisując jej wartość.
Tworzenie tablicy
W poprzednich częściach tworzyłeś stałą lub zmienną, deklarując ją i przypisując jej wartość początkową. W ten sam sposób możesz utworzyć tablicę. Wyobraź sobie, że twój współmałżonek poprosił cię o przyniesienie kilku artykułów ze sklepu ogólnospożywczego. Zaimplementujmy listę zakupów za pomocą tablicy. Dodaj następujący kod do swojego placu zabaw i kliknij przycisk Odtwórz/Zatrzymaj, aby go uruchomić:
var shoppingList = ["Jajka", "Mleko"]
Ta instrukcja tworzy zmienną tablicową o nazwie shoppingList. Przypisana wartość ["Jajka", "Mleko"] jest literałem tablicowym. Reprezentuje tablicę składającą się z dwóch elementów typu String, z "Eggs" w indeksie 0 i "Milk" w indeksie 1. Użycie tutaj słowa kluczowego var oznacza, że zawartość tablicy można modyfikować. Ponieważ Swift używa wnioskowania typu, elementy tej tablicy będą typu String. Wyobraź sobie, że musisz sprawdzić, ile artykułów potrzebujesz, aby dostać się do sklepu. W następnej sekcji dowiesz się, jak określić liczbę elementów w tablicy.
6G
Zarys technologii wielokrotnego dostępu
Teoretyczne podstawy technologii NMA
Kandydujące technologie NMA w 5G
Zastosowanie technologii NMA w 5G
Mity 5G
Część 1 to wprowadzenie do 5G i powiązanych technologii. Chodzi o to, aby wszyscy czytelnicy znaleźli się na tej samej stronie, aby zrozumieli dalszą dyskusję.
Część 2 analizuje lekcje historii, patrząc wstecz na przejścia przez poprzednie generacje i pokazanie, jakie proste ekstrapolacje trendów przewidziałyby dla 5G. Omawiamy, że gdyby podążano za poprzednimi trendami, 5G stałoby się szeroko wdrożone w 2022 r., zapewniając realistyczne szybkości transmisji danych dla użytkowników końcowych na poziomie 200 megabitów na sekundę (Mb/s) i wzrost przepustowości około dwa razy w stosunku do obecnych sieci.
W Części 3 przeanalizowano, czy taki wzrost szybkości i wydajności jest potrzebny. Pokazuje, że użytkownicy nie cenią prędkości powyżej tych, które są już powszechnie dostępne w 4G. Pokazuje, że chociaż wymagania dotyczące danych obecnie szybko rosną, tempo wzrostu spowalnia i, jeśli zostanie ekstrapolowane, spowoduje plateau wymagań dotyczących szybkości transmisji danych około 2027 r., Przy niewielkim wzroście w erze 5G. W związku z tym stwierdza, że postępy w szybkości i przepustowości, jakie może przynieść 5G, nie są potrzebne.
Część 4 rozważa, czy dostępna jest technologia zapewniająca takie korzyści. Pokazuje, że dalsza poprawa przepustowości jest bardzo trudna i prawdopodobnie będzie kosztowna w realizacji, podnosząc koszt świadczenia dla operatorów sieci komórkowych (MNO). Poprawa prędkości jest dostępna tylko w pasmach o bardzo wysokich częstotliwościach, które są ograniczone do gęstych obszarów miejskich, a także wiążą się z wysokimi kosztami. Dlatego nie ma łatwych korzyści z ulepszeń technologicznych. Sugeruje to również, że niektóre zmiany w sieci szkieletowej mogą mieć nieoczekiwane skutki uboczne w postaci udostępnienia różnych struktur branżowych, dzieląc funkcje zapewniane przez operatorów sieci komórkowych na wielu graczy.
Część 5 analizuje ekonomię branży i pokazuje, że operatorzy sieci ruchomej znajdują się w sytuacji, w której przychody spadają w stosunku do produktu krajowego brutto (PKB), a rentowność wynosi tylko połowę średniej we wszystkich sektorach przemysłu. Niewielu spodziewa się, że zmieni się to wraz z 5G, w wyniku czego inwestycje będą wysoce nieatrakcyjne, chyba że wzrost przychodów może być stymulowany poprzez dostarczanie nowych usług.
Część 6 zadaje pytanie: dlaczego, skoro sytuacja jest tak ponura, cała branża wydaje się tak popierać 5G? Mówię, że nie jest w interesie żadnego z kluczowych graczy poddawanie w wątpliwość uporczywej wizji 5G i że dla niektórych pojawienie się 5G jest niezbędne dla ich przetrwania.
W Części 7 bardziej szczegółowo omówiono wizje 5G. Pokazuje, że często są one nieosiągalne. Wspólna wizja operatorów sieci ruchomych, określona przez organizację sieci komórkowych nowej generacji (NGMN), jest szczegółowo analizowana i wykazano, że każda usługa może być dostarczana za pośrednictwem istniejących rozwiązań bezprzewodowych, takich jak 4G, lub jest nieopłacalna ekonomicznie. W tym rozdziale wyjaśniono, że obecne wizje są wadliwe, a ich rozpiętość i brak rzeczywistości wprowadza zamieszanie. Niewiele osób wie, czym właściwie jest 5G.
Część 8 zadaje pytanie, co mogłoby się wydarzyć w miejsce obecnej wizji 5G. Sugeruje to, że stała łączność prawie 10 Mb/s wszędzie jest bardziej przekonującą wizją i pokazuje, jak można ją zapewnić za pośrednictwem połączenia 4G i Wi-Fi. W rozdziale przedstawiono również możliwą ścieżkę wprowadzenia tego rodzaju łączności, pokazując, jak może to spowodować zmiany sejsmiczne w strukturze przemysłu.
Część 9 przygląda się szerzej światu komunikacji, biorąc pod uwagę wpływ regulacji, widma i dostępu szerokopasmowego w domu. Pokazuje, że regulacje mają na celu utrzymanie status quo, którego wczesne Części okazały się nie do utrzymania, i przewiduje, że spowoduje to dalsze problemy dla każdej wizji 5G.
Część 10 podsumowuje wyniki , wyjaśnia, dlaczego wizja 5G, jaka jest obecnie propagowana przez głównych graczy, jest mitem i omawia, co jest bardziej prawdopodobne. W tej części pokazano, jak świat połączonych urządzeń, zwiększony zasięg, niezliczone nowe aplikacje i większą produktywność można osiągnąć szybciej i taniej niż przy obecnej wizji.
mmWave massive MIMO : "cyngiel" killera 5G
Wprowadzenie do mmWave
Sekcja I (Od SISO do mmWave massive MIMO): Dokonamy przeglądu wcześniejszych badań dotyczących SISO i MIMO oraz podsumowano powstającą technologię mmWave massive MIMO. Opiszemy również główne aspekty modelowania kanałów od mikrofalowego SISO do mmWave massive MIMO.
Sekcja II (Hybrydowa matryca antenowa dla mmWave massive MIMO): Przedstawimy architekturę masywnej hybrydowej matrycy, w której elementy antenowe są pogrupowane w wiele analogicznych podnośników, a pojedynczy sygnał cyfrowy jest odbierany lub wysyłany do każdej podtablicy. Zapewnia niedrogie i wykonalne przestrzennie rozwiązanie dla masywnej matrycy mmWave i może osiągnąć porównywalną wydajność z całkowicie cyfrową matrycą dzięki czasowej i przestrzennej rzadkości kanałów propagacji mmWave. Rozpoczynamy od przedstawienia architektury macierzy hybrydowych, podkreślając dwie typowe konfiguracje przeplatanych i zlokalizowanych tablic. Następnie przedstawiamy cztery opcjonalne implementacje sprzętowe tej architektury. Konstrukcja macierzy jest omawiana przez układy anten quasi-Yagi i ułożoną antenę krosową z prostopadłym podłożem zasilającym. Wprowadzono również dwa prototypy opracowane przez CSIRO i Samsung. Po przejrzeniu rozwoju sprzętu, w tym rozdziale omówiono techniki przetwarzania sygnałów dla macierzy hybrydowych, ze szczególnym uwzględnieniem oceny kąta przybycia, LOS MIMO dla pojedynczego użytkownika i jego pojemności oraz technik wielokrotnego dostępu do podziału przestrzennego. Podsumowując, ten rozdział pokazuje, że ogromna macierz hybrydowa jest bardzo obiecującą techniką dla mmWave massive MIMO.
Sekcja III (Kodowanie i wykrywanie dla mmWave massive MIMO): Omówimy schemat ponownego użycia pilota dla łącza w górę masywnego systemu MIMO. Następnie wyznaczono dolną granicę przepustowości systemu, która ma zastosowanie do dowolnej liczby anten. W przypuszczalnym scenariuszu każdy użytkownik najpierw przesyła sekwencję szkoleniową lub pilotującą do stacji bazowej, gdzie maksymalny stosunek łączący odbiornik dekoduje ten komunikat w celu ustalenia odpowiedzi kanału, która następnie może zostać wykorzystana do poprawy średniej przepustowości. Rozważana jest heksagonalna geometria systemu, w której każda komórka zawiera równomiernie rozmieszczonych użytkowników i stały wzorzec ponownego użycia sekwencji pilotującej. Wyprowadzona dolna granica jest ograniczona przez trzy rodzaje zakłóceń: interferencje międzykomórkowe, interferencje wewnątrzkomórkowe i zanieczyszczenie pilotowe. Te wskaźniki zostały wykorzystane do dalszego rozróżnienia między wydajnością sieci o ultra wysokiej częstotliwości i mmWave. Ponadto analizowany jest zestaw warunków, w tym liczba użytkowników, anteny, współczynnik ponownego użycia pilota i okres koherencji, aby osiągnąć dolną granicę przepustowości. Wyniki wskazują, że czynnik ponownego wykorzystania odgrywa kluczową rolę w najmniej osiągalnej wydajności. Minimalny współczynnik ponownego wykorzystania jest określony ilościowo dla danej gęstości użytkownika i okresu koherencji.
Sekcja IV (Wstępne kodowanie dla mmWave massive MIMO): Krótko omówimy tradycyjne cyfrowe wstępne kodowanie dla systemów MIMO i analogowe formowanie wiązki dla komunikacji mmWave. Pokazuje to, że nie można ich bezpośrednio rozszerzyć na masywne systemy MIMO mmWave. Tak więc zbadano nowy schemat wstępnego kodowania zwany hybrydowym analogowym i cyfrowym wstępnym kodowaniem. Kluczową ideą hybrydowego wstępnego kodowania jest podzielenie konwencjonalnego cyfrowego prekodera na duży analogowy prekoder (realizowany przez dużą liczbę analogowych przesuwników fazowych) w celu zwiększenia wzmocnienia matrycy antenowej i mały cyfrowy prekoder (realizowany przez niewielką liczbę RF łańcuchy), aby anulować zakłócenia. Dzięki niskiej charakterystyce kanałów mmWave w domenie przestrzennej wystarczy mały cyfrowy prekoder, aby osiągnąć zysk przestrzennego multipleksowania, co sprawia, że hybrydowe prekodowanie cieszy się satysfakcjonującą wydajnością sumaryczną przy niewielkiej liczbie łańcuchów RF. Wreszcie, porównano wstępne kodowanie hybrydowe z tradycyjnym cyfrowym kodowaniem wstępnym i analogowym kształtowaniem wiązki, a także przedstawiono inne potencjalne schematy wstępnego kodowania dla MIMO masywnego mmWave.
Sekcja V (Szacowanie kanału dla mmWave massive MIMO): Omówimy najnowocześniejsze schematy szacowania kanałów dla mmWave massive MIMO. Najpierw wprowadzamy trzy kluczowe elementy w masywnych systemach MIMO mmWave, w tym rzadkie masywne kanały MIMO mmWave, hybrydową strukturę nadajnika-odbiornika MIMO z analogową siecią z przesuwnikiem fazowym oraz odbiornik z jednobitowym przetwornikiem analogowo-cyfrowym. Następnie omawia szczegółowo cztery rodzaje schematów szacowania kanału dla masywnych systemów MIMO mmWave, w tym oszacowanie kanału oparte na CS, oszacowanie kanału z odbiornikiem jednobitowym, oszacowanie kanału parametrycznego oraz oszacowanie podprzestrzeni i oszacowanie kanału w oparciu o rozkład, a także omawia ich zalety i zalety Cons. Na koniec omawia pokrótce, w jaki sposób istniejące schematy szacowania kanałów pierwotnie zaproponowane dla konwencjonalnego masywnego MIMO z mikrofalami można dostosować do mmWave masywnego MIMO.
Sekcja VI (Sprzężenie zwrotne kanału dla mmWave massive MIMO): Omówimy dwa różne podejścia do sprzężenia zwrotnego kanału dla FDD mmWave massive MIMO, a także metodę wstępnego kodowania łącza w dół, która nie wymaga sprzężenia zwrotnego CSI. Po pierwsze, zauważając, że skorelowany przestrzennie kanał MIMO może mieć rzadką reprezentację poprzez pewne transformacje liniowe, wprowadzono metodę redukcji obciążenia zwrotnego opartą na teorii CS. Po drugie, opisuje praktyczny i wydajny mechanizm sprzężenia zwrotnego kanału wykorzystujący wielostopniowe formowanie wiązki, w którym symbole pilota są transmitowane na wiązkach w dziedzinie kątowej. Na koniec szczegółowo badana jest technika wstępnego kodowania łącza w dół oparta na wiedzy o kątach przybycia ścieżek propagacji zamiast pełnego CSI.
Sekcja VII (Modele kanałów dla mmWave massive MIMO: W tej sekcji po raz pierwszy dokonamy przeglądu i wyróżnienia głównych wyróżniających się cechy masywnych kanałów MIMO mmWave pod względem trzech warstw: mechanizmów propagacji, modelu kanału statycznego i modelu kanału dynamicznego. Opiszemy i omówimy najnowocześniejsze modelowanie i brzmienie odpowiednio masywnego kanału MIMO mmWave. Mimo że obecnie dostępne pomiary lub modele masywnych kanałów MIMO mmWave są nadal bardzo ograniczone, wielu badaczy dokłada starań, aby stworzyć standardowy model kanału, który może skutecznie poprowadzić projekt systemu dla 5G i wyższych.
Sekcja VIII (Techniki umożliwiające komunikację mmWave dla systemów bezprzewodowych 5G:perspektywa na poziomie łącza): Przeanalizujemy wydajność systemów mmWave, które można badać na poziomie sieci lub na poziomie łącza, ze szczególnym uwzględnieniem wydajności na poziomie łącza. Wydajność systemu bezprzewodowego mmWave na poziomie łącza zależy od wielu czynników, w tym od schematu transmisji (tj. od tego, czy stosujemy formowanie wiązki, multipleksowanie czy oba), charakterystyki kanału i struktury fali przesyłanego sygnału.
Sekcja IX (Projektowanie warstwy MAC dla mmWave massive MIMO): Ta sekcja zawiera przegląd planowania użytkownika od SISO do masywnego MIMO w oparciu o model kanału zanikania Rayleigha odpowiedni dla bogatych środowisk rozpraszania w dolnym paśmie komórkowym. Następnie wprowadza się harmonogramowanie użytkownika dla mmWave massive MIMO w oparciu o model kanału odpowiedni dla rzadkich kanałów propagacji mmWave. Różne właściwości między nimi zapewniają podstawowe wyniki teoretyczne.
Sekcja X (Rozszerzony wielokrotny dostęp dla mmWave massive MIMO): Przedstawimy nowatorski schemat wielokrotnego dostępu dla mmWave masywnego MIMO, oparty na półortogonalnym szkoleniu kanałów i transmisji danych, tak że w danym przedziale czasowym niektórzy skoordynowani użytkownicy wydają się ortogonalni podczas gdy pozostali użytkownicy przesyłają nieortogonalnie. Schemat jest ukształtowany jako półortogonalny wielokrotny dostęp (SOMA). SOMA umożliwia przesyłanie dodatkowych danych, a także planowanie większej liczby użytkowników dla transmisji łącza zwrotnego w przeciwieństwie do tradycyjnego protokołu TDD, co powoduje zauważalny wzrost wydajności widmowej masywnego MIMO. Rozwiązanie zostaje następnie rozszerzone na uogólnioną SOMA (GSOMA) poprzez grupowanie użytkowników, przy czym zasada SOMA jest stosowana na grupę, a sekwencje pilotujące w obrębie każdej grupy są odwzorowywane na te same zasoby częstotliwości w oparciu o multipleksowanie z podziałem kodu. Proponowane schematy SOMA i GSOMA są analizowane przy użyciu granic teoretycznych informacji w celu uzyskania odpowiedniej możliwej do uzyskania łącznej przepustowości.
Sekcja XI (Projekt frontu mmWave massive MIMO): Omawimy projekt frontu masywnych sieci HetN opartych na MIMO mmWave. Gęste rozmieszczenie małych komórek wymaga opłacalnego frontu o dużej pojemności, aby pomieścić 1000-krotne zwiększenie pojemności komórkowej dla 5G. Na tym tle masywny przód siatki mmWave oparty na MIMO cieszy się w ostatnich latach coraz większym zainteresowaniem. W porównaniu z istniejącymi rozwiązaniami frontu działającymi w pasmach niskiej częstotliwości, fronthaul mmWave jest kompatybilny z ultra-gęstym rozmieszczeniem małych komórek, ponieważ łącze frontu może być krótkie (zwykle 50-200 m), aby złagodzić wysoką utratę ścieżki sygnałów mmWave i zagwarantować Łącze LOS. Ponadto, wykorzystując powstającą technikę masywnego MIMO mmWave, topologię siatki czołowej można łatwo ułatwić, aby ułatwić instalację i zmniejszyć koszty wdrożenia. Dodatkowo techniki formowania wiązki mmWave massive MIMO mogą uczynić siatkę przednią bardziej elastyczną i inteligentną. Przedstawiamy badanie istniejących rozwiązań fronthaul, a następnie zapotrzebowanie rynku sieci fronthaul na przyszłe sieci 5G HetNets. Co ważniejsze, przedstawia koncepcję masywnej sieci kratowej opartej na MIMO mmWave dla fronthaul, gdzie szczegółowo omawia się niektóre kwestie, w tym techniki antenowe, projektowanie formowania wiązki, protokół dupleksowania i wewnątrzpasmowy fronthaul.
Sekcja XII (Sieci komórkowe MmWave: Stochastyczne modelowanie geometrii, analiza i walidacja eksperymentalna): Wprowadzamy nowe ramy matematyczne do analizy sieci komórkowych mmWave. Jego osobliwość polega na rozważeniu realistycznych modeli utraty ścieżki i blokady, które pochodzą z danych eksperymentalnych. Model utraty ścieżki uwzględnia różne rozkłady warunków propagacji LOS i innych niż LOS. Model blokady obejmuje również stan wyłączenia, który zapewnia lepszą reprezentację możliwości wyłączenia transmisji mmWave. Poprzez modelowanie lokalizacji BS jako punktów procesu punktu Poissona uzyskuje się proste i dokładne całki, a także przybliżone i zamknięte formuły do obliczania prawdopodobieństwa pokrycia i średniej szybkości. Przy pomocy symulacji Monte Carlo i przy użyciu danych eksperymentalnych wykazano, że przybliżenie ograniczone szumem jest wystarczająco dokładne dla typowych gęstości sieci. Przybliżone ograniczenie szumów może jednak nie być wystarczająco dokładne dla wdrożeń UDN i dla pasm transmisyjnych subgigaherców. W takich przypadkach podejście analityczne jest uogólnione w celu uwzględnienia zakłóceń innych komórek kosztem zwiększenia jego złożoności obliczeniowej. Dokładność podejścia do modelowania geometrii stochastycznej dla sieci komórkowych mmWave jest badana poprzez wyraźne uwzględnienie realistycznych lokalizacji BS, śladów budynków, blokad przestrzennych i propagacji kanałów. Podkreślamy, że wystarczająco gęste sieci komórkowe mmWave są w stanie przewyższyć mikrofalowe sieci komórkowe pod względem zasięgu i szybkości.
10 Filarów 5G
I. Ewolucja istniejących RAT
5G nie będzie konkretnym RAT, raczej jest to zbiór RAT, w tym ewolucja istniejących RAT, uzupełniona nowatorskimi projektami rewolucyjnymi. W związku z tym, pierwszym i najbardziej ekonomicznym rozwiązaniem problemu awarii 1000x jest poprawa istniejących RAT pod względem SE, EE i latencji, a także wspieranie elastycznego współdzielenia RAN wśród wielu dostawców. W szczególności LTE musi ewoluować, aby obsługiwać masowy / 3D MIMO, aby w dalszym stopniu wykorzystywać przestrzenny stopień swobody (DOF) dzięki zaawansowanemu formowaniu wiązki wielu użytkowników, w celu dalszego zwiększenia możliwości eliminacji zakłóceń i koordynacji interferencji w scenariuszu wdrażania hiperdencyjnych małych komórek. WiFi musi również ewoluować, aby lepiej wykorzystać dostępne nielicencjonowane widmo. IEEE 802.11ac, najnowsza ewolucja technologii Wi-Fi, może zapewnić szerokopasmowe potoki bezprzewodowe z szybkością transmisji wielu Gb / s. Wykorzystuje szerszą przepustowość do 160 MHz w mniej zanieczyszczonym paśmie ISM 5 GHz, wykorzystując do 256 kwadraturowej modulacji amplitudy (QAM). Może również obsługiwać jednoczesne transmisje do czterech strumieni przy użyciu techniki MIMO dla wielu użytkowników. Zastosowana technika formowania wiązki zwiększyła zasięg o kilka rzędów wielkości w porównaniu z poprzednikiem (IEEE 802.11n). Wreszcie duże firmy telekomunikacyjne, takie jak Qualcomm, pracują ostatnio nad rozwojem LTE w nielicencjonowanym spektrum, a także integrują nadajniki-odbiorniki 3G / 4G / WiFi w jedną jednostkę stacji bazowej (BS). W związku z tym przewiduje się, że przyszłe UE będzie wystarczająco inteligentne, aby wybrać najlepszy interfejs do połączenia z RAN w oparciu o wymagania QoS działającej aplikacji.
II. Hyperdense Small-Cell Deployment
Wdrożenie Hyperdense dla małych komórek jest kolejnym obiecującym rozwiązaniem, które spełni wymagania 1000x pojemności, a jednocześnie wprowadzi dodatkowe EE do systemu. To innowacyjne rozwiązanie, nazywane również HetNet, może znacznie zwiększyć efektywność widmową obszaru (b / s / Hz / m2). Ogólnie rzecz biorąc, istnieją dwa różne sposoby realizacji HetNet: (i) nakładanie systemu komórkowego na małe komórki tej samej technologii, to znaczy na mikro-, piko lub femtokomórki; (ii) nakładanie małych komórek różnych technologii w przeciwieństwie do tylko komórek (np. High Speed Packet Access (HSPA), LTE, WiFi itd.). Pierwsza z nich nazywana jest wielowarstwową HetNet, natomiast druga jest nazywana HetNetem wielorakim. Qualcomm, wiodąca firma zajmująca się wyzwaniem 1000x pojemności poprzez hiperdensyjne wdrożenia małych komórek, wykazała, że dodawanie małych komórek może skalować pojemność sieci niemal liniowo. Oznacza to, że pojemność podwaja się za każdym razem, gdy podwoimy liczbę małych komórki. Jednak zmniejszenie rozmiaru komórki zwiększa interferencję międzykomórkową i wymaganą sygnalizację sterowania. Aby przezwyciężyć tę wadę, potrzebne są zaawansowane techniki zarządzania interferencjami międzykomórkowymi na poziomie systemu wraz z uzupełniającymi technikami eliminowania zakłóceń w urządzeniach użytkownika. Wzmocnienie małych komórek było centralnym punktem LTE R-12, gdzie wprowadzono nowy typ nośnika (NCT) (znany również jako Lean Carrier), aby pomóc małym komórkom w makrokomórce gospodarza. Pozwala to na bardziej wydajne działanie płaszczyzny sterowania (np. Do zarządzania mobilnością, synchronizacji, alokacji zasobów itp.) Przez warstwę makro, zapewniając jednocześnie wysoką pojemność i efektywną widmowo płaszczyznę danych przez małe komórki. Wreszcie, zmniejszenie rozmiaru komórki może również poprawić EE sieci poprzez zbliżenie sieci do UE, a tym samym zmniejszenie budżetu mocy łączy bezprzewodowych
III. Sieć samoorganizująca się
Zdolność do samoorganizacji sieci (SON) to kolejny kluczowy element 5G. Wraz ze wzrostem populacji małych komórek SON nabiera większego rozpędu. Prawie 80% ruchu bezprzewodowego generowane jest w pomieszczeniach. Aby przenosić ten olbrzymi ruch, potrzebujemy hiperdentycznych wdrożeń małych komórek w domach - instalowanych i utrzymywanych głównie przez użytkowników - poza kontrolą operatorów. Te małe komórki wewnętrzne muszą być konfigurowalne i instalowane w sposób "plug and play". Ponadto muszą mieć zdolność SON, aby inteligentnie dostosować się do sąsiednich małych komórek, aby zminimalizować zakłócenia międzykomórkowe. Na przykład mała komórka może to zrobić poprzez autonomiczną synchronizację z siecią i sprytne dostosowanie zasięgu radiowego.
IV. Komunikacja typu maszynowego
Oprócz ludzi łączenie maszyn mobilnych jest kolejnym podstawowym aspektem 5G. Komunikacja typu maszynowego (MTC) to pojawiająca się aplikacja, w której jeden lub obaj użytkownicy końcowi sesji komunikacyjnej obejmują maszyny. MTC narzuca dwa główne wyzwania w sieci. Po pierwsze, liczba urządzeń, które należy podłączyć, jest ogromnie duża. Ericsson (jedna z wiodących firm badających 5G) przewiduje, że 50 miliardów urządzeń musi być połączonych w przyszłym społeczeństwie sieciowym; firma przewiduje, że "wszystko, co może być korzystne z połączenia, zostanie połączone'" Innym wyzwaniem narzuconym przez MTC jest przyspieszenie zapotrzebowania na zdalne sterowanie urządzeniami mobilnymi (takimi jak pojazdy) w czasie rzeczywistym za pośrednictwem sieci. Wymaga to wyjątkowo niskiego opóźnienia poniżej jednej milisekundy, zwanego "dotykowym Internetem", dyktującego poprawę 20-krotnego opóźnienia z 4G do 5G.
V. Opracowywanie RAT z falami milimetrowymi
Tradycyjne widmo poniżej 3 GHz staje się coraz bardziej zatłoczone, a obecne RAT zbliżają się do limitu pojemności Shannona. W związku z tym rozpoczęto już badania nad odkrywaniem pasm cm i fal dla komunikacji mobilnej. Chociaż badania w tej dziedzinie są jeszcze w powijakach, wyniki wyglądają obiecująco. Istnieją trzy główne przeszkody dla komunikacji mobilnej mmWave. Po pierwsze, utrata ścieżki jest relatywnie wyższa w tych pasmach w porównaniu z konwencjonalnymi pasmami poniżej 3GHz. Po drugie, fale elektromagnetyczne mają tendencję do rozprzestrzeniania się w kierunku Line-Of-Sight (LOS), co sprawia, że łącza radiowe są podatne na zablokowanie przez ruchome obiekty lub ludzi. Wreszcie, straty penetracji przez budynki są znacznie wyższe w tych pasmach, blokując zewnętrzne RAT dla użytkowników wewnętrznych. Pomimo tych ograniczeń istnieje wiele zalet komunikacji mmWave. Ogromna ilość widma dostępna jest w paśmie mmWave; na przykład przy 60 GHz dostępne jest 9 GHz nielicencjonowanego widma. Ta ilość widma jest ogromna, zwłaszcza, gdy uważamy, że globalne przydzielone widmo dla wszystkich technologii komórkowych prawie nie przekracza 780 MHz. Ta ilość widma może całkowicie zrewolucjonizować komunikację mobilną poprzez dostarczenie ultra-szerokopasmowych bezprzewodowych rur, które mogą bezproblemowo kleić przewodowe i bezprzewodowe sieci. Inne zalety komunikacji mmWave obejmują małe rozmiary anten (λ/ 2) i ich małe separacje (również około λ / 2), co pozwala na pakowanie dziesiątek elementów antenowych w zaledwie jeden centymetr kwadratowy. To z kolei pozwala nam uzyskać bardzo wysokie zyski kształtowania wiązki na stosunkowo małych obszarach, które mogą być realizowane zarówno w BS, jak iw UE. Wykorzystując inteligentne anteny z fazowaną matrycą, możemy w pełni wykorzystać przestrzenny stopień swobody kanału bezprzewodowego (za pomocą SDMA), co może jeszcze bardziej zwiększyć wydajność systemu. Wreszcie, gdy stacja ruchoma porusza się, ciężary kształtujące wiązkę można dostosować adaptacyjnie, tak aby wiązka anteny zawsze wskazywała BS. Niedawno Samsung Electronics, lider branży badającej pasma mmWave do komunikacji mobilnej, przetestował technologię, która może osiągnąć prędkość transmisji 2 Gb / s przy zasięgu 1 km w środowisku miejskim. Ponadto profesor Theodore Rappaport i jego zespół badawczy z Polytechnic Institute of New York University wykazali, że komunikacja mobilna o częstotliwości 28 GHz w gęstym środowisku miejskim, takim jak Manhattan, NY, jest możliwa do zrealizowania przy rozmiarze komórki 200 m przy użyciu dwóch anten 25 dBi , jeden w BS, a drugi w UE, co jest łatwo osiągalne za pomocą anten macierzowych i techniki formowania wiązki. Wreszcie, utrata liści dla mmWaves jest znacząca i może ograniczać rozmnażanie. Ponadto, transmisje mmWave mogą również doświadczyć znacznego tłumienia w obecności ulewnego deszczu, ponieważ krople deszczu są mniej więcej tej samej wielkości co długości fal radiowych (milimetry), a zatem mogą powodować rozpraszanie. Dlatego w ramach rozwiązania mmWave może być potrzebny zapasowy system komórkowy działający w starszych pasmach poniżej 3 GHz
VI. Przeprojektowanie łączy typu backhaul
Przeprojektowanie łączy typu backhaul jest kolejnym krytycznym problemem 5G. Równolegle z ulepszaniem RAN, łącza typu backhaul muszą być również przeprojektowane, aby przenosić ogromną ilość ruchu użytkowników generowanego w komórkach. W przeciwnym razie łącza dosyłowe wkrótce staną się wąskimi gardłami, zagrażając prawidłowemu działaniu całego systemu. Problem nabiera tempa wraz ze wzrostem populacji małych komórek. Można rozważyć różne media komunikacyjne, w tym światłowód, mikrofalę i falę mm. W szczególności można rozważyć łącza mmWave punkt-punkt wykorzystujące anteny macierzowe z bardzo ostrymi wiązkami, aby zapewnić niezawodne samo-backhaulowanie bez zakłócania innych komórek lub łączy dostępu.
VII. Efektywność energetyczna
EE pozostanie ważnym zagadnieniem projektowym podczas opracowywania 5G. Obecnie technologie informacyjno-komunikacyjne (ICT) zużywają aż 5% energii elektrycznej produkowanej na całym świecie i odpowiadają za około 2% globalnych emisji gazów cieplarnianych - w przybliżeniu odpowiada to emisjom wytwarzanym przez przemysł lotniczy. Bardziej dotyczy to faktu, że jeśli nie podejmiemy żadnych środków mających na celu zmniejszenie emisji dwutlenku węgla, przewiduje się, że wkład ten podwoi się do 2020 r. W związku z tym konieczne jest dążenie do energooszczędnych podejść projektowych z łączy RAN i dosyłowych do urządzeń UE. Korzyści płynące z projektowania energooszczędnych systemów są różnorodne. Po pierwsze, może odgrywać ważną rolę w zrównoważonym rozwoju poprzez zmniejszenie śladu węglowego samego przemysłu mobilnego. Po drugie, ICT jako podstawowa technologia wspomagająca przyszłe inteligentne miasta mogą również odgrywać zasadniczą rolę w zmniejszaniu śladu węglowego innych sektorów (np. Transportu). Po trzecie, może zwiększyć przychody operatorów telefonii komórkowej poprzez zmniejszenie wydatków operacyjnych (Opex) dzięki oszczędności na rachunkach za energię elektryczną. Po czwarte, obniżenie kosztu "Joule per bit" może zapewnić przystępność cenową usług mobilnych dla użytkowników, umożliwiając ustalanie stawek ryczałtowych pomimo 10-100-krotnej poprawy przepływności danych oczekiwanej do 2020 roku. UE, które TNS określiła jako firma zajmująca się badaniem rynku jako kryterium numer jeden dla większości konsumentów kupujących telefon komórkowy.
VIII. Przydział nowego widma dla 5G
Kolejną istotną kwestią 5G jest przydzielenie nowego widma do zasilania komunikacji bezprzewodowej w następnej dekadzie. 1000-krotny wzrost natężenia ruchu jest trudny do opanowania tylko dzięki poprawie wydajności widmowej lub hiper-zagęszczeniu. W rzeczywistości wiodące firmy telekomunikacyjne, takie jak Qualcomm i NSN wierzą, że oprócz innowacji technologicznych, aby zaspokoić popyt, potrzeba 10 razy więcej widma. Alokacja pasma około 100 MHz w paśmie 700 MHz i kolejna szerokość pasma 400 MHz przy około 3,6 GHz, a także potencjalna alokacja kilku pasm GHz w pasmach cm lub mmWave do 5G będzie centralnym punktem kolejnej konferencji WRC , organizowane przez ITU-R w 2015 roku.
IX. Udostępnianie widma
Proces regulacyjny dotyczący nowego przydziału widma jest często bardzo czasochłonny, więc efektywne wykorzystanie dostępnego widma ma zawsze kluczowe znaczenie. Innowacyjne modele przydziału widma (inne niż tradycyjne przydziały licencjonowane lub nielicencjonowane) mogą zostać przyjęte w celu przezwyciężenia istniejących ograniczeń regulacyjnych. Wiele widma radiowego jest tradycyjnie przydzielane do radarów wojskowych, gdzie widmo nie jest w pełni wykorzystywane przez cały czas (24/7) lub w całym regionie geograficznym. Z drugiej strony, czyszczenie widma jest bardzo trudne, ponieważ niektóre widma nigdy nie mogą być czyszczone lub mogą być czyszczone tylko przez bardzo długi czas; poza tym widmo może być czyszczone w niektórych miejscach, ale nie w całym kraju. W związku z tym Qualcomm zaproponował model autoryzowanego / licencjonowanego wspólnego dostępu (ASA / LSA) do wykorzystania widma w małych komórkach (o ograniczonym zasięgu) bez zakłócania pracy obecnego użytkownika (np. Radarów wojskowych). Ten rodzaj modelu przydziału widma może skompensować bardzo powolny proces czyszczenia widma. Warto również wspomnieć, że wraz z przyspieszeniem wzrostu ruchu mobilnego ważna staje się refarming widma, aby wyczyścić wcześniej przydzielone widmo i udostępnić je dla 5G. Koncepcje radia kognitywnego można również ponownie rozważyć, aby wspólnie korzystać z licencjonowanych i nielicencjonowanych widm. Wreszcie, nowe modele współdzielenia widma mogą być potrzebne, ponieważ obsługa sieci wielu najemców staje się powszechna
X. Wirtualizacja RAN
Ostatnim, ale nie mniej ważnym czynnikiem 5G jest wirtualizacja RAN, umożliwiająca współdzielenie infrastruktury bezprzewodowej między wieloma operatorami. Wirtualizacja sieci musi być przesyłana z przewodowej sieci rdzeniowej (np. Przełączników i routerów) w kierunku sieci RAN. W przypadku wirtualizacji sieci inteligencja musi zostać wyjęta ze sprzętu RAN i kontrolowana w sposób scentralizowany przy użyciu mózgu oprogramowania, co można zrobić w różnych warstwach sieci. Wirtualizacja sieci może przynieść niezliczone korzyści domenie bezprzewodowej, w tym zarówno wydatki kapitałowe (wydatki inwestycyjne), jak i oszczędności Opex dzięki współdzieleniu sieci i urządzeń przez wielu najemców, ulepszone EE, skalowanie w górę lub w dół wymaganych zasobów oraz zwiększoną sieć sprawność dzięki skróceniu czasu potrzebnego na innowacyjne usługi (od 90 godzin do 90 minut), a także łatwość konserwacji i szybkie rozwiązywanie problemów dzięki większej przejrzystości sieci. Wirtualizacja może również służyć do konwergencji sieci przewodowych i bezprzewodowych poprzez wspólne zarządzanie całą siecią z centralnej jednostki orkiestracyjnej, co jeszcze bardziej zwiększa wydajność sieci. Na koniec można zastosować sieci RAN obsługujące wiele trybów, obsługujące 3G, 4G lub WiFi, w których różne centralne interfejsy radiowe mogą być włączane i wyłączane za pomocą centralnej jednostki sterującej oprogramowaniem w celu poprawy EE lub jakości doświadczenia (QoE) dla użytkowników końcowych.
IX Filarów Technologii dla Przemysłu 4.0
I. Roboty autonomiczne: Wykonywanie zadań z minimalną ingerencją człowieka lub bez niej
Roboty są powszechnie wykorzystywane do wykonywania powtarzalnych, żmudnych i niebezpiecznych zadań. W ostatnich dniach roboty są w stanie świadczyć coraz szerszy zakres usług, stając się jednocześnie bardziej elastycznymi, współpracującymi i autonomicznymi. Roboty te współdziałają ze sobą i są zaprojektowane w sposób umożliwiający bezpieczną pracę z ludźmi. Stworzony z dwóch oddzielnych słów "współpraca" i "robotyka", Cobotics jest popularnym terminem używanym do opisania robotów pomagających operatorom w wykonywaniu codziennych zadań operacyjnych. Roboty stają się coraz bardziej inteligentne i mogą teraz uczyć się od ludzi, aby wykonywać różne złożone i wymagające zadania. W fabrykach wykorzystywane są autonomiczne roboty, które pełnią różne role. Roboty w pełni autonomiczne są zwykle wykorzystywane do procesów o dużej objętości i powtarzalności, ponieważ dokładność, szybkość i trwałość robota mają znaczne zalety. Wiele hal produkcyjnych używa robotów do pomocy w wykonywaniu bardziej skomplikowanych zadań. Roboty są powszechnie używane do wykonywania zadań, takich jak podnoszenie, przytrzymywanie i przesuwanie ciężkich lub nieporęcznych elementów. Roboty są zaprojektowane tak, aby były bardziej elastyczne, współpracujące i autonomiczne oraz mogą wchodzić ze sobą w interakcje i bezpiecznie współpracować z ludźmi. Przy zachowaniu dobrego bezpieczeństwa, elastyczności i wszechstronności roboty autonomiczne mogą wykonać dane zadanie z dużą precyzją i wydajnością. Wprowadzenie autonomicznych robotów odgrywa kluczową rolę we współczesnym przemyśle wytwórczym. Roboty mogą inteligentnie wykonywać zadania, z uwzględnieniem wszechstronności, bezpieczeństwa i elastyczności. Dzięki najnowszym innowacjom technologicznym produkowane są roboty, które są bardziej autonomiczne, aby wspierać rewolucję przemysłową. Roboty i ludzie pracują ramię w ramię nad łączeniem zadań za pomocą interfejsu człowiek-maszyna. Wdrażanie robotów w produkcji jest powszechne i zachęcające, ponieważ obejmuje różne funkcje, tj. logistykę, produkcję, zarządzanie biurem itp. Od 2004 r. liczba wielozadaniowych robotów przemysłowych opracowanych przez firmy w Europie wzrosła dwukrotnie. Włączenie robotów do automatyzacji w produkcji skłania firmy do utrzymania konkurencyjności na arenie międzynarodowej, ponieważ stanowi to skuteczne rozwiązanie w celu uzupełnienia luki w umiejętnościach w obszarach, w których trudno jest zatrudnić odpowiednio wykwalifikowanych pracowników. Dzięki wdrożeniu robotów autonomicznych pracownicy mogą poświęcić więcej czasu na projektowanie, innowacje, planowanie i strategię, które są równie ważne dla rozwoju i sukcesu. Automatyzacja produkcji za pomocą robotów doprowadzi do większego bezpieczeństwa i satysfakcji pracowników, zwiększonej produktywności i ostatecznie wyższej rentowności. Istnieją uzasadnione przesłanki, aby skłonić właścicieli fabryk do stosowania autonomicznych robotów w swoich podmiotach. Po pierwsze, ponieważ przy wytwarzaniu produktu zaangażowanych jest wiele procesów produkcyjnych, roboty mogą być wykorzystywane do automatyzacji każdego zadania, od obsługi surowców po pakowanie gotowego produktu. Po drugie, roboty nie potrzebują odpoczynku jak ludzie i mogą pracować 24 godziny na dobę, aby wykonywać zadania w sposób ciągły. Po trzecie, nowoczesne roboty są opracowywane w taki sposób, aby były bardzo elastyczne i można je wygodnie dostosowywać do wykonywania różnych funkcji, w tym złożonych. Po czwarte, wykorzystanie robota do automatyzacji w produkcji jest opłacalne i poprawia wyniki finansowe firmy. Wreszcie automatyzacja za pomocą robotów pomoże osiągnąć wysoką prędkość produkcji i szybsze dostarczanie produktów do klientów. Niektóre roboty są zaprojektowane tak, aby były mobilne w wykonywaniu swoich zadań. Planowanie ruchu to trudny aspekt w dziedzinie autonomicznych robotów mobilnych, który pozwala im przemieszczać się z jednej pozycji do drugiej w różnych środowiskach, które mogą obejmować zarówno statyczne, jak i dynamiczne przeszkody. Zaproponowano inteligentne i zoptymalizowane rozwiązanie nawigacyjne z zastosowaniem techniki sztucznej inteligencji, aby zapewnić maksymalne bezpieczeństwo oraz krótszą i lepszą opcję wyznaczania tras. Roboty autonomiczne różnych dostawców, takich jak ABB, Bionic Robotics, Fanuc, Gomtec, Kuka itp., są obecnie szeroko stosowane w różnych zastosowaniach przemysłowych. Różne modele robotów są opracowywane przez różnych kluczowych graczy, aby wspierać trend technologiczny Przemysłu 4.0. Coraz więcej krajów intensyfikuje wysiłki na rzecz zatrudniania robotów przemysłowych w swoim przemyśle wytwórczym. Republika Korei znalazła się na szczycie listy w 2016 r. z 631 robotami przemysłowymi na 10 000 pracowników. Niedawny rozwój robotów autonomicznych był wyjątkowy i zachęcający. W wielu fabrykach autonomiczne roboty są w stanie przenosić surowce, półprodukty i gotowe towary w sposób wydajniejszy, szybszy i inteligentniejszy. Ponieważ roboty działają w oparciu o złożony algorytm logiczny, nie wymagają żadnej z góry ustalonej ścieżki do realizacji swoich zadań. Zastosowanie robotów w rzeczywistości sprawiło, że proces produkcyjny stał się wydajniejszy i bardziej opłacalny.
II. Symulacja: Tworzenie w wirtualnym świecie i przewidywanie wyników działania
Symulację definiuje się jako przybliżoną imitację działania procesu lub systemu. Jest wykorzystywana w wielu funkcjach, takich jak inżynieria bezpieczeństwa, optymalizacja wydajności, szkolenia, testowanie, projektowanie itp. Symulacja odgrywa kluczową rolę w Przemyśle 4.0, ponieważ ta technologia pomaga osiągać lepsze wyniki na wiele sposobów. Zasadniczo zmniejsza niepotrzebne marnotrawstwo czasu i zasobów, jednocześnie zwiększając wydajność produkcji. Ponadto znacznie zwiększa wydajność i przychody firmy produkcyjnej. Poza tym symulacja jest bardzo ważna na etapie projektowania produktu, ponieważ pozwala na należytą ocenę wyników produktu i wprowadzenie niezbędnych zmian, jeśli produkt nie spełnia specyfikacji. Za pomocą kroków symulacyjnych można znacznie poprawić i ustalić jakość podejmowania decyzji. Warto zauważyć, że symulacja 3D rozwoju produktu, rozwoju materiałów i procesów produkcyjnych stała się normalną praktyką w wielu firmach jako niezbędny krok. Wykorzystuje dane w czasie rzeczywistym, aby
odzwierciedlić świat fizyczny w wirtualnym modelu ucieleśniającym ludzi, maszyny i produkty. Symulacja umożliwia również operatorom testowanie i optymalizację ustawień maszyny dla następnego produktu w linii w świecie wirtualnym przed rzeczywistą fizyczną rekonfiguracją, dzięki czemu czas przestoju maszyny na konfigurację jest minimalny, przy jednoczesnym zwiększeniu ogólnej jakości. W zakładach produkcyjnych częściej stosuje się narzędzia symulacyjne do odzwierciedlenia świata fizycznego w modelu wirtualnym, głównie w celu skrócenia czasu konfiguracji maszyny i podniesienia ogólnej jakości. Wykorzystanie symulacji procesów produkcyjnych nie tylko skróci czas przestojów, ale także zmniejszy awarie produkcyjne w fazie rozruchu. Symulacja z systemami komputerowymi zapewnia narzędzie do modelowania i oceny do analizy złożonych systemów. Symulacja była wykorzystywana do ulepszania projektowania złożonych systemów już w latach 50. XX wieku. Początkowo przeprowadzono symulacje, aby zweryfikować projekty systemów,
aby sprawdzić, czy spełniają one określone z góry cele. Dzięki serii symulacji zasadniczo oszczędzają czas i zasoby, ustanawiając weryfikację koncepcji przed zbudowaniem systemu fizycznego. Symulacje są przydatne do oceny różnych opcji projektów systemów, co następnie pomaga projektantowi wybrać najlepszą wydajność lub najbardziej zoptymalizowany projekt. Ponadto symulacje mogą być wykorzystywane do pomocy projektantom w identyfikacji mocnych i słabych stron konkretnego projektu. Co istotne, model symulacyjny jest w stanie wykorzystać specyficzność w celu zwiększenia wierności modelowanemu systemowi. W związku z tym dane wyjściowe z modelu symulacyjnego mogą oferować wiarygodne prognozy wydajności systemu. Na podstawie wyników symulacji projektant może zdecydować, czy zbudować system fizyczny, czy też nie. Modele symulacyjne są zwykle wymagane do uchwycenia ważnych systemów i operacji z dużą ilością szczegółów. Dlatego modele symulacyjne są zwykle bardzo złożone i obliczeniowo drogie w prowadzeniu. Koszt
obliczeń jest jeszcze wyższy, gdy do kontrolowania szumu w symulacjach stochastycznych konieczne są wielokrotne replikacje symulacji. Ponadto należy dostarczyć modelarzom symulacyjnym wystarczającą ilość danych wysokiej jakości, aby mogli oszacować modele rozkładu prawdopodobieństwa dla różnych źródeł niepewności i losowości w systemie. Modele symulacyjne są zwykle używane na etapie projektowania systemu, aby projektanci mieli wystarczająco dużo czasu na zebranie danych i przeprowadzenie symulacji w celu uzyskania statystycznie uzasadnionych wniosków do podjęcia decyzji. Gwałtowny wzrost mocy obliczeniowej w ostatnich latach, w postaci przetwarzania w chmurze i wysokowydajnych klastrów obliczeniowych, zachęcił do podejmowania dalszych decyzji opartych na symulacjach, które wcześniej były ograniczone ze względu na obawy związane z kosztami obliczeniowymi. Optymalizacja symulacji umożliwia projektantowi systemu systematyczne i metodyczne przeszukiwanie dużej przestrzeni decyzyjnej w celu uzyskania optymalnego
projektu bez ograniczania się do kilku konkretnych opcji. Ta zdolność optymalizacji znacznie zwiększa możliwości narzędzia do symulacji zakresu dla złożonych projektów. Obecnie jest to aktywny obszar badawczy i istnieje wiele komercyjnych produktów oprogramowania symulacyjnego, które są wyposażone w integrację rozwiązań optymalizacji symulacji. Optymalizacja symulacji jest zasadniczo użytecznym narzędziem do znajdowania optymalnego projektu systemu w oparciu o model symulacji komputerowej. Służy do przewidywania i oceny wydajności złożonych systemów stochastycznych. Ciągłe wysiłki na rzecz optymalizacji symulacji i wykładniczego wzrostu mocy obliczeniowej sprawiły, że korzystanie z symulacji w celu bezpośredniej optymalizacji projektowania i działania systemów stało się bardziej atrakcyjne
III. Pozioma i pionowa integracja systemu: Łączenie, współpraca i współpraca w poziomie i pionie
System można zintegrować poziomo i pionowo. Integracja pozioma może doprowadzić tworzenie sieci między systemami cyberfizycznymi na bezprecedensowy poziom w celu osiągnięcia większej wydajności. Każde urządzenie i system tego samego poziomu produkcji w tym samym zakładzie jest ze sobą połączone. Istnieje również komunikacja danych między systemami w różnych obiektach, umożliwiająca planowanie i rozdzielanie zadań między sobą. Mając to na uwadze, przestój w określonym zakładzie może zostać pokryty lub zrekompensowany przez maszyny z innego zakładu przy niewielkiej interwencji człowieka lub bez niej. Tymczasem integracja pionowa jest stosunkowo trudniejszym przedsięwzięciem. Każdy system na różnych poziomach hierarchii ma dostęp do wszystkich zebranych lub wygenerowanych danych. Obecnie głównym wyzwaniem jest to, że różne protokoły komunikacyjne są używane na różnych poziomach. W związku z tym systemy mają trudności z komunikacją i wymianą danych między sobą. Jeśli jednak integracja pionowa w obiekcie zostanie przeprowadzona prawidłowo, wydajność ulegnie znacznej poprawie. Można to rozwiązać za pomocą odpowiednich i odpowiednich interfejsów. Pełna integracja i automatyzacja procesów produkcyjnych w pionie i poziomie pokazuje automatyzację komunikacji i współpracy, szczególnie w ramach standaryzowanych procesów. W przypadku integracji poziomej stara się realizować połączone sieci systemów cyberfizycznych i korporacyjnych, które osiągają nowy poziom elastyczności, automatyzacji i wydajności operacyjnej w procesach produkcyjnych. Ten rodzaj integracji może mieć miejsce na różnych poziomach. Na poziomie hali produkcyjnej połączone z Internetem maszyny i jednostki produkcyjne stają się obiektem o ściśle określonych właściwościach w ramach sieci produkcyjnej. Nieustannie komunikują swój stan wydajności i autonomicznie reagują na zmieniające się wymagania produkcyjne. Skutkuje to lepszą opłacalnością w produkcji elementów i skrócenie przestojów maszyn dzięki konserwacji predykcyjnej. Integracja pozioma może wystąpić w wielu zakładach produkcyjnych, gdzie dane zakładu produkcyjnego są współdzielone w całym przedsiębiorstwie, co umożliwia wykonywanie zadań produkcyjnych inteligentnie przydzielone do obiektów, aby sprawnie i szybko reagować na zmiany zmiennych produkcyjnych. Ponadto integracja pozioma może mieć miejsce w całym łańcuchu dostaw, gdzie przejrzystość danych i wysoki poziom zautomatyzowanej współpracy w ramach (i) łańcucha dostaw i logistyki, który sam obsługuje procesy produkcyjne, oraz (ii) łańcucha dostaw, który dostarcza gotowe produkty do rynek. Z drugiej strony integracja pionowa pomaga powiązać wszystkie warstwy logiczne w organizacji, takie jak produkcja, badania i rozwój, zapewnienie jakości, technologia informacyjna, sprzedaż i marketing, zasoby ludzkie itp. Ten rodzaj integracji umożliwia swobodny przepływ danych między tymi warstwami, aby ułatwić podejmowanie decyzji taktycznych i strategicznych. Integracja pionowa zasadniczo tworzy przewagę konkurencyjną, ponieważ umożliwia firmie szybką i odpowiednią reakcję na zmieniające się sygnały rynkowe, a także nowe możliwości. Obecnie odkryto, że wiele systemów informatycznych wciąż nie jest w pełni zintegrowanych. Większość firm rzadko jest połączona ze swoimi dostawcami i klientami za pomocą połączenia internetowego. Nawet w ramach własnej firmy dział projektowania technicznego nie jest bezpośrednio połączony z jej halą produkcyjną. Dlatego mamy nadzieję, że wraz z wprowadzeniem Przemysłu 4.0 większość firm produkcyjnych podejmie kroki w celu ścisłego powiązania lub wzajemnego połączenia między działami oraz między dostawcami i klientami. Dzięki uniwersalnym sieciom integracji danych obejmujących wiele firm, które umożliwiają całkowicie zautomatyzowany łańcuch wartości, pozioma i pionowa integracja systemów między firmami, działami, funkcjami i możliwościami będzie bardziej spójna i wydajna.
IV. Przemysłowy Internet Rzeczy: Sprawianie, że przedmioty komunikują się ze sobą i z ludźmi
IoT to ogromna liczba urządzeń, maszyn lub systemów, które są połączone za pośrednictwem sieci lub Internetu w celu udostępniania i manipulacji danymi. To ekosystem, w którym wszystkie czujniki i aktuatory mogą funkcjonować oddzielnie i komunikować się ze sobą. IoT jest również czasami określany jako Internet wszystkiego (IoE), obejmujący IoS, Internet usług produkcyjnych (IoMs), Internet ludzi (IoP) oraz integrację technologii informacyjnych i komunikacyjnych (IICT). Kelvin Ashton, brytyjski pionier technologii, po raz pierwszy zapoczątkował koncepcję IoT w 1999 roku. Jak widać w przemyśle motoryzacyjnym, istnieje komunikacja między różnymi urządzeniami i systemami w samochodzie. Wprowadzenie Connected Car umożliwia komunikację w czasie rzeczywistym, m.in. systemy nawigacyjne w połączeniu z rejestrami pojazdów i ustawianiem połączeń alarmowych w razie wypadku. Przemysłowy IoT (IIoT), po raz pierwszy wspomniany przez General Electric, to solidna wersja IoT, która ma zwiększoną odporność, aby przetrwać w trudnych warunkach branży. Jako podkategoria IoT, IIoT jest ważny, ponieważ wykorzystuje inteligentne czujniki i siłowniki do usprawnienia procesów produkcyjnych. Jest to sieć inteligentnych urządzeń połączonych w kompletny system gromadzący, wymieniający i analizujący dane. Ogólnie rzecz biorąc, system IIoT składa się z (i) inteligentnych urządzeń, które mogą gromadzić, przechowywać i przekazywania danych, (ii) prywatna lub publiczna infrastruktura teleinformatyczna oraz (iii) systemy analizy danych, które generują przydatne informacje biznesowe. Obejmuje również wykorzystanie gromadzenia i analizy danych w różnych branżach, takich jak produkcja, energetyka, rolnictwo, transport, opieka zdrowotna itp. Urządzenia IIoT obejmują szeroki zakres, od małych czujników środowiskowych po złożone przemysłowe roboty autonomiczne. Systemy IIoT zwykle składają się z warstwowej architektury modułowej technologii cyfrowej. Warstwy te to warstwa urządzenia, warstwa sieciowa, warstwa usługowa i warstwa treści. Warstwa urządzenia zwykle składa się z komponentów fizycznych, takich jak czujniki, maszyny, systemy cyberfizyczne (CPS) itp. Tymczasem warstwa sieciowa zwykle składa się z magistral sieciowych, protokołów komunikacyjnych, przetwarzania w chmurze itp. Warstwy usług składają się z oprogramowania lub aplikacje analizujące dane i ostatecznie przekształcić je w przydatne informacje. Na górze znajduje się warstwa treści, która jest urządzeniem obsługującym interfejs użytkownika, takim jak monitor, wyświetlacz, tablet, inteligentne szkło itp. IIoT zmienia zasady gry, zapewniając doskonałą wydajność operacyjną i przedstawia zupełnie nowy model biznesowy, który przynosi korzyści nie tylko pewnej firmy, ale także ogółu społeczeństwa. Obecnie IIoT są wykorzystywane w wielu branżach w celu usprawnienia ich codziennej pracy. Technologia IIoT jest agresywnie wdrażana w sektorze produkcyjnym w celu poprawy wydajności produkcji. Maszyna z obsługą IIoT może mieć inteligentne funkcje monitorowania i przewidywać potencjalne problemy, co skutkuje krótszymi przestojami i lepszą ogólną wydajnością. W sektorze łańcucha dostaw technologia IIoT jest wykorzystywana do obsługi zamówień dostaw, zanim się skończą. Pomaga to utrzymać niezbędne artykuły w magazynie i zmniejsza ilość wytwarzanych odpadów. W linii detalicznej IIoT pomaga w inteligentnym i szybkim podejmowaniu decyzji dla poszczególnych sklepów. Jako strategia biznesowa z wdrożeniem technologii IIoT, panele wyświetlające, które automatycznie odświeżają się zgodnie z zainteresowaniami klientów i ich zdolnością do inteligentnej promocji, mogą pomóc sklepowi w uzyskaniu znaczącej przewagi nad innymi firmami. W opiece zdrowotnej IIoT sprawia, że branża staje się bardziej responsywna, bardziej precyzyjna i bezpieczniejsza. Wprowadza urządzenia, które zdalnie monitorują pacjentów i informują lekarzy o nieprawidłowościach lub nietypowych wzorcach w danych monitorujących stan pacjentów. Technologia IIoT przenika również do sektora zarządzania budynkami, gdzie zastosowanie tej technologii może sprawić, że zadania związane z zarządzaniem budynkami będą bezpieczniejsze i wydajniejsze. Wykorzystywana jest kontrola klimatu oparta na czujnikach, co usunie niedokładne domysły związane z ręczną zmianą klimatu w budynku. Dodatkowo dzięki technologii IIoT, instalacja urządzeń sieciowych do monitorowania wejścia do budynku może zwiększyć bezpieczeństwo i umożliwić szybką reakcję w przypadku potencjalnego zagrożenia. Jednym z głównych wyzwań dla IoT w Industry 4.0 jest brak wspólnych standardów. Posiadanie urządzeń połączonych ze sobą w celu udostępniania danych jest dobre; jednak gdy wszystkie z nich zbierają dane w różnych formatach i mają różne protokoły, integracja ich w całkowicie zautomatyzowaną fabrykę będzie trudna i kosztowna. Duże firmy, takie jak Bosch, Eclipse Foundation i inne, pracują w standardowych architekturach komunikacyjnych i protokołach, takich jak protokół zarządzania wydajnością produkcji (PPMP), transport telemetryczny kolejkowania wiadomości (MQTT) i OPC UA. Dzięki temu podłączone urządzenia, w tym te w hali produkcyjnej, mogą bezproblemowo komunikować się ze sobą. Kolejnym głównym wyzwaniem jest bezpieczeństwo w Internecie. Ponieważ urządzenia są połączone z Internetem, są podatne na ataki i podatne na włamania i nadużycia ze strony hakerów. Eksperci ds. bezpieczeństwa szybko poruszają się, aby rozwiązać problemy związane z cyberbezpieczeństwem w Internecie Rzeczy, łącząc nowe technologie ze standardowym bezpieczeństwem IT
V. Cyberbezpieczeństwo: ochrona systemów i sieci komputerowych
Cyberbezpieczeństwo jest niezwykle istotnym elementem Przemysłu 4.0, ponieważ chroni systemy komputerowe, sieci i dane przed złośliwymi działaniami, takimi jak atak sieciowy, nieautoryzowany dostęp, kradzież danych, zakłócenia, uszkodzenia itp. Staje się ważniejszy niż kiedykolwiek ze względu na rosnącą liczbę podłączonych urządzeń i systemów. Ochrona danych przy zachowaniu wydajności systemów to główny cel cyberbezpieczeństwa. Niepokojący jest fakt, że systemy informatyczne wielu instytucji są codziennie atakowane i włamywane. Niezwykle ważne jest, aby fabryki były świadome swoich potencjalnych słabości i dobrze przygotowane na wszelkie nadchodzące zagrożenia. Bardzo ważne jest posiadanie solidnego cyberbezpieczeństwa, ponieważ zapewnia to, że codzienne prowadzenie działalności produkcyjnej nie zostanie poważnie naruszone, co może kosztować ogromne straty dla firmy. W przypadku Przemysłu 4.0 posiadanie zaawansowanego zarządzania tożsamością i dostępem do maszyn i użytkowników oraz wiarygodnych systemów komunikacyjnych ma ogromne znaczenie, ponieważ problem zagrożeń cyberbezpieczeństwa staje się coraz poważniejszy wraz ze wzrostem łączności i szerszym wykorzystaniem standardowych protokołów komunikacyjnych. Zwiększenie gęstości danych oraz fuzja technologii informacyjnej i operacyjnej niesie ze sobą ogromne wyzwanie dla cyberbezpieczeństwa. W ostatnich latach wiele rządów traktowało cyberbezpieczeństwo jako główny problem krajowy o najwyższym znaczeniu. Ważna jest ochrona informacji biznesowych w postaci cyfrowej przed nieautoryzowanym dostępem, kradzieżą i nadużyciami. Wraz z rosnącymi połączeniami sieciowymi cyberataki stają się coraz bardziej powszechne w miarę kradzieży danych można wykorzystać do uzyskania określonych korzyści w formie finansowej i strategicznej. Cyberataki i zagrożenia internetowe stały się coraz poważniejsze w ciągu ostatniej dekady. Problemy te dotyczą w szczególności bezpośrednio i pośrednio użytkowników systemów IoT. Duże firmy lub przedsiębiorstwa są często narażone na złośliwe ataki, które oprócz innych niedogodności, takich jak awarie systemu, wycieki danych, naruszenia prywatności, uszkodzenie danych, spowolnienie systemów itp., powodują ogromne straty finansowe. Powszechne korzystanie z podłączonych urządzeń i usług stworzył ogromne zapotrzebowanie i zachęcenie do nowych form potężnej obrony cybernetycznej w celu zwalczania problemu cyberataków. W wielu firmach cyberbezpieczeństwo jest identyfikowane jako główny problem technologiczny. Większość dużych firm wzmocniła cyberobronę i możliwości swoich systemów informatycznych w celu zapobiegania atakom. Przydzielono i wydano miliony dolarów na zakup zaawansowanych systemów i opracowanie nowych strategii z inwestycjami w bezpieczeństwo IT, aby zmniejszyć ryzyko cyberzagrożeń. W systemie IoT można go ogólnie podzielić na cztery główne poziomy, tj. warstwę percepcji, warstwę sieciową, warstwę usługową i aplikację. System może być podatny na ataki, a cyberatak może nastąpić na dowolnym poziomie systemu. Aby rozwiązać problemy związane z cyberbezpieczeństwem, różne strony muszą ściśle ze sobą współpracować, aby ograniczyć wpływ do minimum. Interesariusze ci to eksperci ds. bezpieczeństwa IT, producenci, regulatorzy, społeczność normalizacyjna i środowisko akademickie. Aby zapewnić sukces w rozwiązywaniu tych problemów, każdy z nich powinien aktywnie podejmować swoje role. Obejmuje ważne role, takie jak (i) promowanie wielofunkcyjnej wiedzy na temat bezpieczeństwa IT i OT, (ii) wyjaśnianie odpowiedzialności wśród podmiotów Przemysłu 4.0, (iii) wspieranie zachęt ekonomicznych i administracyjnych dla bezpieczeństwa Przemysłu 4.0, (iv) zabezpieczanie zarządzania łańcuchem dostaw procesy, (v) harmonizacja wysiłków na rzecz standardów bezpieczeństwa Przemysłu 4.0, (vi) ustanowienie linii bazowych Przemysłu 4.0 dla interoperacyjności bezpieczeństwa oraz (vii) zastosowanie środków technicznych w celu zapewnienia bezpieczeństwa Przemysłu 4.0. Eksperci ds. bezpieczeństwa IT powinni promować wielofunkcyjną wiedzę z zakresu bezpieczeństwa IT i OT oraz bezpiecznych procesów zarządzania łańcuchem dostaw. Ta grupa ekspertów może pomóc w ustaleniu bazowych standardów Przemysłu 4.0 dla interoperacyjności bezpieczeństwa, oprócz zastosowania środków technicznych w celu zapewnienia bezpieczeństwa Przemysłu 4.0. Duże znaczenie ma również bezpieczna i niezawodna komunikacja w połączeniu z wyrafinowanym zarządzaniem tożsamością i dostępem do maszyn i użytkowników
VI. Cloud Computing: dostęp do informacji z dowolnego miejsca za pomocą Internetu
Przetwarzanie w chmurze odnosi się do zdalnego systemu, w którym można uzyskać zdalny dostęp do informacji z dowolnego miejsca za pośrednictwem Internetu. Dzięki wdrożeniu chmury obliczeniowej system produkcyjny umożliwia dostarczanie różnych usług przez Internet z zasobami obejmującymi narzędzia i aplikacje, takie jak bazy danych, magazyny danych, serwery, sieci, oprogramowanie itp. Zamiast przechowywać dane na własnym, lokalnym urządzeniu magazynującym lub dysk twardy, przetwarzanie w chmurze przechowuje informacje w zdalnej bazie danych. Gdy urządzenie komputerowe ma połączenie z Internetem, może wygodnie uzyskiwać dostęp do danych na zdalnym serwerze i uruchamiać określone oprogramowanie w celu manipulacji lub przetwarzania danych. Aby osiągnąć szybszy czas reakcji, nawet na poziomie poniżej sekundy, organizacja wymaga udostępniania danych między witrynami i firmami, co zapewnia przetwarzanie w chmurze. Zaczęło być popularnym wsparciem zarówno dla użytkowników indywidualnych, jak i firm, ponieważ ma kluczowe zalety w postaci wyższej efektywności kosztowej, lepszego bezpieczeństwa, zwiększonej produktywności, szybszego przetwarzania i najwyższej wydajności. Przetwarzanie w chmurze to ważna technologia, która pomaga ludziom współpracować. Jest to narzędzie do współpracy, które rewolucjonizuje kulturę pracy zarządzania danymi. Firmy lub firmy są obecnie bardziej otwarte na wymianę informacji, zamiast zatrzymywać je dla siebie. Praktyka otwierania przyniesie korzyści firmie jako całości, osiągając lepsze wyniki finansowe. Dzięki przetwarzaniu w chmurze ma praktycznie nieskończone możliwości przechowywania dla użytkowników. Istnieje potrzeba, aby firma udostępniała informacje i umożliwiała podejmowanie działań, gdy więcej informacji jest generowanych i gromadzonych. Będzie to korzystne dla każdego użytkownika, który ma dostęp do systemu komputerowego w celu wykonania swoich zadań, a także dla całej firmy. Generalnie wyróżnia się cztery rodzaje chmur, tj. chmura publiczna, chmura społecznościowa, chmura prywatna i chmura hybrydowa. Ich charakterystykę podsumowano w Tabeli
Rodzaj chmury: Opis
Chmura publiczna: nie działa w ramach IT firmy. Zwykle oferowane przez operatorów usług IT. Otwarte dla każdej osoby, firmy lub ogółu społeczeństwa.
Chmura społecznościowa : dostępna tylko dla tych firm lub instytucji, które dołączyły do odpowiedniej grupy z określonymi wymaganiami. Współdzielone przez kilka organizacji, które mają wspólne obawy (np. bezpieczeństwo, misja, zgodność itp.). Może być zarządzany przez zaangażowane organizacje lub stronę trzecią.
Chmura prywatna : dostępna wyłącznie dla jednej organizacji lub firmy .Zwykle fizycznie zlokalizowana w sieci firmowej . Może być własnością firmy, strony trzeciej lub ich kombinacji, być zarządzanymi i zarządzanymi przez tę firmę .
Chmura hybrydowa : połączenie co najmniej dwóch odrębnych infrastruktur chmury (publicznej, społecznościowej lub prywatnej) . Połączone przez ustandaryzowane lub zastrzeżone - dla przenośności danych i aplikacji
Przetwarzanie w chmurze zasadniczo ułatwia wymianę danych w czasie rzeczywistym, tworząc i promując sferę cyfrowej integracji i współpracy. Firma lub firma, która korzysta z usług przetwarzania w chmurze, będzie lepiej łączyć się z kluczowymi interesariuszami, umożliwiając proaktywne zarządzanie łańcuchem dostaw, zapewniając widoczność w czasie rzeczywistym, osiągając najwyższą wydajność i poprawiając zarządzanie ryzykiem.
VII. Produkcja przyrostowa: tworzenie obiektów 3D poprzez dodawanie materiału warstwa po warstwie
Wytwarzanie przyrostowe jest powszechnie znane jako proces łączenia materiałów w celu utworzenia fizycznego obiektu, w odniesieniu do zestawu danych modelu 3D, zwykle warstwa po warstwie. Technologia ta jest powszechnie stosowana do wytwarzania małych partii niestandardowych produktów, które oferują zalety konstrukcyjne, tj. złożone, ale lekkie konstrukcje. Tymczasem jest to w przeciwieństwie do wytwarzania subtraktywnego, które jest konwencjonalnym procesem, w którym fizyczny obiekt 3D jest tworzony poprzez sukcesywne usuwanie materiału z litego bloku materiału. Wytwarzanie subtraktywne jest zwykle wykonywane przez ręczne cięcie materiału lub mechanicznie za pomocą komputerowej maszyny sterowanej numerycznie (CNC). Fizyczna część wdrożenia Przemysłu 4.0 jest ograniczona funkcjami i możliwościami obecnych systemów produkcyjnych, co sprawia, że wytwarzanie addytywne jest bardzo ważnym elementem Przemysłu 4.0. Wyzwania polegające na rosnącej indywidualizacji produktów i skróceniu czasu wprowadzania na rynek są poważnie napotykane przez wiele firm, aby zaspokoić potrzeby klientów. Wymagane jest ponowne opracowanie nietradycyjnych metod produkcji, aby osiągnąć możliwość masowej personalizacji w Przemyśle 4.0. Wytwarzanie przyrostowe stało się kluczową technologią tworzenia produktów dostosowanych do indywidualnych potrzeb ze względu na możliwość wytwarzania elementów o zaawansowanych właściwościach pod względem kształtu, materiału itp. Produkcja stała się szybsza i bardziej opłacalna dzięki wdrożeniu technologii wytwarzania przyrostowego, takich jak selektywne topienie laserowe (SLM), metoda stapiania (FDM), selektywne spiekanie laserowe (SLS) itp. Ponieważ jakość produktów wytwarzanych przy użyciu technologii wytwarzania przyrostowego znacznie się poprawiła w ostatnich latach, są one obecnie stosowane w różnych gałęziach przemysłu, m.in. produkcja, budownictwo, biomedycyna, lotnictwo i wiele innych. Pomimo pojawiających się wątpliwości co do możliwości jej zastosowania w produkcji masowej, wdrażanie wytwarzania addytywnego w różnych branżach szybko rośnie ze względu na postęp technologiczny. Jako zaawansowana technologia wytwarzania dokładnych i złożonych produktów, wytwarzanie przyrostowe jest na dobrej drodze, by zastąpić konwencjonalne techniki produkcyjne
VIII. Rozszerzona Rzeczywistość: Interaktywne wykonywanie zadań w środowisku rzeczywistym za pomocą wirtualnych obiektów
Rzeczywistość rozszerzona odnosi się do technologii cyfrowej, w której użytkownicy mają interaktywne doświadczenie w środowisku świata rzeczywistego z wirtualnymi obiektami wzbogaconymi o informacje percepcyjne generowane komputerowo. Narzędzia do rzeczywistości rozszerzonej są w większości w powijakach, ale już zaczęły tworzyć nowe fale usług. Wcześniej rozszerzona rzeczywistość znalazła zastosowanie tylko w niektórych ważnych lub niebezpiecznych zadaniach, takich jak symulatory lotu. Ostatnio przeniknął do obszarów napraw i konserwacji. Zdalne instrukcje naprawy mogą być dostarczone do dowolnej części świata, o ile istnieje połączenie z Internetem. Dzięki tej technologii technicy mogą zdobywać swoje umiejętności, powtarzając czynności konserwacyjne, aż będą wystarczająco kompetentni. Rzeczywistość rozszerzona została wprowadzona do wielu zastosowań w branży. Jest on obecnie wykorzystywany we współpracy człowieka z robotem (HRC), która jest dziedziną, w której próbuje się zrozumieć, w jaki sposób usprawnić współpracę między człowiekiem a robotem za pomocą innowacyjnych interfejsów. W rzeczywistości stworzenie godnego zaufania i bezpiecznego systemu człowiek-robot jest niewątpliwie bardzo trudnym zadaniem. Rzeczywistość rozszerzona służy do pokazywania informacji kontekstualizowanych w rzeczywistym środowisku, pomagając operatorom w uzyskaniu lepszej świadomości ruchów i sił wywieranych przez robota. Poza tym rozszerzona rzeczywistość jest wykorzystywana do prac konserwacyjnych, naprawczych i montażowych. Wykorzystanie rzeczywistości rozszerzonej do tych zadań może pomóc w obniżeniu ogólnych kosztów. Jednak implementacja rzeczywistości rozszerzonej do tych zadań może być skomplikowana, np. technicy mogą potrzebować odwołać się do instrukcji obsługi, aby zakończyć procedurę. Ciągłe przełączanie uwagi między systemem a instrukcją może nałożyć na techników dodatkowe obciążenie poznawcze. Aplikacje rzeczywistości rozszerzonej do konserwacji i naprawy składają się z zestawu wirtualnych zasobów, które zapewniają pomoc, wskazówki lub sugestie dla techników. Te wirtualne zasoby obejmują animowany model 3D opisujący zadanie do wykonania, ścieżkę dźwiękową z instrukcjami, etykietę tekstową wyjaśniającą kroki itp. Dzięki nałożeniu zasobów graficznych i wyrównaniu z maszyną, która ma być naprawiona lub konserwowana, technologia ta pozwala technikom na właściwe prowadzenie do wykonywać pewne zadania, które mogą mieć niebezpieczny charakter. Mimo swojej użyteczności stoi przed wyzwaniem wdrożeniowym, tzn. tworzenie, zmiana i ulepszanie procedur rozszerzonej rzeczywistości może zająć dużo czasu. Kolejnym wielkim wyzwaniem, z jakim się zmagamy, jest brak przejrzystego i dostępnego przepływu pracy do projektowania i tworzenia aplikacji rzeczywistości rozszerzonej dla branży. Systemy z implementacją z rozszerzoną rzeczywistością obsługują również wiele innych usług, m.in. wybór części w magazynie i wysyłanie instrukcji naprawy za pomocą urządzeń mobilnych. Rzeczywistość rozszerzona może być wykorzystywana do dostarczania pracownikom informacji w czasie rzeczywistym, aby pomóc w podejmowaniu decyzji i procedurach pracy. Podczas gdy pracownicy sprawdzają rzeczywisty system wzywający do naprawy, mogą otrzymać instrukcje naprawy dotyczące sposobu wykonywania pracy. Rzeczywistość rozszerzona jest również wykorzystywana do kontroli jakości produktów. Ponieważ różnorodność produktów w przemyśle szybko rośnie, zadanie kontroli staje się coraz bardziej złożone. Proces sprawdzania może stać się mniej skuteczny ze względu na ograniczenia poznawcze pracowników. Wdrożenie rzeczywistości rozszerzonej może pomóc w usprawnieniu procesu kontroli, ponieważ umożliwia bezpośrednie porównanie między produktem rzeczywistym a idealnym. Nosząc dedykowane urządzenie AR, pracownik może skutecznie skontrolować wytworzony produkt, wizualizując nałożoną na niego reprezentację 3D idealnego produktu. Rzeczywistość rozszerzona jest rzeczywiście bardzo potężnym komponentem Przemysłu 4.0. Stworzyła halę produkcyjną, w której nie tylko wszystko jest połączone, ale także widoczne i interaktywne. Skuteczność rzeczywistości rozszerzonej zależy od samego procesu wizualizacji, ale od sposobu wizualizacji danych. Jego zdolność do ulepszania rzeczywistej przestrzeni została szeroko udowodniona w wielu zastosowaniach. Może zasadniczo pomóc fabryce znacznie poprawić wydajność produkcji. Ponadto rozszerzona rzeczywistość zwiększa również niezawodność i bezpieczeństwo systemów robotycznych. Powoduje to również redukcję kosztów i poprawę wydajności systemów utrzymania ruchu. Rzeczywistość rozszerzona to zdecydowanie jedna z kluczowych technologii Przemysłu 4.0, która wzbogaca role menedżerów i pracowników.
IX. Big Data i analiza danych: analizowanie i wydobywanie przydatnych informacji z dużych zbiorów danych
Analityka big data jest powszechnie określana jako powszechny proces badania ogromnych i zróżnicowanych zbiorów danych w celu wydobycia kluczowych informacji (np. ukrytych wzorców, korelacji, nieregularności, trendów i preferencji), zwykle do podejmowania decyzji. Jest to systematyczny sposób odkrywania ważnych informacji lub wskazówek, czego nie można łatwo wykonać przy użyciu tradycyjnych metod przetwarzania danych. Analityka danych, niegdyś bardzo popularna wśród aplikacji informatycznych, obecnie przenika do łańcucha dostaw i przemysłu wytwórczego. Potęga Big Data i analizy danych może pomóc branży produkcyjnej w zmniejszeniu marnotrawstwa i skróceniu przestojów. W niektórych fabrykach dane są gromadzone na różnych poziomach procesów produkcyjnych. Gdy produkt z fabryk zostanie zidentyfikowany jako wadliwy, można uzyskać dostęp do jego danych produkcyjnych, przetworzyć je i przeanalizować w celu uzyskania określonego wzorca. Etap lub etapy procesu produkcyjnego, które powodują powstawanie wzoru, można przeprojektować lub skorygować, aby naprawić wadliwy problem. Konserwacja predykcyjna służy do oszacowania, kiedy należy przeprowadzić rutynową konserwację i może być oparta na zebranych danych produkcyjnych. Jest uważany za bardziej opłacalny i bezpieczniejszy niż tradycyjna praktyka konserwacji. Analityka Big Data jest często uważana za jedną z kluczowych części Przemysłu 4.0. Analityka przemysłowa big data w rzeczywistości przyciągnęła zainteresowanie zarówno naukowców, jak i środowisk akademickich zarówno w zakresie badań, jak i zastosowań. Efektywne wykorzystanie tej technologii zapewni nową falę wzrostu produkcji i ostatecznie przekształci gospodarki. Aby przedsiębiorstwa osiągały efektywność operacyjną w sposób efektywny kosztowo, muszą być spełnione wymagania przemysłowego big data. Przemysłowa analiza big data obejmuje przechowywanie danych w chmurze, system zarządzania danymi operacyjnymi oraz hybrydową platformę usługową. Przemysłowe analizy big data są również wykorzystywane do konserwacji produkcji i innowacji w zakresie usług, koncentrując się na automatycznym przetwarzaniu danych, ocenie stanu zdrowia i prognozowaniu. Zebrane dane są analizowane w celu identyfikacji problemów występujących w różnych procesach produkcyjnych oraz przewidywania nawrotów podczas eksploatacji. Zbieranie i analiza danych z różnych źródeł systemów produkcyjnych stało się normą wspierającą podejmowanie decyzji w czasie rzeczywistym. Wraz z przyspieszonym wdrażaniem Internetu Rzeczy i różnych czujników do gromadzenia danych, ilość i prędkość danych rosną w sposób wykładniczy, zwłaszcza w sektorze produkcji przemysłowej. Sektor produkcyjny musi korzystać z najnowocześniejszych technologii, aby wydobywać i analizować przydatne informacje z dużych zbiorów danych, co prowadzi do rozpowszechnienia analityki dużych zbiorów danych. Oczywiste korzyści lub zwrot z inwestycji, którymi cieszą się producenci, to najwyższa jakość produktu, wyższa wydajność operacyjna, większa elastyczność i zoptymalizowana efektywność kosztowa