Funkcje i interfejsy API – przegląd

Android 15 wprowadza świetne funkcje i interfejsy API dla deweloperów W kolejnych sekcjach znajdziesz podsumowanie tych funkcji, które pomoże Ci zacząć korzystać z powiązanych interfejsów API.

Szczegółową listę dodanych, zmodyfikowanych i usuniętych interfejsów API znajdziesz w raporcie o różnicach w interfejsach API. Więcej informacji o dodanych interfejsach API znajdziesz w dokumentacji interfejsu Android API – w przypadku Androida 15 poszukaj interfejsów API dodanych na poziomie 35. Aby dowiedzieć się, w jakich obszarach zmiany platformy mogą wpłynąć na Twoje aplikacje, zapoznaj się ze zmianami w działaniu Androida 15 w przypadku aplikacji, które są kierowane na Androida 15 oraz wszystkich aplikacji.

Aparat i multimedia

Android 15 zawiera wiele funkcji, które poprawiają jakość zdjęć i multimediów oraz zapewniają dostęp do narzędzi i sprzętu, które pomagają twórcom realizować swoje pomysły na Androidzie.

Więcej informacji o najnowszych funkcjach i rozwiązaniach dla deweloperów w zakresie multimediów i aparatu na Androidzie znajdziesz w prezentacji Building modern Android media and camera experiences (Tworzenie nowoczesnych rozwiązań multimedialnych i fotograficznych na Androidzie) z Google I/O.

Słabe oświetlenie

Android 15 wprowadza wzmocnienie w słabym oświetleniu, czyli tryb automatycznej ekspozycji dostępny zarówno w aplikacji Aparat 2, jak i w rozszerzeniu aparatu w trybie nocnym. Tryb słabego oświetlenia dostosowuje ekspozycję strumienia podglądu w warunkach słabego oświetlenia. Jest to inne podejście niż w przypadku rozszerzenia aparatu w trybie nocnym, które łączy serię zdjęć w jedno ulepszone zdjęcie. Chociaż tryb nocny doskonale sprawdza się w przypadku zdjęć, nie umożliwia ciągłego przesyłania ujęć, czego nie można powiedzieć o trybie Boost w oświetleniu słabym. Dzięki temu tryb Low Light Boost umożliwia korzystanie z takich funkcji aparatu, jak:

  • Udostępnianie ulepszonej podglądu obrazu, aby użytkownicy mogli lepiej kadrować zdjęcia w warunkach słabego oświetlenia
  • Skanowanie kodów QR w warunkach słabego oświetlenia

Jeśli włączysz tryb słabego oświetlenia, włączy się on automatycznie, gdy poziom światła będzie niski, i wyłączy, gdy będzie jaśniej.

Aplikacje mogą nagrywać strumień podglądu w warunkach słabego oświetlenia, aby zapisać film z podwyższoną jasnością.

Więcej informacji znajdziesz w artykule Zwiększanie jasności w słabym oświetleniu.

Sterowanie aparatem w aplikacji

Android 15 dodaje rozszerzenie, które zapewnia większą kontrolę nad sprzętem aparatu i jego algorytmami na obsługiwanych urządzeniach:

  • Zaawansowane ustawienia siły błysku umożliwiające precyzyjne sterowanie natężeniem błysku w trybach SINGLE i TORCH podczas fotografowania.

Kontrola zakresu dynamicznego HDR

Android 15 wybiera zakres HDR odpowiedni dla możliwości urządzenia i głębi bitowej panelu. W przypadku stron zawierających dużo treści SDR, takich jak aplikacja do obsługi wiadomości wyświetlająca pojedynczą miniaturę HDR, takie działanie może negatywnie wpływać na postrzeganą jasność treści SDR. Android 15 umożliwia kontrolowanie marginesu HDR za pomocą setDesiredHdrHeadroom, aby zachować równowagę między treściami SDR a HDR.

Wydaje się, że jasność elementów interfejsu SDR na lewym ekranie jest bardziej jednolita niż jasność na prawym ekranie, co symuluje możliwe problemy z marginesem dynamiki podczas łączenia treści HDR i SDR. Dostosowując margines HDR, możesz uzyskać lepszy balans między treściami SDR a HDR.

Sterowanie głośnością

Android 15 引入了对 CTA-2075 响度标准的支持，可帮助您避免音频响度不一致，并确保用户在切换内容时不必不断调整音量。系统利用输出设备（头戴式耳机和扬声器）的已知特性以及 AAC 音频内容中提供的响度元数据，智能调整音频响度和动态范围压缩级别。

如需启用此功能，您需要确保 AAC 内容中提供响度元数据，并在应用中启用平台功能。为此，您可以通过使用关联的 AudioTrack 中的音频会话 ID 调用其 create 工厂方法来实例化 LoudnessCodecController 对象；这会自动开始应用音频更新。您可以传递 OnLoudnessCodecUpdateListener 来修改或过滤响度参数，然后再将其应用于 MediaCodec。

// Media contains metadata of type MPEG_4 OR MPEG_D
val mediaCodec = …
val audioTrack = AudioTrack.Builder()
                                .setSessionId(sessionId)
                                .build()
...
// Create new loudness controller that applies the parameters to the MediaCodec
try {
   val lcController = LoudnessCodecController.create(mSessionId)
   // Starts applying audio updates for each added MediaCodec
}

AndroidX media3 ExoPlayer 也将更新，以使用 LoudnessCodecController API，可实现无缝应用集成。

Wirtualne urządzenia MIDI 2.0

W Androidzie 13 dodano obsługę łączenia się z urządzeniami MIDI 2.0 przez USB, które komunikują się za pomocą pakietów Universal MIDI (UMP). Android 15 rozszerza obsługę UMP na wirtualne aplikacje MIDI, umożliwiając aplikacjom do komponowania sterowanie syntezatorami jako wirtualnym urządzeniem MIDI 2.0, tak jak w przypadku urządzenia USB MIDI 2.0.

Wydajniejsze dekodowanie oprogramowania AV1

dav1d 徽标

dav1d 是 VideoLAN 推出的热门 AV1 软件解码器，适用于不支持硬件 AV1 解码的 Android 设备。与旧版 AV1 软件解码器相比，dav1d 的性能最高可提升 3 倍，让更多用户（包括一些低端和中端设备）能够播放高清 AV1 视频。

您的应用需要选择启用 dav1d，方法是通过名称 "c2.android.av1-dav1d.decoder" 调用它。在后续更新中，dav1d 将成为默认的 AV1 软件解码器。此支持已标准化，并向后移植到收到 Google Play 系统更新的 Android 11 设备。

Wydajność i narzędzia dla deweloperów

