что такое рендер графического процессора skia
Анализ рендеринга через Skia Debugger: как можно найти самые дорогие для отрисовки элементы
Доброго дня, недавно я решал проблему притормаживания скролла на страницах Почты Mail.Ru. Особенно эта проблема была заметна на retina-дисплеях. После простого анализа я пришел к выводу, что одна из основных проблем — это медленная отрисовка страницы.
В этой статье я расскажу, как можно применять инструмент Skia Debugger, входящий в набор инструментов Chrome, для пошагового анализа процесса отрисовки страницы, а также как с его помощью можно получить данные о том, сколько времени занимает отрисовка каждого элемента.
Как и многие подобные проблемы оптимизации, данную проблему можно решить множеством способов. Я взялся за оптимизацию рендеринга, так как на нее затрачивалось значительное количество времени. Тем самым, я достаточно быстро смог бы получить прирост производительности и, соответственно, улучшить плавность скролла, ускорив отрисовку.
В начале я решил посмотреть, сколько времени занимает отрисовка страницы. Для этого можно использовать настройку devtools “Enable continuos page repainting”. Данная опция заставляет браузер постоянно перерисовывать страницу без каких-либо действий пользователя. В этом режиме также отображается панель со временем отрисовки страницы. Про эту и другие возможности devtools отлично рассказано в этой статье, так что я не буду заострять внимание на ней. Скажу лишь, что после снятия замеров оказалось, что анализируемая страница на ретине рендерится порядка 100 миллисекунд, что и создает притормаживания при скролле страницы. Данные, которые я могу посмотреть при записи timing’а в devtools, были не очень информативны, так как они содержали только время отрисовки страницы целиком, а мне нужно было найти виновника проблем.
Поэтому я стал искать, какой компонент браузера отвечает за отрисовку, и какие логи смогут помочь мне понять, что же тормозит. Начал я с изучения этой статьи и архитектуры Chromium, которая доступна в открытом доступе и концептуально не отличается от архитектуры Chrome.
В этих статьях меня интересовало, какой компонент отвечает за рендеринг и какие логи он предоставляет. Из глав с описанием графических компонентов я узнал, что в основном вся работа лежит на библиотеке Skia. К моей радости, для нее был разработан отладчик Skia Debugger, который, судя по скринам на сайте проекта, был мне необходим. Но, к сожалению, его установка была для меня нетривиальной задачей (нужно было собрать сам отладчик и пересобрать Chrome).
Запустив браузер с этим параметром, переходим по адресу chrome://tracing. Вам должна отобразиться следующая вкладка:
Открываем еще одну вкладку со страницей, которую мы хотим проанализировать. В моем случае это была страница списка писем. Возвращаемся обратно к вкладке chrome://tracing и нажимаем Record, должен открыться попап. В нем нужно выбрать из списка пункт “Frame Viewer” и нажать на Record. После этого начнется запись, и вы можете выполнить какие-либо действия на анализируемой вкладке, рекомендую держать открытой не более одной вкладки, так как буфер записи очень ограничен, и в него влезает сравнительно небольшой кусок данных.
Как только вы выполнили интересующие вас действия, возвращаемся обратно к вкладке tracing и нажимаем Stop. После этого вам построится диаграмма, содержащая информацию о том, что происходило в системе при записи. Все данные сгруппированны по процессам браузера. Меня интересует процесс со списком сообщений, его легко найти по заголовку. В этом процессе смотрим раздел сс::Picture, в котором кружочками отображены итоговые отрисованные браузером изображения.
Найдем среди них одно, которое содержит отрисовку страницы целиком. Теперь в нижней части экрана отобразилось окно с картинкой страницы. В правом верхнем углу отображена диаграмма, в которой показано, сколько суммарного времени занимает каждая функция отрисовки. Слева отображена временная шкала с последовательностью отрисовки элементов страницы и затраченное на каждое из них время.
Пролистав временную шкалу, я нашел, что основной виновник столь долгой отрисовки страницы – контейнер списка сообщений с тенью. Данный элемент занимает порядка 45% всего времени отрисовки страницы.
После того как я заменил box-shadow на обычный border и заново записал страницу, я увидел, что количество времени на отрисовку уменьшилось c 45% до 6.5%, а также, что теперь используется уже другая функция Skia.
Ускорение отрисовки также подтвердилось после просмотра оптимизированной страницы в режиме “Enable continuos page repainting”.
Многим может показаться, что проблема с box-shadow была очевидна, и ее можно было бы найти, просто изменив стили на страницы через devtools. Но мне в этой статье хотелось рассказать о том, как можно применять альтернативные инструменты. Как с их помощью можно понять, в какой последовательности рисуются элементы на странице и сколько конкретно времени это занимает.
Данный инструмент обладает куда большими возможностями, которые я не описал в статье, так как про них прекрасно рассказано в видео, про которое я упоминал ранее.
Понимание процессов протекающих в браузере — очень важные знания, которые необходимы для эффективной оптимизации веб-приложений. Но для оптимизации также необходимы инструменты, которые позволят нам измерить ускорение, которое дала та или иная оптимизация, а также понять причину проблемы.
«Если речь идет о производительности, не может быть никаких «вероятно». Без измерения производительности вы никак не сможете точно узнать, помогли ваши изменения программе или навредили».
Стив Макконел «Совершенный код» 2-е. издание, стр. 579 «Стратегии оптимизации кода»
Определение наиболее тяжелых для отрисовки элементов — это важный шаг по оптимизации веб-приложения. Полученные знания по новым возможностям Chrome помогут не только отлаживать и находить узкие места отрисовки, но также понимать, как любой из компонентов страницы влияет на весь процесс рендеринга потока в целом. О других возможностях данного инструмента я постараюсь рассказать в следующих статьях.
Включите OpenGL Skies для лучшей производительности в Android-играх
Включите OpenGL Skies для лучшей производительности в Android-играх
Включите OpenGL Skia для лучшей производительности в играх и интерфейсе Android
Игры на мобильных платформах (Android и iOS) достигли невероятного роста всего за несколько лет. Если сначала игры были довольно простыми, как, например, 80 PC, эти игры стали чрезвычайно сложными.
Игры на Android или iOS почти такие же, как на вашем ПК или консолях.
Поскольку игры на мобильных устройствах в настоящее время очень сложны, потребление ресурсов также увеличилось. Если у топ-телефонов нет проблем с запуском последних названий, более старые устройства в значительной степени нахмурились от резких изображений, которые приводят к неприятному опыту.
У большинства геймеров нет самых горячих телефонов.
Поскольку не у всех есть лучшие телефоны, Google нашел решение предложить небольшое повышение производительности тем, у кого слабые телефоны. Этот параметр повышает производительность игр при условии, что у нас есть ОС Oreo Android или новее. В старых версиях Android этот параметр недоступен.
Переход от графического движка OpenGL к OpenGL Skia.
Графический движок OpenGL Skia можно активировать с помощью:
Настройки / Параметры разработчика / Воспроизведение с аппаратным ускорением / Установка графического процессора… / выберите OpenGL Skia здесь
Бонус, Настройки кэша и Ускорение скорости интерфейса.
За исключением настройки, которая активирует графический движок OpenGL Skia, есть два важных параметра, которые заставят ваш Android двигаться быстрее.
1. Очистить кеш из: Настройки телефона / Хранение и память / Данные кэширования. Кэшированные данные больше не полезны, поэтому вы можете удалить их без проблем.
Учебники нравится:
Русские Блоги
Механизм рисования экрана Android и аппаратное ускорение
Современные технологические новости
Недавно EVelozcity, запуск электромобиля, основанный бывшим финансовым директором Faraday Future, подал в суд на главного акционера Faraday Future и исполняющего обязанности генерального директора в Высоком суде Лос-Анджелеса, заявив, что соблазнил и попросил сотрудников подписать трудовое соглашение с оговоркой о запрете конкуренции. И обманчивые средства мешают его сотрудникам свободно искать новые рабочие места. В ответ Faraday Future заявила, что в иске говорится, что «FF91 добился прогресса и намеренно преследовал и оскорблял Faraday Future. Faraday Future уверенно выиграл иск».
Эта статья написана на основе старого драйвера Убийца программист Вклад, делимся связанным содержанием о механизме рисования экрана Android и аппаратном ускорении, давайте посмотрим! Надеюсь тебе понравится.
Убийца программист Адрес блога:
Два основных момента разработки приложений для мобильных телефонов:
Обрабатывать пользовательский сенсорный ввод
Интерфейс отображения эффектов (включая анимацию и различные отзывы)
Аппаратное ускорение
Пользовательский интерфейс системы Android разделен на два этапа: от рисования до отображения на экране.
Первый шаг: на стороне приложения Android. (Соберите пользовательский интерфейс в графический буфер и передайте его SurfaceFlinger)
Второй шаг: на стороне процесса SurfaceFlinger. (Получите буфер, синтезируйте и отобразите его на экране.)
Среди них, операция второго шага в SurfaceFlinger всегда завершалась аппаратным ускорением, поэтому мы обычно ссылаемся на аппаратное ускорение, относящееся к процессу рендеринга графики через ускорение графического процессора в прикладной программе для буфера.
Сравнение структуры CPU / GPU
Следующее содержание взято из: Блог Muye 57, адрес блога выглядит следующим образом:
Центральный процессор: центральный процессор, центральный процессор, является основным устройством компьютерного оборудования, используемым для выполнения программного кода.
Графический процессор: графический процессор, графический процессор, в основном используемый для обработки графических операций, основным компонентом так называемой «графической карты» является графический процессор.
Ниже приведена сравнительная диаграмма структуры CPU и GPU. Среди них:
Зеленый АЛУ (Арифметическая Логическая Единица) является арифметической логической единицей, используемой для математических и логических операций;
Как видно из структурной схемы, контроллер ЦПУ более сложный, а количество АЛУ меньше. Следовательно, процессор хорош для всех видов сложных логических операций, но не очень хорош для математики, особенно операций с плавающей запятой.
Более простые ЦП даже имеют только инструкции сложения, вычитание реализовано с добавлением дополнения, умножение реализовано с накоплением, а деление реализовано с помощью цикла вычитания.
Современные ЦП обычно оснащены аппаратными арифметическими модулями с плавающей точкой (FPU), но в основном подходят для ситуаций, когда объем данных невелик.
Процессор представляет собой последовательную структуру. Если взять в качестве примера вычисление 100 чисел, то для одного ядра ЦП одновременно может быть вычислена только сумма двух чисел, и результаты постепенно накапливаются.
В отличие от процессоров, графические процессоры предназначены для выполнения большого количества математических операций. Как видно из структурной схемы, контроллер GPU относительно прост, но содержит много ALU. ALU в GPU использует параллельную конструкцию и имеет больше арифметических единиц с плавающей точкой.
Основной принцип аппаратного ускорения заключается в использовании базового программного кода для преобразования графических вычислений, в которых ЦП недостаточно хорош, в специфические для графического процессора инструкции, которые выполняются графическим процессором.
OpenGL
Разработчики Android могут реализовать аппаратное ускорение рендеринга графики с помощью OpenGL ES.
Сначала поймите два слова: OpenGL, OpenGL ES
OpenGL (Open Graphics Library): Относится к профессиональному графическому программному интерфейсу, который определяет язык кросс-программирования и спецификацию интерфейса кроссплатформенного программирования. Он используется для трехмерных изображений (также доступны двухмерные изображения) и представляет собой мощную и удобную низкоуровневую графическую библиотеку.
OpenGL ES (OpenGL для встраиваемых систем) является подмножеством трехмерного графического API OpenGL и предназначен для встроенных устройств, таких как мобильные телефоны, КПК и игровые приставки.
Здесь мы должны сначала уточнить, что такое аппаратно-ускоренный рендеринг, который на самом деле выполняется через графический процессор.
Как аппаратное обеспечение, графический процессор не может использоваться непосредственно в пространстве пользователя, а используется производителем графического процессора косвенно в соответствии с драйвером, реализованным в спецификации Open GL.
Другими словами, если устройство поддерживает аппаратное ускорение рендеринга с помощью графического процессора, когда приложение Android вызывает интерфейс Open GL для рисования пользовательского интерфейса, пользовательский интерфейс приложения Android отображается с помощью технологии аппаратного ускорения.
Графический компонент Android
Если процесс отображения графических эффектов приложения, написанного разработчиком, рассматривается как яркий процесс рисования, как различные роли Android взаимодействуют и взаимодействуют в процессе рисования:
кисть
Skia: процессор рисует 2D графику;
Open GL: графический процессор рисования 2D / 3D графики;
Бумага для рисования
Surface: приложения Android 4.4+ отрисовываются и отображаются на бумаге Surface.
Доска для рисования
Графический буфер: Как уже упоминалось в механизме обновления экрана, после Android 4.1+ есть 3 графических буфера для рисования графики приложения или синтеза и отображения SurfaceFlinger.
Синтез и отображение
SurfaceFlinger: все слои синтезируются и отображаются. (Поставщик Поверхности)
Давайте разберемся с общей архитектурой графической системы Android
Производители потока изображений: Производители графического потока, графика, отображаемая в Surface в приложениях (графика, реализованная в XML или Java, или видео)
Диспетчер окон: Изучите механизм окна Android по следующему адресу:
SurfaceFlinger: синтезируйте и выводите их на дисплей в соответствии с содержимым, предоставляемым диспетчером окон. Он использует OpenGL и HardWareComposer для синтеза поверхности. (Другими потребителями также могут быть приложения OpenGL ES, такие как камеры или другие.) В начале было упомянуто, что аппаратное ускорение относится к процессу ускорения рендеринга графики в приложении, а SurfaceFlinger всегда использовал OpenGL для синтеза и вывода графики.
HWC: Hardware Composer, аппаратный синтезатор. (Поймите) Это аппаратная абстракция системы контроллера дисплея. SurfaceFlinger делегирует некоторые работы по компоновке в Hardware Composer, чтобы уменьшить нагрузку на GPU. Это потребляет меньше энергии, чем простой синтез с помощью графического процессора.
Gralloc: Распределитель графической памяти используется для выделения графической памяти.
Приложение может рисовать 2D-графику через Skia, а также может рисовать 2D / 3D-графику с помощью OpenGL (ускорение приложения относится к использованию обработки OpenGL и визуализации графики в приложении).
SurfaceFlinger будет использовать OpenGL для смешивания графики с указанной поверхностью и отправки в HWC для синтеза.
Процесс рендеринга CPU / GPU
Ниже мы используем код для анализа различий между рендерингом программного обеспечения и аппаратным ускорением.
Программное обеспечение рендеринга
private void performDraw () <
«««
try <
draw(fullRedrawNeeded);
>
>
mAttachInfo.mHardwareRenderer.draw(mView, mAttachInfo, this ); // Аппаратное ускорение рисования
> else <
// Программное обеспечение рисования
if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) <
return ;
>
>
>
>
// These can be accessed by any thread, must be protected with a lock.
// Surface can never be reassigned or cleared (use Surface.clear()).
final Surface mSurface = new Surface(); // Каждый ViewRootImpl соответствует Surface
// Три конструктора поверхности
/**
* Create an empty surface, which will later be filled in by readFromParcel().
* @hide
*/
public Surface () <
>
public Surface (SurfaceTexture surfaceTexture) <
if (surfaceTexture == null ) <
throw new IllegalArgumentException( «surfaceTexture must not be null» );
>
mIsSingleBuffered = surfaceTexture.isSingleBuffered();
synchronized (mLock) <
mName = surfaceTexture.toString();
setNativeObjectLocked(nativeCreateFromSurfaceTexture(surfaceTexture));
>
>
private Surface ( long nativeObject) <
synchronized (mLock) <
setNativeObjectLocked(nativeObject);
>
>
Поверхность имеет три вида конструкторов, первый из которых используется здесь, то есть создает пустой объект Surface и не инициализирует собственный слой Surface. Фактически процесс создания поверхности процесса приложения завершается службой WMS. Служба возвращает созданную поверхность в процесс приложения через метод перекрестного процесса Binder.
То есть, хотя приложение (в ViewRootImpl) создает пустой объект Surface, оно фактически создает действительно используемую поверхность на стороне WMS и назначает ее этой пустой поверхности. Чтобы узнать больше о процессе создания и назначения Surface, обратитесь к статье: Процесс рисования приложения под AndroidO Graphics Framework-Surface Creation.
/**
* @return true if drawing was successful, false if an error occurred
*/
private boolean drawSoftware (Surface surface, AttachInfo attachInfo, int xoff, int yoff,
boolean scalingRequired, Rect dirty) <
final Canvas canvas;
canvas = mSurface.lockCanvas(dirty); // Получить SkiaCanvas
mView.draw(canvas); // Графический рисунок
> finally <
surface.unlockCanvasAndPost(canvas); // Отправить полученный результат
>
return true ;
>
lockCanvas: (часть, которая должна быть прорисована в заблокированном интерфейсе) Каждое окно связано с Surface. Когда этому окну необходимо нарисовать пользовательский интерфейс, оно вызовет связанный с ним метод lockCanvas () для Surface, чтобы получить Canvas (этот Canvas инкапсулирует, предоставленный Skia Интерфейс для рисования 2D-графики) и графический буфер в SurfaceFlinger Dequeue, нарисованный контент будет выведен в графический буфер, а затем передан SurfaceFlinger для синтеза и отображения графического содержимого на экране.
draw: нарисуйте содержимое View на Canvas.
unlockCanvasAndPost: после завершения рисования вызовите unlockCanvasAndPost, чтобы запросить отображение холста на экране, который, по сути, служит графическим буфером для очереди SurfaceFlinger.
Аппаратное ускорение
Точки оптимизации аппаратного ускорения:
Весь процесс рисования программного рисования (с использованием только ЦП) выполняется в главном потоке.Если вы хотите одновременно реагировать на события пользовательского ввода, это может привести к зависанию.
Способность графического процессора рисовать и визуализировать графику еще лучше. Если вы используете графический процессор и рисуете и визуализируете графику в разных потоках, весь процесс будет более плавным.
Процесс аппаратного ускорения состоит из двух этапов:
Этап построения: перебирайте все представления, кэшируйте операции, которые необходимо отрисовать, и передайте их отдельному потоку рендеринга, чтобы использовать графический процессор для аппаратного ускорения рендеринга. (Этот этап построен с использованием процессора в основном потоке)
Стадия рисования: вызовите OpenGL (т. Е. Используйте графический процессор) для рисования и рендеринга встроенного вида, нарисованный контент сохраняется в графическом буфере и представляется SurfaceFlinger. (Android 5.0+ использует поток Render Thread, который отвечает за визуализацию пользовательского интерфейса и отображение анимации.)
Посмотреть здание
Справка: Маленькая улитка читает, адрес следующий:
Принцип аппаратного ускорения тщательно проанализирован.
Во время аппаратного ускорения Android представление View абстрагируется в узлы RenderNode, операции рисования в View будут абстрагироваться в DrawOp, например drawLine в View, будут абстрагироваться в DrawLineOp во время построения, операция drawBitmap будет абстрагироваться в DrawBitmapOp
Рисование каждого вложенного вида абстрагируется в DrawRenderNodeOp, каждый DrawOp имеет соответствующую команду рисования OpenGL, и в то же время он также содержит данные, необходимые для рисования. Как показано ниже:
Каждый вид не только содержит свой собственный список DrawOp, но также содержит запись чертежа в дополнительном окне, поэтому он может рекурсивно подсчитывать все операции рисования, которые в исходном коде называются Display List. (Другими словами, RenderNode корневого узла может получить доступ ко всем операциям рисования)
После завершения построения чертежный список отображения дерева операций передается потоку рендеринга для рисования, который сильно отличается от программного чертежа. Когда программное обеспечение выполняет рисование, представление обычно завершается в основном потоке, а аппаратное обеспечение ускоряется. Рисование выполняется в отдельном потоке, таким образом разделяя большое давление на основной поток и улучшая скорость отклика потока пользовательского интерфейса.
Преимущества построения команд операции рисования в Списке отображения:
Если пользовательский интерфейс представления не изменился, вы можете использовать связанный API-интерфейс Canvas (без onDraw) и напрямую использовать графический кэш списка отображения, созданный в прошлый раз.
Если пользовательский интерфейс представления изменяется, но изменяются только некоторые простые свойства, такие как прозрачность, перевод, вращение и другие простые свойства, вы также можете изменить свойства, относящиеся к отображаемому списку, последней сборки, не перестраивая отображаемый список.
void draw (View view, AttachInfo attachInfo, HardwareDrawCallbacks callbacks) <
updateRootDisplayList(view, callbacks); // Создаем дерево DrawOp вида
«««
// Уведомляем поток RenderThread для рисования
int syncResult = nSyncAndDrawFrame(mNativeProxy, frameInfo, frameInfo.length);
>
private void updateRootDisplayList (View view, HardwareDrawCallbacks callbacks) <
// Для построения списка отображения представления параметров (DecorView)
updateViewTreeDisplayList(view);
canvas.restoreToCount(saveCount);
> finally <
// Заполняем все DrawOp в корневой RootNode как новый список отображения
mRootNode.end(canvas);
>
>
>
Основная функция ThreadedRenderer заключается в создании представления в основном потоке (ЦП) и уведомлении RenderThread о встроенном представлении, чтобы позволить ему использовать OpenGL для рисования и рендеринга. (Вызовите nSyncAndDrawFrame ())
В методе updateRootDisplayList () начните создавать список отображения, который должен создавать последовательность команд Draw Op. Способ в основном имеет следующие процессы:
Получите DisplayListCanvas через RenderNode корневого представления (mRootNode.start ())
Вызовите view.updateDisplayListIfDirty () для обхода дерева команд Draw OP и построения его на DisplayListCanvas
Заполните кэшированный Draw Op в RenderNode корневого представления, чтобы завершить построение представления. (MRootNode.end (canvas))
Давайте посмотрим на метод updateDisplayListIfDirty () View. Из именования мы можем знать, что если View не меняет макет, он не будет подвергнут рефакторингу.
View() <
mResources = null ;
mRenderNode = RenderNode.create(getClass().getName(), this );
>
/**
* Gets the RenderNode for the view, and updates its DisplayList (if needed and supported)
*/
@NonNull
public RenderNode updateDisplayListIfDirty () <
final RenderNode renderNode = mRenderNode;
final DisplayListCanvas canvas = renderNode.start(width, height);
if ((mPrivateFlags & PFLAG_SKIP_DRAW) == PFLAG_SKIP_DRAW) <
// В настоящее время ViewGroup, и не нужно рисовать себя, рекурсивный дочерний вид
dispatchDraw(canvas);
> else <
// Если это ViewGroup, он вызовет dispatchDraw для рекурсивного вызова отрисовки дочернего View
draw(canvas);
>
>
> finally <
// Заполняем кешированный Draw Draw (т. Е. Display List) в RenderNode
renderNode.end(canvas);
setDisplayListProperties(renderNode); // Устанавливаем свойство renderNode
>
>
return renderNode; // Сборка завершена
>
В трех случаях View необходимо перестроить отображение текущего View, включая вложенный View:
Бит PFLAG_DRAWING_CACHE_VALID значения переменной-члена mPrivateFlags класса View равен 0, что указывает на то, что список отображения, созданный в прошлый раз, был признан недействительным.
Переменная члена списка просмотра mRenderNode описывает внутренний узел отображения данных списка отображения, который не был установлен или был уничтожен.
Значение переменной-члена mRecreateDisplayList класса View равно true, что напрямую указывает на необходимость перестройки списка отображения.
В потоке viewDisplayListIfDirty () процесс построения выглядит следующим образом:
Получите DisplayListCanvas из узла визуализации, связанного с текущим представлением.
Запишите команды рисования пользовательского интерфейса текущего и вспомогательного видов в DisplayListCanvas. (Рисовать (холст)
Наконец, данные списка отображения, которые были нарисованы в DisplayListCanvas, заполняются в узел визуализации, связанный с текущим представлением. (RenderNode.end (canvas))
Таким образом, Показать список окна приложения завершается. Построенный список отображения соответствует списку отображения корневого узла визуализации окна приложения, и этот список отображения содержит список отображения всех дочерних представлений рекурсивно.
Дополнительные очки
Как поддержать рисование программного обеспечения API во время аппаратного ускорения
RenderNode будет связан только с представлениями, поддерживающими и поддерживающими аппаратное ускорение. В то же время графический процессор не поддерживает все команды рисования 2D UI. Подробную информацию можно найти в документации разработчика Android. Поэтому команды рисования, которые не поддерживаются графическим процессором, могут отображаться только программным обеспечением.
Конкретный метод заключается в получении растрового изображения через кеш представления через метод buildDrawingCache (), что означает, что рисование представления всего происходит в этом растровом изображении. После рисования растровое изображение будет записано в список отображения родительского VIew. При выполнении команды «Показать список» родительского вида записанное в нем растровое изображение рисуется командой «Открыть GL».
Основная операция пользовательского интерфейса представления реализуется функцией-членом onDraw. Вы можете получить холст для получения API рисования через параметры метода onDraw. Но для View не нужно различать, отображается ли он аппаратным или программным обеспечением.
Если обрабатываемое в данный момент представление является группой представлений, дочерний вид будет перемещаться через dispatchDraw для рисования.
Кроме того, для представления, использующего аппаратную визуализацию, его фон также абстрагируется как узел визуализации, нарисованный на узле визуализации, связанном с представлением хоста, что эквивалентно обработке фона как дочернего представления представления. (Отражено методом drawRenderNode метода ViewBackground ()) Следовательно, удаление дублирующих или ненужных фонов в макете может ускорить построение ЦП, а также снизить нагрузку на графический процессор. В частности, вы можете отладить перегрузку графического процессора в параметрах разработчика, чтобы просмотреть макет ситуация.
Выше приведен процесс создания списка отображения (графического буфера) во время аппаратного ускорения.Наконец, давайте посмотрим на небольшой фрагмент кода, чтобы оценить принцип гладкой работы, предоставляемой списком отображения. (Просмотр изменений прозрачности)
Только программный рендеринг против аппаратного ускорения
Резюме аппаратного ускорения
Рестеризация: растеризация. Относится к самым основным операциям рисования Button, Shape, Path, String, Bitmap и других компонентов. Растеризация разделяет эти компоненты на разные пиксели для отображения. Это очень трудоемкая операция, и для ускорения операции растеризации был введен графический процессор.
На этапе построения аппаратного ускорения ЦП отвечает за вычисление компонентов представления пользовательского интерфейса на полигоны и текстуры, которые затем передаются в графический процессор для растеризованного рендеринга в отдельном потоке.
Чтобы сделать приложение гладким, нам нужно обработать все операции с процессором, вычислением графического процессора, построением, рендерингом и другими операциями в пределах 16 мс каждого кадра.
Режим рендеринга GPU
Наконец, я прилагаю карту стилей режима рендеринга с помощью графического процессора. Я должен был прочитать эту статью, чтобы лучше понять процесс рисования экрана Android. Это также будет более удобно для работы с киосками пользовательского интерфейса.
ссылка
Разные точки CPU / GUP: принцип аппаратного ускорения Android и реализация
Концептуальная дифференциация графических компонентов: введение в изменения в графической структуре отображения
Статья углубленного анализа аппаратного ускорения: принципы аппаратного ускорения
Серия анализа исходного кода Лао Луо: аппаратная ускоренная технология рендеринга пользовательского интерфейса приложения Android
Модель оптимизации производительности Android от Google Перевод: модель оптимизации производительности Android
илиподметатьСледуйте за моим публичным аккаунтом