Większość naszych działań mających na celu zwiększenie Twojej produktywności koncentruje się na narzędziach takich jak Android Studio, Jetpack Compose i biblioteki Android Jetpack . Zawsze jednak szukamy sposobów, aby ułatwić Ci realizację Twojej wizji na platformie.

Aktualizacje OpenJDK 17

Android 15 将继续更新 Android 的核心库，以与最新 OpenJDK LTS 版本中的功能保持一致。

其中包含以下主要功能和改进：

这些 API 会通过 Google Play 系统更新在搭载 Android 12（API 级别 31）及更高版本的 10 亿多部设备上更新，以便您以最新的编程功能为目标平台。

Ulepszenia dotyczące plików PDF

Android 15 zawiera znaczne ulepszenia interfejsów API PdfRenderer. Aplikacje mogą zawierać zaawansowane funkcje, takie jak renderowanie plików chronionych hasłem, adnotacje, edytowanie formularzy, wyszukiwanie i wybieranie z kopiowaniem. Obsługiwane są optymalizacje linearyzowanych plików PDF, które przyspieszają wyświetlanie lokalnych plików PDF i zmniejszają wykorzystanie zasobów. Biblioteka PDF Jetpacka używa tych interfejsów API, aby ułatwić dodawanie do aplikacji możliwości wyświetlania plików PDF.

Najnowsze aktualizacje renderowania PDF obejmują funkcje takie jak wyszukiwanie wbudowanego pliku PDF.

Sekcja PdfRenderer została przeniesiona do modułu, który może być aktualizowany za pomocą Google Aktualizacje systemu Google Play niezależne od wersji platformy, a my aby wrócić do Androida 11 (poziom interfejsu API 30) przez utworzenie platformy API dostępnej w wersjach starszych niż Android 15 PdfRendererPreV

Ulepszenia automatycznego przełączania języka

Android 14 dodał na urządzeniu rozpoznawanie wielu języków w dźwięku z automatycznym przełączaniem się między językami, ale może to powodować pomijanie słów, zwłaszcza gdy języki przełączają się z mniejszą przerwą między dwoma wypowiedziami. Android 15 wprowadza dodatkowe opcje, które pomagają aplikacjom dostosować przełączanie do ich przypadku użycia. EXTRA_LANGUAGE_SWITCH_INITIAL_ACTIVE_DURATION_TIME_MILLISogranicza automatyczne przełączanie do początku sesji audio, podczas gdy EXTRA_LANGUAGE_SWITCH_MATCH_SWITCHESdezaktywuje przełączanie języka po określonej liczbie przełączeń. Te opcje są szczególnie przydatne, jeśli spodziewasz się, że w trakcie sesji będzie używany tylko jeden język, który powinien być automatycznie wykrywany.

Ulepszony interfejs OpenType Variable Font API

W Androidzie 15 łatwiejsza obsługa czcionki zmiennej OpenType. Za pomocą interfejsu API buildVariableFamily możesz utworzyć instancję FontFamily z czcionki zmiennej bez określania osi wag. W celu dopasowania wyświetlanego tekstu render tekstu zastępuje wartość osi wght.

Korzystanie z interfejsu API znacznie upraszcza kod potrzebny do utworzenia Typeface:

Kotlin

val newTypeface = Typeface.CustomFallbackBuilder(
            FontFamily.Builder(
                Font.Builder(assets, "RobotoFlex.ttf").build())
                    .buildVariableFamily())
    .build()

Java

Typeface newTypeface = Typeface.CustomFallbackBuilder(
            new FontFamily.Builder(
                new Font.Builder(assets, "RobotoFlex.ttf").build())
                    .buildVariableFamily())
    .build();

Wcześniej, aby utworzyć ten sam Typeface, potrzeba więcej więcej kodu:

Kotlin

val oldTypeface = Typeface.CustomFallbackBuilder(
            FontFamily.Builder(
                Font.Builder(assets, "RobotoFlex.ttf")
                    .setFontVariationSettings("'wght' 400")
                    .setWeight(400)
                    .build())
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 100")
                        .setWeight(100)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 200")
                        .setWeight(200)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 300")
                        .setWeight(300)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 500")
                        .setWeight(500)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 600")
                        .setWeight(600)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 700")
                        .setWeight(700)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 800")
                        .setWeight(800)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 900")
                        .setWeight(900)
                        .build()
                ).build()
        ).build()

Java

Typeface oldTypeface = new Typeface.CustomFallbackBuilder(
    new FontFamily.Builder(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 400")
            .setWeight(400)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 100")
            .setWeight(100)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 200")
            .setWeight(200)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 300")
            .setWeight(300)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 500")
            .setWeight(500)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 600")
            .setWeight(600)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 700")
            .setWeight(700)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 800")
            .setWeight(800)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 900")
            .setWeight(900)
            .build()
    )
    .build()
).build();

Oto przykład renderowania Typeface utworzonego za pomocą starego i nowego interfejsu API:

Przykład różnicy renderowania kroju czcionki w przypadku nowych i starych wersji Interfejsy API

W tym przykładzie Typeface utworzony za pomocą starego interfejsu API nie ma możliwości tworzenia dokładnych wartości wagi czcionki dla instancji 350, 450, 550 i 650Font, więc renderowanie wraca do wartości najbliższej. W tym przypadku zamiast 350 wyświetlana jest wartość 300, zamiast 450 – 400 itd. Natomiast interfejs Typeface utworzony przy użyciu nowych interfejsów API dynamicznie tworzy wystąpienie Font dla danej wagi, więc dokładne wagi są renderowane dla 350, 450, 550 i 650.

Szczegółowe ustawienia podziału wiersza

Począwszy od Androida 15 TextView i powiązany z nimi podział wiersza mogą zachować daną część tekstu w tym samym wierszu, aby zwiększyć czytelność. Możesz skorzystać z tej opcji dostosowywania znaku końca wiersza, używając tagu <nobreak> w zasobach napisów lub w pliku createNoBreakSpan. Podobnie możesz zachować słowa przed dzieleniem na sylaby, używając tagu <nohyphen> lub createNoHyphenationSpan.

Na przykład ten zasób z ciągiem znaków nie zawiera podziału wiersza i renderuje się z tekstem „Pixel 8 Pro” w nieodpowiednim miejscu:

<resources>
    <string name="pixel8pro">The power and brains behind Pixel 8 Pro.</string>
</resources>

Ten zasób ciągu znaków zawiera natomiast tag <nobreak>, który otacza wyrażenie „Pixel 8 Pro” i zapobiega podziałom wiersza:

<resources>
    <string name="pixel8pro">The power and brains behind <nobreak>Pixel 8 Pro.</nobreak></string>
</resources>

Różnica w sposobie renderowania tych ciągów znaków jest widoczna na tych obrazach:

Układ wiersza tekstu, w którym wyrażenie „Pixel 8 Pro” nie jest zawijane za pomocą tagu <nobreak>.
Układ tego samego wiersza tekstu, w którym wyrażenie „Pixel 8 Pro” jest zawinięte za pomocą tagu <nobreak>.

Archiwizacja aplikacji

W zeszłym roku Android i Google Play ogłosiły obsługę archiwizacji aplikacji, aby umożliwić użytkownikom zwolnienie miejsca na urządzeniu przez częściowe usunięcie rzadko używanych aplikacji opublikowanych w Google Play za pomocą pakietu aplikacji na Androida. Android 15 obejmuje archiwizację aplikacji na poziomie systemu operacyjnego i cofania archiwizacji, co ułatwia wdrożenie tej funkcji we wszystkich sklepach z aplikacjami.

Aplikacje z uprawnieniami REQUEST_DELETE_PACKAGES mogą wywoływać Metoda PackageInstaller requestArchive prośby o zarchiwizowanie zainstalowany pakiet aplikacji, który usuwa plik APK i wszelkie pliki z pamięci podręcznej, ale pozostaje bez zmian. danych użytkownika. Zarchiwizowane aplikacje są zwracane jako aplikacje, które można wyświetlić w interfejsy API LauncherApps; użytkownicy zobaczą w interfejsie podkreślenie, aplikacje są zarchiwizowane. Jeśli użytkownik kliknie zarchiwizowaną aplikację, odpowiedzialny instalator otrzyma prośbę o przywrócenie go z archiwum. Proces przywracania jest monitorowana przez transmisję ACTION_PACKAGE_ADDED.

Włączanie trybu 16 KB na urządzeniu za pomocą opcji programisty

Włącz opcję programisty Uruchom ze stroną 16 KB, aby uruchomić urządzenie w trybie 16 KB.

W wersjach QPR Androida 15 możesz skorzystać z opcji dla programistów dostępnej na niektórych urządzeniach, aby uruchomić urządzenie w trybie 16 KB i przeprowadzić testowanie na urządzeniu. Zanim skorzystasz z opcji programisty, otwórz Ustawienia > System > Aktualizacje oprogramowania i zastosuj wszystkie dostępne aktualizacje.

Ta opcja dla programistów jest dostępna na tych urządzeniach:

  • Pixel 8 i 8 Pro (z Androidem 15 QPR1 lub nowszym)

  • Pixel 8a (z Androidem 15 QPR1 lub nowszym)

  • Pixel 9, 9 Pro i 9 Pro XL (z Androidem 15 QPR2 lub nowszym)

  • Pixel 9a (z Androidem 16 lub nowszym)

Grafika

Android 15 wprowadza najnowsze ulepszenia graficzne, w tym ANGLE i dodatki do systemu graficznego Canvas.

Modernizacja dostępu do GPU na Androidzie

Logo Vulkan

Sprzęt Androida zmienił się od czasów, gdy główne jądro systemu operacyjnego działało na jednym procesorze CPU, a do kart graficznych uzyskiwano dostęp za pomocą interfejsów API opartych na stałych ścieżkach funkcji. Interfejs Vulkan® API do obsługi grafiki jest dostępny w NDK od wersji Androida 7.0 (poziom interfejsu API 24) i zawiera abstrakcję na niższym poziomie, która lepiej odzwierciedla nowoczesne GPU, lepiej skaluje się do obsługi wielu rdzeni procesora i zapewnia mniejsze obciążenie procesora przez sterownik, co przekłada się na większą wydajność aplikacji. Vulkan jest obsługiwany przez wszystkie nowoczesne silniki gier.

Vulkan jest preferowanym interfejsem Androida do obsługi GPU. Dlatego Android 15 zawiera ANGLE jako opcjonalną warstwę do uruchamiania OpenGL® ES na platformie Vulkan. Przejście na ANGLE pozwoli ustandaryzować implementację OpenGL na Androidzie, co zwiększy zgodność i w niektórych przypadkach wydajność. Stabilność i wydajność aplikacji OpenGL ES możesz sprawdzić za pomocą ANGLE, włączając opcję dla programistów w Ustawienia -> System -> Opcje programisty -> Eksperymentalnie: włącz ANGLE w Androidzie 15.

Plan rozwoju ANGLE na Androida na platformie Vulkan

Plan wprowadzania nadchodzących zmian w interfejsach API procesora graficznego na Androida.

W ramach uproszczenia naszego pakietu GPU będziemy w przyszłości dostarczać ANGLE jako systemowy sterownik GL na kolejnych nowych urządzeniach. W przyszłości OpenGL/ES będzie dostępny tylko za pomocą ANGLE. Planujemy jednak nadal obsługiwać OpenGL ES na wszystkich urządzeniach.

Zalecane kolejne kroki

W opcjach deweloperskich wybierz sterownik ANGLE dla OpenGL ES i przetestuj aplikację. W przypadku nowych projektów zdecydowanie zalecamy używanie Vulkana w przypadku języków C/C++.

Ulepszenia Canvas

Android 15 继续对 Android 的 Canvas 图形系统进行现代化改造，并新增了以下功能：

  • Matrix44 提供一个 4x4 矩阵来转换坐标，当您想在 3D 中操控画布时，应使用此矩阵。
  • clipShader 会将当前剪裁区域与指定的着色器相交，而 clipOutShader 会将剪裁区域设为当前剪裁区域与着色器的差值，每个操作都会将着色器视为一个 Alpha 遮罩。这支持高效地绘制复杂形状。

Wydajność i bateria

Android nadal koncentruje się na pomaganiu Ci w zwiększaniu wydajności i jakości Twoich aplikacji. Android 15 wprowadza interfejsy API, które pomagają wydajniej wykonywać zadania w aplikacji, optymalizować wydajność aplikacji i zbierać statystyki o aplikacjach.

Więcej informacji o sprawdzonych metodach oszczędzania baterii, debugowaniu zużycia sieci i energii oraz o tym, jak zwiększamy wydajność baterii w przypadku pracy w tle w Androidzie 15 i nowszych wersjach Androida, znajdziesz w prezentacji Improving battery efficiency of background work on Android (Zwiększanie wydajności baterii w przypadku pracy w tle na Androidzie) z Google I/O.

ApplicationStartInfo API

W poprzednich wersjach Androida uruchamianie aplikacji było trochę tajemnicze. Trudno było określić, czy aplikacja została uruchomiona „na zimno”, „na ciepło” czy z pamięci. Trudno też było ustalić, ile czasu aplikacja spędziła w różnych fazach uruchamiania: dzielenia procesu, wywoływania funkcji onCreate, rysowania pierwszego kadru itp. Gdy instancja klasy Application została utworzona, nie było sposobu na ustalenie, czy aplikacja została uruchomiona przez transmisję, dostawcę treści, zadanie, kopię zapasową, uruchomienie, alarm czy Activity.

Interfejs API ApplicationStartInfo w Androidzie 15 zapewnia wszystkie te funkcje i wiele więcej. Możesz nawet dodać do przepływu własne sygnały czasu, aby zbierać dane o czasie w jednym miejscu. Oprócz zbierania danych możesz używać ApplicationStartInfo do bezpośredniej optymalizacji uruchamiania aplikacji. Możesz na przykład wyeliminować kosztowne instancjonowanie bibliotek związanych z interfejsem użytkownika w klasie Application, gdy aplikacja uruchamia się z powodu transmisji.

Szczegółowe informacje o rozmiarze aplikacji

Od Androida 8.0 (poziom interfejsu API 26) Android zawiera interfejs API StorageStats.getAppBytes, który podsumowuje rozmiar zainstalowanej aplikacji jako pojedynczą liczbę bajtów będącą sumą rozmiaru pliku APK, rozmiaru plików wyodrębnionych z pliku APK oraz plików wygenerowanych na urządzeniu, takich jak kod skompilowany z wyprzedzeniem (AOT). Ta liczba nie dostarcza zbyt wielu informacji o tym, jak aplikacja wykorzystuje miejsce na dane.

Android 15 dodaje interfejs API StorageStats.getAppBytesByDataType([type]), który pozwala uzyskać informacje o tym, jak aplikacja wykorzystuje całą dostępną przestrzeń, w tym podziały pliku APK, kod AOT i kod związany z przyspieszeniem, metadane dex, biblioteki i profilowanie kierunkowe.

Profilowanie zarządzane przez aplikację

Android 15 zawiera klasę ProfilingManager, która umożliwia zbieranie informacji o profilowaniu z aplikacji, takich jak zrzuty stosu, profile stosu, próbkowanie stosu itp. Wywołuje ona Twoją aplikację z dołączonym tagiem, aby zidentyfikować plik wyjściowy, który jest dostarczany do katalogu plików aplikacji. Interfejs API stosuje ograniczanie szybkości, aby zminimalizować wpływ na wydajność.

Aby uprościć tworzenie żądań profilowania w aplikacji, zalecamy użycie odpowiedniego interfejsu AndroidX API Profiling, dostępnego w wersji Core 1.15.0-rc01 lub nowszej.

Ulepszenia bazy danych SQLite

Android 15 wprowadza interfejsy API SQLite, które udostępniają zaawansowane funkcje podstawowego mechanizmu SQLite, ukierunkowane na konkretne problemy z wydajnością, które mogą wystąpić w aplikacjach. Te interfejsy API są uwzględnione w aktualizacji SQLite do wersji 3.44.3.

Aby w pełni wykorzystać możliwości bazy danych SQLite, zwłaszcza w przypadku dużych baz danych lub wykonywania zapytań wrażliwych na opóźnienia, deweloperzy powinni zapoznać się z najlepszymi praktykami dotyczącymi wydajności SQLite.

  • Transakcje odroczone tylko do odczytu: w przypadku zawierania transakcji, które są tylko do odczytu (bez instrukcji zapisu), należy użyć funkcji beginTransactionReadOnly() i beginTransactionWithListenerReadOnly(SQLiteTransactionListener). do wystawiania transakcji DEFERRED tylko do odczytu. Takie transakcje mogą być realizowane jednocześnie, a jeśli baza danych jest w trybie WAL, można prowadzić równolegle z IMMEDIATE lub EXCLUSIVE transakcjami.
  • Liczba i identyfikatory wierszy: dodano interfejsy API, które umożliwiają pobieranie liczby zmienionych wierszy lub identyfikatora ostatniego wstawionego wiersza bez wysyłania dodatkowego zapytania. getLastChangedRowCount() zwraca liczbę wierszy, które zostały wstawione, zaktualizowane lub usunięte przez najnowszą instrukcję SQL w ciągu bieżącej transakcji, a getTotalChangedRowCount() zwraca liczbę dla bieżącego połączenia. getLastInsertRowId() zwraca rowid ostatniego wiersza, który ma zostać wstawiony w bieżącym połączeniu.
  • Instrukcje w postaci łańcucha znaków: instrukcje w postaci łańcucha znaków, które są wysyłane do bazy danych SQLite, omijając wrappery i dodatkowe obciążenia przetwarzania, które mogą one generować.

Aktualizacje Android Dynamic Performance Framework

Android 15 继续投资于 Android 动态性能框架 (ADPF)，这是一组 API，可让游戏和性能密集型应用更为直接地与 Android 设备的电源和散热系统进行互动。在受支持的设备上，Android 15 添加了 ADPF 功能：

  • 针对提示会话的节能模式，用于指明其关联的线程应优先节能而非性能，非常适合长时间运行的后台工作负载。
  • 系统可以在提示会话中报告 GPU 和 CPU 工作时长，以便同时调整 CPU 和 GPU 频率，以最佳方式满足工作负载需求。
  • 热余量阈值，用于根据余量预测来解读可能的热节流状态。

如需详细了解如何在应用和游戏中使用 ADPF，请参阅相关文档。

Prywatność

Android 15 zawiera wiele funkcji, które pomagają deweloperom aplikacji chronić prywatność użytkowników.

Wykrywanie nagrywania ekranu

Android 15 obsługuje aplikacje, aby wykrywać w trakcie nagrywania. Funkcja wywołania zwrotnego jest wywoływana, gdy aplikacja przechodzi z widocznego stanu do niewidocznego w nagraniu ekranu. Aplikacja jest są uznawane za widoczne, jeśli działania należące do identyfikatora UID procesu rejestracji są nie są zapisywane. Dzięki temu, jeśli aplikacja wykonuje działanie związane z poufnymi danymi, możesz poinformować użytkownika, że jest nagrywany.

val mCallback = Consumer<Int> { state ->
  if (state == SCREEN_RECORDING_STATE_VISIBLE) {
    // We're being recorded
  } else {
    // We're not being recorded
  }
}

override fun onStart() {
   super.onStart()
   val initialState =
      windowManager.addScreenRecordingCallback(mainExecutor, mCallback)
   mCallback.accept(initialState)
}

override fun onStop() {
    super.onStop()
    windowManager.removeScreenRecordingCallback(mCallback)
}

Rozszerzone możliwości IntentFilter

Android 15 通过 UriRelativeFilterGroup 支持更精确的 Intent 解析，UriRelativeFilterGroup 包含一组 UriRelativeFilter 对象，这些对象构成一组必须满足的 Intent 匹配规则，包括网址查询参数、网址片段以及屏蔽或排除规则。

您可以在 AndroidManifest XML 文件中使用 <uri-relative-filter-group> 标记来定义这些规则，该标记可以包含 android:allow 标记。这些代码可以包含使用现有数据代码属性以及 android:query 和 android:fragment 属性的 <data> 代码。

下面是一个 AndroidManifest 语法示例：

<intent-filter android:autoVerify="true">
  <action android:name="android.intent.action.VIEW" />
  <category android:name="android.intent.category.BROWSABLE" />
  <category android:name="android.intent.category.DEFAULT" />
  <data android:scheme="http" />
  <data android:scheme="https" />
  <data android:host="astore.com" />
  <uri-relative-filter-group>
    <data android:pathPrefix="/auth" />
    <data android:query="region=na" />
  </uri-relative-filter-group>
  <uri-relative-filter-group android:allow="false">
    <data android:pathPrefix="/auth" />
    <data android:query="mobileoptout=true" />
  </uri-relative-filter-group>
  <uri-relative-filter-group android:allow="false">
    <data android:pathPrefix="/auth" />
    <data android:fragmentPrefix="faq" />
  </uri-relative-filter-group>
</intent-filter>

Przestrzeń prywatna

可通过解锁和锁定私密空间，在设备上显示或隐藏敏感应用。

借助私密空间，用户可以在设备上创建一个单独的空间，在额外的身份验证层保护下，防止敏感应用遭到窥探。私密空间使用单独的用户个人资料。用户可以选择使用设备锁定方式或为私密空间使用单独的锁定方式。

私密空间中的应用会显示在启动器的单独容器中，并且当私密空间处于锁定状态时，这些应用不会显示在“最近用过”视图、通知、“设置”和其他应用中。用户生成的内容和下载的内容（例如媒体内容或文件）以及账号在私密空间和主空间之间是分开的。在私密空间处于解锁状态时，您可以使用系统 Sharesheet 和照片选择器向应用授予对各个空间中内容的访问权限。

用户无法将现有应用及其数据移至私密空间。相反，用户可以在私密空间中选择安装选项，以便使用他们偏好的任意应用商店安装应用。私密空间中的应用会作为主空间中任何应用的单独副本进行安装（同一应用的新副本）。

当用户锁定私密空间时，系统会停止该个人资料。在个人资料停止运行时，私密空间中的应用将不再处于活动状态，无法执行前台或后台活动，包括显示通知。

我们建议您使用私密空间测试应用，以确保应用能按预期运行，尤其是当您的应用属于以下某一类别时：

Wysyłanie zapytań o najnowszy wybór użytkownika w przypadku dostępu do wybranych zdjęć

Aplikacje mogą teraz wyróżniać tylko ostatnio wybrane zdjęcia i filmy, gdy użytkownik przyzna uprawnienia do multimediów w ramach dostępu częściowego. Ta funkcja może poprawić wyniki aplikacji, które często proszą o dostęp do zdjęć, filmy. Aby korzystać z tej funkcji w aplikacji, włącz argument QUERY_ARG_LATEST_SELECTION_ONLY podczas wysyłania zapytania MediaStore za pomocą interfejsu ContentResolver.

Kotlin

val externalContentUri = MediaStore.Files.getContentUri("external")

val mediaColumns = arrayOf(
   FileColumns._ID,
   FileColumns.DISPLAY_NAME,
   FileColumns.MIME_TYPE,
)

val queryArgs = bundleOf(
   // Return only items from the last selection (selected photos access)
   QUERY_ARG_LATEST_SELECTION_ONLY to true,
   // Sort returned items chronologically based on when they were added to the device's storage
   QUERY_ARG_SQL_SORT_ORDER to "${FileColumns.DATE_ADDED} DESC",
   QUERY_ARG_SQL_SELECTION to "${FileColumns.MEDIA_TYPE} = ? OR ${FileColumns.MEDIA_TYPE} = ?",
   QUERY_ARG_SQL_SELECTION_ARGS to arrayOf(
       FileColumns.MEDIA_TYPE_IMAGE.toString(),
       FileColumns.MEDIA_TYPE_VIDEO.toString()
   )
)

Java

Uri externalContentUri = MediaStore.Files.getContentUri("external");

String[] mediaColumns = {
    FileColumns._ID,
    FileColumns.DISPLAY_NAME,
    FileColumns.MIME_TYPE
};

Bundle queryArgs = new Bundle();
queryArgs.putBoolean(MediaStore.QUERY_ARG_LATEST_SELECTION_ONLY, true);
queryArgs.putString(MediaStore.QUERY_ARG_SQL_SORT_ORDER, FileColumns.DATE_ADDED + " DESC");
queryArgs.putString(MediaStore.QUERY_ARG_SQL_SELECTION, FileColumns.MEDIA_TYPE + " = ? OR " + FileColumns.MEDIA_TYPE + " = ?");
queryArgs.putStringArray(MediaStore.QUERY_ARG_SQL_SELECTION_ARGS, new String[] {
    String.valueOf(FileColumns.MEDIA_TYPE_IMAGE),
    String.valueOf(FileColumns.MEDIA_TYPE_VIDEO)
});

Piaskownica prywatności na Androida

Android 15 zawiera najnowsze rozszerzenia Usług reklamowych Androida, które obejmują najnowszą wersję Piaskownicy prywatności na Androidzie. Ta funkcja jest częścią naszych działań mających na celu opracowanie technologii, które poprawią prywatność użytkowników oraz umożliwią skuteczne, spersonalizowane reklamy w aplikacjach mobilnych. Na stronie Piaskownicy prywatności znajdziesz więcej informacji o Piaskownicy prywatności w wersji dla deweloperów i w programach beta na Androida, które pomogą Ci zacząć.

Health Connect

Android 15 łączy najnowsze rozszerzenia Health Connect by Android – bezpieczne i scentralizowane platforma, która pozwala zarządzać zbieranymi przez aplikacje danymi o zdrowiu i aktywności fizycznej oraz je udostępniać. Ta aktualizacja obsługa dodatkowych typów danych dotyczących fitnessu, odżywianie, temperatura skóry, plany treningów itp.

Śledzenie temperatury skóry umożliwia użytkownikom przechowywanie i udostępnianie dokładniejszych danych o temperaturze z urządzenia do noszenia lub innego urządzenia śledzącego.

Plany treningowe to usystematyzowane plany treningowe, które pomagają użytkownikom osiągnąć cele fitnessowe. Plany treningowe obejmują różne cele dotyczące ukończenia i wyników:

Więcej informacji o najnowszych aktualizacjach Health Connect na Androidzie znajdziesz w prezencie Tworzenie dostosowanych usług z Androidem Health z Google I/O.

Udostępnianie ekranu aplikacji

Android 15 obsługuje udostępnianie ekranu aplikacji, dzięki czemu użytkownicy mogą udostępniać lub nagrywać tylko okno aplikacji, a nie cały ekran urządzenia. Ta funkcja, która została po raz pierwszy włączona w Androidzie 14 QPR2, obejmuje wywołania MediaProjection, które umożliwiają aplikacji dostosowywanie udostępniania ekranu. Pamiętaj, że w przypadku aplikacji kierowanych na Androida 14 (poziom API 34) lub nowszego wymagana jest zgoda użytkownika na każdą sesję rejestrowania MediaProjection.

Interfejs użytkownika i interfejs systemu

Android 15 daje deweloperom aplikacji i użytkownikom większą kontrolę i elastyczność w konfigurowaniu urządzenia pod kątem swoich potrzeb.

Więcej informacji o tym, jak wykorzystać najnowsze ulepszenia w Androidzie 15, aby poprawić wygodę użytkowania aplikacji, znajdziesz w prezentacji Improve the user experience of your Android app z Google I/O.

Bogatsze podglądy widżetów dzięki Generated Previews API

Przed Androidem 15 jedynym sposobem wyświetlania podglądów selektora widżetów było określenie statycznych zasobów obrazów lub układu. Te podglądy często znacznie różnią się od wyglądu widżetu na ekranie głównym. Ponadto za pomocą Jetpack Glance nie można tworzyć zasobów statycznych, więc deweloper Glance musiał zrobić zrzut ekranu z widżetem lub utworzyć układ XML, aby wyświetlić jego podgląd.

Android 15 obsługuje wygenerowane podglądy. Oznacza to, że dostawcy widżetów aplikacji mogą generować RemoteViews, aby używać go jako podglądu selektora zamiast zasobu statycznego.

Aplikacje mogą udostępniać widoki zdalne do selektora widżetów, co pozwala aktualizować zawartość selektora w taki sposób, aby lepiej reprezentował to, co zobaczy użytkownik.

Interfejs API usługi Push

Aplikacje mogą udostępniać wygenerowane podglądy za pomocą interfejsu API push. Aplikacje mogą udostępniać podglądy w dowolnym momencie ich cyklu życia i nie muszą otrzymać wyraźnej prośby od gospodarza. Podglądy są przechowywane w AppWidgetService, a gospodarze mogą je żądać na żądanie. W tym przykładzie wczytujemy zasób układu widżetu XML i ustawiamy go jako podgląd:

AppWidgetManager.getInstance(appContext).setWidgetPreview(
   ComponentName(
       appContext,
       SociaLiteAppWidgetReceiver::class.java
   ),
   AppWidgetProviderInfo.WIDGET_CATEGORY_HOME_SCREEN,
   RemoteViews("com.example", R.layout.widget_preview)
)

Oczekiwany przebieg:

  1. W dowolnym momencie dostawca widżetu może wywołać funkcję setWidgetPreview. Udostępnione podglądy są przechowywane w AppWidgetService wraz z innymi informacjami o dostawcy.
  2. setWidgetPreview informuje hostów o zaktualizowanym podglądzie za pomocą wywołania zwrotnego AppWidgetHost.onProvidersChanged. W odpowiedzi host widżetu ponownie wczytuje wszystkie informacje dostawcy.
  3. Podczas wyświetlania podglądu widżetu host sprawdza, czy AppWidgetProviderInfo.generatedPreviewCategories jest dostępna, a jeśli tak, wywołuje funkcję AppWidgetManager.getWidgetPreview, aby zwrócić zapisany podgląd dla tego dostawcy.

Kiedy zadzwonić do: setWidgetPreview

Ponieważ nie ma wywołania zwrotnego, które umożliwia wyświetlanie podglądów, aplikacje mogą wysyłać podglądy w dowolnym momencie, gdy są uruchomione. Częstotliwość aktualizacji podglądu zależy od przypadku użycia widżetu.

Na liście poniżej znajdziesz 2 główne kategorie przypadków użycia podglądu:

  • Dostawcy, którzy wyświetlają prawdziwe dane w podglądzie widżetów, np. informacje spersonalizowane lub najnowsze informacje. Ci dostawcy mogą ustawić podgląd po zalogowaniu się użytkownika lub po wykonaniu wstępnej konfiguracji w aplikacji. Następnie mogą skonfigurować zadanie okresowe, aby aktualizować podgląd w wybranym interwale. Przykładami tego typu widżetów są widżety ze zdjęciami, kalendarza, pogody lub wiadomościami.
  • Dostawcy, którzy wyświetlają w podglądach informacje statyczne lub widżety szybkich działań, które nie wyświetlają żadnych danych. Ci dostawcy mogą ustawić podgląd tylko raz przy pierwszym uruchomieniu aplikacji. Przykładami tego typu widżetów są widżet Szybkie działania na Dysku lub widżet skrótów w Chrome.

Niektórzy dostawcy mogą wyświetlać podgląd statyczny w selektorze trybu centrali, ale w selektorze na ekranie głównym mogą wyświetlać prawdziwe informacje. Podczas ustawiania podglądów dostawcy ci powinni postępować zgodnie ze wskazówkami dotyczącymi obu tych przypadków użycia.

Obraz w obrazie

Android 15 引入了画中画 (PiP) 方面的变更，确保实现 更流畅的过渡效果。对于在主界面上叠加界面元素的应用，这将非常有用，因为这些界面元素会进入 PiP。

开发者使用 onPictureInPictureModeChanged 回调来定义逻辑 用于切换叠加界面元素的可见性。此回调是 在画中画进入或退出动画播放完毕时触发。距离开始还有 Android 15 中，PictureInPictureUiState 类包含另一种状态。

在此界面状态下，以 Android 15（API 级别 35）为目标平台的应用将遵守 使用以下参数调用 Activity#onPictureInPictureUiStateChanged 回调： isTransitioningToPip()。还有 在画中画模式下，有很多与应用无关的界面元素， 包含建议、 评分和标题当应用进入画中画模式时，请使用 onPictureInPictureUiStateChanged 回调以隐藏这些界面元素。当 应用从画中画窗口进入全屏模式，使用 onPictureInPictureModeChanged 回调以取消隐藏这些元素，如 请参阅以下示例：

override fun onPictureInPictureUiStateChanged(pipState: PictureInPictureUiState) {
        if (pipState.isTransitioningToPip()) {
          // Hide UI elements
        }
    }

override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
        if (isInPictureInPictureMode) {
          // Unhide UI elements
        }
    }

不相关界面元素的快速可见性切换（适用于画中画窗口）有助于 确保画中画播放动画更流畅、无闪烁。

Ulepszone reguły trybu Nie przeszkadzać

AutomaticZenRule umożliwia aplikacjom dostosowywanie uwagi Reguły zarządzania (Nie przeszkadzać) i określanie, kiedy mają być aktywowane lub dezaktywowane . Android 15 znacznie ulepsza te reguły, aby poprawić komfort użytkowników. Wprowadzono te ulepszenia:

  • Dodaję typy do AutomaticZenRule, aby umożliwić systemowi zastosowanie specjalnych traktowanie pewnych zasad.
  • Dodaję ikonę do interfejsu AutomaticZenRule, aby pomóc w ulepszaniu trybów i rozpoznawalna.
  • Dodawanie do AutomaticZenRule ciągu triggerDescription, który opisuje warunki, po spełnieniu których reguła powinna zostać aktywowana dla użytkownika.
  • Dodane ZenDeviceEffects do AutomaticZenRule, co umożliwia regułom wywoływanie takich funkcji jak skali szarości wyświetlacza, tryb nocny lub przyciemnienie tapety.

Ustawianie VibrationEffect dla kanałów powiadomień

Android 15 支持为传入的通知设置丰富的振动，方法是 频道使用的是NotificationChannel.setVibrationEffect，因此 您的用户可以区分不同类型的通知 不需要看他们的设备

Element paska stanu rejestrowania multimediów i automatyczne zatrzymywanie

媒体投放可能会泄露用户的私密信息。一个醒目的新状态栏条状标签可让用户了解任何正在进行的屏幕投影。用户可以点按该条状标签停止投屏、共享或录制屏幕。此外，为了提供更直观的用户体验，当设备屏幕锁定后，所有正在进行的屏幕投影都会自动停止。

Przycisk na pasku stanu do udostępniania ekranu, przesyłania treści i nagrywania.

Duże ekrany i formaty

Android 15 zapewnia aplikacjom obsługę formatów Androida, w tym dużych ekranów, urządzeń z klapką i składanych.

Ulepszona wielozadaniowość na dużym ekranie

Android 15 daje użytkownikom więcej możliwości wykonywania wielu zadań jednocześnie na urządzeniach z dużym ekranem. Dla: Na przykład użytkownicy mogą zapisać ulubione kombinacje aplikacji podzielone na podzielony ekran, dostęp do paska aplikacji na ekranie i przypinanie go, aby szybko przełączać się między aplikacjami. Oznacza to, że że zapewnienie adaptacji aplikacji jest teraz ważniejsze niż kiedykolwiek.

W ramach Google I/O odbywają się sesje poświęcone tworzeniu adaptacyjnego Androida Apps i Building UI with the Material 3 biblioteka adaptacyjna może pomóc, a nasza dokumentacja jest pomocna w zaprojektowaniu .

Obsługa ekranu zewnętrznego

Aplikacja może deklarować właściwość, której Android 15 używa do wyświetlania elementów Application lub Activity na małych ekranach okładki obsługiwanych urządzeń z ekranem składanym. Te ekrany są zbyt małe, aby uznać je za kompatybilne cele dla aplikacji na Androida, ale możesz włączyć obsługę tych ekranów, aby udostępnić aplikację w większej liczbie miejsc.

Łączność

Android 15 aktualizuje platformę, aby zapewnić Twojej aplikacji dostęp do najnowszych osiągnięć w dziedzinie komunikacji i technologii bezprzewodowych.

Obsługa satelitarna

Android 15 rozszerza obsługę platformy w zakresie łączności satelitarnej, zawiera kilka elementów UI, by zapewnić spójność połączenia satelitarnego.

Aplikacje mogą używać ServiceState.isUsingNonTerrestrialNetwork() do wykrywania, kiedy urządzenie jest połączone z satelitą, dzięki czemu użytkownicy lepiej rozumieją, dlaczego pełne usługi sieciowe mogą być niedostępne. Android 15 obsługuje też aplikacje SMS i MMS oraz wstępnie zainstalowane aplikacje RCS, które umożliwiają korzystanie z łączności satelitarnej do wysyłania i odbierania wiadomości.

Powiadomienie pojawi się, gdy urządzenie połączy się z satelitą.

Płynniejsze korzystanie z NFC

Android 15 czyni korzystanie z płatności zbliżeniowych wygodniejszym i bardziej niezawodnym, a jednocześnie nadal obsługuje solidny ekosystem aplikacji NFC. Na obsługiwanych urządzeniach aplikacje mogą prosić NfcAdapter o wejście w tryb obserwacji, w którym urządzenie nasłuchuje, ale nie reaguje na czytniki NFC, wysyłając PollingFrame obiekty usługi NFC aplikacji do przetwarzania. Obiekty PollingFrame mogą być używane do uwierzytelniania przed pierwszym nawiązaniem komunikacji z czytnikiem NFC, co w wielu przypadkach umożliwia transakcję jednym kliknięciem.

Aplikacje mogą też zarejestrować filtr na obsługiwanych urządzeniach, aby otrzymywać powiadomienia o aktywności pętli zapytań, co umożliwia płynne działanie z wieloma aplikacjami obsługującymi NFC.

Rola w Portfelu

Android 15 wprowadza rolę Portfela, która umożliwia ściślejszą integrację z ulubioną aplikacją portfela użytkownika. Ta rola zastępuje domyślne ustawienie płatności zbliżeniowych NFC. Użytkownicy mogą zarządzać właścicielem roli Portfel, klikając Ustawienia > Aplikacje > Domyślne aplikacje.

Rola Portfela jest używana podczas kierowania dotykiem NFC do identyfikatorów AID zarejestrowanych w kategorii płatności. Kliknięcia zawsze trafiają do posiadacza roli w Portfelu, chyba że na pierwszym planie działa inna aplikacja zarejestrowana z tym samym identyfikatorem AID.

Ta rola służy też do określenia, gdzie ma się wyświetlać kafelek Szybki dostęp w Portfelu po jego aktywowaniu. Gdy rola jest ustawiona na „Brak”, kafelek Szybki dostęp jest niedostępny, a dotknięcia NFC w ramach kategorii płatności są dostarczane tylko do aplikacji na pierwszym planie.

Bezpieczeństwo

Android 15 pomaga zwiększyć bezpieczeństwo aplikacji, chronić jej dane oraz zapewnia użytkownikom większą przejrzystość i kontrolę nad ich danymi. Więcej informacji o tym, co robimy, aby zwiększyć bezpieczeństwo użytkowników i chronić Twoją aplikację przed nowymi zagrożeniami, znajdziesz w prezentacji Safeguarding user security on Android (Zabezpieczanie użytkowników na Androidzie) z Google I/O.

Integracja Menedżera haseł z autouzupełnianiem

Począwszy od Androida 15 deweloperzy mogą połączyć określone widoki, takie jak pola nazwy użytkownika lub hasła, z żądaniami menedżera danych uwierzytelniających, co ułatwia dostosowanie interfejsu do potrzeb użytkownika podczas procesu logowania. Gdy użytkownik skupi się na jednym z tych widoków, do Menedżera danych logowania zostanie wysłane odpowiednie żądanie. Uzyskane dane są agregowane w ramach dostawców i wyświetlane w interfejsach autouzupełniania, takich jak sugestie w polu tekstowym lub sugestie w menu. Biblioteka Jetpack androidx.credentials to preferowany punkt końcowy dla deweloperów. Wkrótce będzie ona dostępna w celu dalszego ulepszania tej funkcji w Androidzie 15 i nowszych.

Integracja rejestracji i logowania jednym dotknięciem z prośbami o dane biometryczne

Menedżer danych uwierzytelniających integruje prompty biometryczne z procesami tworzenia danych uwierzytelniających i logowania, dzięki czemu dostawcy nie muszą zarządzać promptami biometrycznymi. Dlatego dostawcy danych uwierzytelniających mogą się skupić jedynie na wyników tworzenia i odbierania przepływów, wzbogaconych o wynik przepływu biometrycznego. Ten uproszczony proces umożliwia bardziej wydajne i prostsze tworzenie oraz pobieranie danych logowania.

Zarządzanie kluczami w przypadku pełnego szyfrowania

W Androidzie 15 wprowadzamy interfejs E2eeContactKeysManager, który ułatwia szyfrowanie end-to-end (E2EE) w aplikacjach na Androida dzięki interfejsowi API na poziomie systemu operacyjnego do przechowywania kluczy publicznych kryptograficznych.

E2eeContactKeysManager jest przeznaczony do integracji z aplikacją Kontakty na platformie, aby zapewnić użytkownikom scentralizowany sposób zarządzania i weryfikowania kluczy publicznych kontaktów.

Sprawdzanie uprawnień w przypadku identyfikatorów URI treści

Android 15 wprowadza zestaw interfejsów API, które przeprowadzają sprawdzanie uprawnień w przypadku adresów URI treści:

Ułatwienia dostępu

Android 15 dodaje funkcje, które poprawiają dostępność dla użytkowników.

Lepszy brajl

在 Android 15 中，我们让 TalkBack 能够支持通过 USB 和安全蓝牙使用 HID 标准的盲文显示屏。

此标准与鼠标和键盘使用的标准非常相似，将有助于 Android 随着时间的推移支持更多类型的盲文显示屏。

Internacjonalizacja

Android 15 dodaje funkcje i możliwości, które uzupełniają wygodę użytkowania, gdy urządzenie jest używane w różnych językach.

Czcionka zmienna CJK

Od wersji 15 Androida plik czcionki dla języków chińskiego, japońskiego i koreańskiego (CJK) NotoSansCJK jest teraz czcionką zmienną. Czcionki zmienne otwierają nowe możliwości kreatywnej typografii w językach CJK. Projektanci mogą odkrywać szerszy zakres stylów i tworzyć atrakcyjne wizualnie układy, które wcześniej były trudne lub niemożliwe do osiągnięcia.

Jak zmienna czcionka w przypadku języków chińskiego, japońskiego i koreańskiego (CJK) wygląda w różnych szerokościach.

Wyrównywanie między znakami

Od Androida 15 tekst można wyrównać do lewej, korzystając z odstępów między literami za pomocą znaku JUSTIFICATION_MODE_INTER_CHARACTER. Poprzednie uzasadnienie między słowami: po raz pierwszy wprowadzona w Androidzie 8.0 (poziom interfejsu API 26) daje podobne możliwości w językach korzystających z funkcji znak odstępu na potrzeby segmentacji, np. w języku chińskim, japońskim itp.

Układ tekstu japońskiego za pomocą JUSTIFICATION_MODE_NONE.
Układ tekstu w języku angielskim za pomocą: JUSTIFICATION_MODE_NONE.


Układ tekstu w języku japońskim za pomocą JUSTIFICATION_MODE_INTER_WORD.
Układ tekstu angielskiego z użyciem JUSTIFICATION_MODE_INTER_WORD.


Układ tekstu w języku japońskim za pomocą: JUSTIFICATION_MODE_INTER_CHARACTER.
Układ tekstu w języku angielskim za pomocą: JUSTIFICATION_MODE_INTER_CHARACTER.

Automatyczna konfiguracja podziału wiersza

Android zaczął obsługiwać podziały wierszy oparte na wyrażenia w języku japońskim i koreańskim od Android 13 (poziom API 33). Mimo że podziały wierszy oparte na wyrażeniach poprawiają czytelność krótkich wierszy tekstu, dlatego nie sprawdzają się w przypadku długich wierszy. Na Androidzie 15 aplikacje mogą stosować podziały wierszy oparte na wyrażeniach tylko w przypadku krótkich wierszy tekstu, za pomocą funkcji LINE_BREAK_WORD_STYLE_AUTO . Ta opcja powoduje wybranie najlepszej opcji stylu tekstu dla tekstu.

W przypadku krótkich wierszy tekstu stosuje się znaki końca wiersza oparte na frazie, które działają tak samo jak LINE_BREAK_WORD_STYLE_PHRASE, jak pokazano na poniższym obrazie:

W przypadku krótkich wierszy tekstu LINE_BREAK_WORD_STYLE_AUTO stosuje podziały wierszy oparte na wyrażeniach, aby poprawić czytelność tekstu. Ta metoda działa tak samo jak stosowana LINE_BREAK_WORD_STYLE_PHRASE.

W przypadku dłuższych wierszy tekstu LINE_BREAK_WORD_STYLE_AUTO używa operatora nie stylu słów podziału wiersza, który działa tak samo jak LINE_BREAK_WORD_STYLE_NONE, jak widać w tabeli ten obraz:

W przypadku długich wierszy tekstu LINE_BREAK_WORD_STYLE_AUTO nie stosuje się stylu łamania wiersza, aby poprawić czytelność tekstu. Ta metoda działa tak samo jak stosowana LINE_BREAK_WORD_STYLE_NONE.

Dodatkowa japońska czcionka Hentaigana

W Androidzie 15 domyślnie jest dołączony plik czcionki starej japońskiej Hiragana (zwanej Hentaigana). Dzięki wyjątkowym kształtom postaci hentaigana charakterystyczne dla dzieła sztuki lub wzornictwa, a także pomagają zachować wierność przekazywanie i rozumienie starożytnych japońskich dokumentów.

Styl znaków i tekstu dla japońskiego hentaigany czcionki.

VideoLAN cone Copyright (c) 1996-2010 VideoLAN. To logo lub jego zmodyfikowana wersja może być używane lub modyfikowane przez dowolną osobę w odniesieniu do projektu VideoLAN lub dowolnego produktu opracowanego przez zespół VideoLAN, ale nie oznacza poparcia przez projekt.

Vulkan i logo Vulkan są zastrzeżonymi znakami towarowymi Khronos Group Inc.

OpenGL jest zastrzeżonym znakiem towarowym, a logo OpenGL ES jest znakiem towarowym firmy Hewlett Packard Enterprise używanym za zgodą Khronos.