<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Alexander Goremykin on Medium]]></title>
        <description><![CDATA[Stories by Alexander Goremykin on Medium]]></description>
        <link>https://medium.com/@ifresh.wp?source=rss-55766948f623------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*srh_DzUewp4u0DOUwtjdwA.jpeg</url>
            <title>Stories by Alexander Goremykin on Medium</title>
            <link>https://medium.com/@ifresh.wp?source=rss-55766948f623------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 22:24:47 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ifresh.wp/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[UIGestureRecognizer: теория, практика, кастомизация]]></title>
            <link>https://medium.com/yandex-maps-mobile/uigesturerecognizer-tutorial-83f2128e479d?source=rss-55766948f623------2</link>
            <guid isPermaLink="false">https://medium.com/p/83f2128e479d</guid>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[apps]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[uikit]]></category>
            <dc:creator><![CDATA[Alexander Goremykin]]></dc:creator>
            <pubDate>Thu, 12 Jul 2018 10:44:37 GMT</pubDate>
            <atom:updated>2018-07-12T10:51:39.163Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*DhhAVKOKDNjmszDZqtBrWA.jpeg" /></figure><p>Представляя первый iPhone в 2007 году, Стив Джобс апеллировал к устареванию концепции физической клавиатуры у мобильных устройств: “<em>Buttons &amp; controls can’t change</em>”. С этого момента началось стремительное развитие устройств с качественными тачскринами, позволившими отказаться и от физических кнопок, и от стилусов. Теперь палец — главный инструмент управления девайсом и мы можем тапать по кнопкам, свайпать списки, пинчить фотографии… Давайте разберемся как это реализовано со стороны софта и научимся использовать всю мощь механизма распознавания жестов.</p><h3>UITouch и его обработка</h3><p>Но давайте по порядку. Перед тем, как начинать распознавать жесты, надо понять, как вообще приложение получает информацию о касаниях, свайпах, нажатиях на экран и кто их обрабатывает.</p><p>Что происходит, когда палец пользователя касается экрана? Система создает объект типа <strong>UITouch</strong>, который будет ассоциирован с текущим касанием на все время его жизни, пока палец пользователя не оторвется от экрана. Это значит, что на время всей цепочки событий</p><blockquote>“палец коснулся экрана → палец движется по экрану → палец оторвался от экрана”</blockquote><p>для каждого пальца, касающегося экрана, существует уникальный объект <strong>UITouch</strong>. Далее, используя механизм <a href="https://medium.com/yandex-maps-ios/%D0%B4%D0%B5%D1%80%D0%B6%D0%B8%D0%BC-%D1%83%D0%B4%D0%B0%D1%80-%D1%81-hittest-542653d51a8c">hit-testing’а</a>, находится самая глубокая в иерархии <strong>UIView</strong>, frame которой содержит в себе точку касания экрана. Полученная <strong>UIView </strong>становится<strong> firstResponder, </strong>начинает получать уведомления о <strong>UITouch</strong> и прокидывать их дальше по <a href="https://medium.com/yandex-maps-ios/tooltip-menu-for-every-view-1aede0d4d3e7"><strong>responderChain</strong></a><strong>.</strong></p><p>Для обработки поступающих событий, <strong>UIView</strong> предоставляет несколько методов:</p><ul><li><strong>touchesBegan(_ touches: Set&lt;UITouch&gt;, with event: UIEvent?) </strong>— начало касания (экрана коснулись пальцы)</li><li><strong>touchesMoved(_ touches: Set&lt;UITouch&gt;, with event: UIEvent?)</strong> — изменение параметров касания (позиция на экране, сила (ForceTouch))</li><li><strong>touchesEnded(_ touches: Set&lt;UITouch&gt;, with event: UIEvent?)</strong> — конец касания (пальцы были убраны с экрана)</li><li><strong>touchesCancelled(_ touches: Set&lt;UITouch&gt;, with event: UIEvent?)</strong> — отмена касания (далее рассмотрим, что это значит)</li></ul><p>Так как экран iPhone поддерживает мультитач, то в один момент времени может измениться состояние сразу нескольких касаний. Например, если пользователь коснется экрана двумя пальцами одновременно, система вызовет <em>touchesBegan</em><strong> </strong>лишь один раз, но во множестве <em>Set&lt;UITouch&gt;</em> мы получим два объекта — каждый для своего пальца.</p><p>Первые три метода (<em>touchesBegan, touchesMoved, touchesEnded</em>) отвечают за “нормальный” жизненный цикл <strong>UITouch</strong> и вызываются при начале касания, изменении его параметров (позиция на экране, сила нажатия) и конце касания соответсвенно.</p><p>Однако, <em>touchesCancelled </em>выбивается из их ряда. На самом деле, концом жизненного цикла <strong>UITouch</strong> может быть не только физический конец жеста, но и какое-либо программное событие, в следствие которого система будет вынуждена прервать обработку данного касания. Это может произойти, например, в случае, если появился интерфейс входящего звонка и продолжение обработки касания будет некорректным — пользователь уже находится в контексте другого приложения (телефон). Ожидается, что при получении <em>touchesCancelled</em> приложение отменит все действия которые могли быть произведены в <em>touchesBegan/Moved</em>. Для понимания логики этого требования рассмотрим кнопку. Пусть пользователь нажал на нее, но еще не поднял палец и в это время происходит входящий звонок. Если обработать <em>touchesCancelled</em> аналогично <em>touchesEnded</em> и вызвать обработчик нажатия кнопки, то после окончания звонка и возврата в приложение будет произведено какое-то действие, которое пользователь мог не ожидать.</p><p>Зная как обрабатывать тач-события, мы, вообще говоря, можем реализовать сколь угодно сложную логику и начать вычленять из них нечто, что может нас интересовать. Давайте, например, попробуем обрабатывать долгое нажатие на <strong>UIView</strong>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c12cf21592bd31d01953134c4e9beb03/href">https://medium.com/media/c12cf21592bd31d01953134c4e9beb03/href</a></iframe><ol><li>Для каждого нового <strong>UITouch </strong>создаем <strong>DispatchWorkItem</strong>, который, будучи выполненным через 0.3c вызовет callback onLongTap.</li><li>Если пользователь достаточно сильно сдвинет палец от начальной точки касания, то такой жест не надо обрабатывать как long-tap и надо отменить его <strong>DispatchWorkItem.</strong></li><li>В случае, если касание было прекращено пользователем или отменено системой, то вызываем <em>cancel() </em>у отвечающего ему <strong>DispatchWorkItem</strong>, тем самым предотвращая вызов callback’a, если он еще не был осуществлен.</li></ol><p>Вот и все! Теперь мы можем распознавать долгие нажатия на нашей <strong>UIView. </strong>Но сколь прост получившейся код, столь же он и плох с точки зрения архитектуры. Представим, что мы хотим “научить” еще какую-нибудь <strong>UIView</strong> в приложении обрабатывать долгие нажатия. Или больше — перед нами стоит задача отлавливать и долгое нажатие, и двойной тап по <strong>UIView</strong> одновременно. Какие у нас варианты? Можно либо скопировать код, либо прибегнуть к наследованию. Очевидно, что ни тот, ни другой подход тут неприемлем. Так или иначе, но мы должны вынести логику по обработке <strong>UITouch</strong> событий в независимую сущность. И тут, наконец, на поле выходит <strong>UIGestureRecognizer</strong>.</p><h3>UIGestureRecognizer</h3><p><strong>UIGestureRecognizer</strong> — сущность, предоставляемая нам <strong>UIKit</strong> и инкапсулирующая в себе всю логику по работе с <strong>UITouch</strong> объектами. Имея <strong>UIGestureRecognizer</strong> легко “научить” любую <strong>UIView</strong> распознавать какой-либо жест, достаточно добавить инстанс необходимого рекогнайзера на <strong>UIView</strong> через <strong>addGestureRecognizer</strong> и настроить обработку событий посредствам паттерна Target-Action.</p><blockquote><strong>UIGestureRecognizer </strong>инкапсулирует в себе логику по работе с UITouch/UIPress объектами</blockquote><p><strong>UIKit</strong> предлагает нам на выбор несколько стандартных реализаций <strong>UIGestureRecognizer</strong>’а:</p><ul><li><strong>UITapGestureRecognizer</strong> — тапы</li><li><strong>UIPinchGestureRecognizer</strong> — щипковый жест (зум) двумя пальцами</li><li><strong>UIRotationGestureRecognizer</strong> — жест “поворота” двумя пальцами</li><li><strong>UISwipeGestureRecognizer</strong> — свайп в любом направлении</li><li><strong>UIPanGestureRecognizer</strong> — скролл в любом направлении</li><li><strong>UIScreenEdgePanGestureRecognizer</strong> — скролл от края экрана (как жест возврата к предыдущему экрану через смахивание от края дисплея)</li><li><strong>UILongPressGestureRecognizer</strong> — долгое нажатие</li></ul><p>Наш код обработки долгого нажатия может быть значительно упрощен с использованием <strong>UILongPressGestureRecognizer</strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/90bf95c2176127d3a5989c246fdbaea0/href">https://medium.com/media/90bf95c2176127d3a5989c246fdbaea0/href</a></iframe><p>Идейно все рекогнайзеры делятся на два типа:</p><ul><li><strong>дискретные</strong> (<em>UITapGestureRecognizer, UILongPressGestureRecognizer, UISwipeGestureRecognizer</em>)</li><li><strong>непрерывные</strong> (<em>UIPinchGestureRecognizer, UIRotationGestureRecognizer, UIPanGestureRecognizer, UIScreenEdgePanGestureRecognizer</em>)</li></ul><p>Работа с дискретными рекогнайзерами напоминает работу с обычной <strong>UIButton</strong> — задаем action, который будет вызван единожды по факту наступления требуемого события.</p><p>Непрерывные рекогнайзеры, напротив, будут вызывать action-метод много раз при каждом значимом для распознаваемого ими жеста изменении. Например, <strong>UIPanGestureRecognizer</strong> будет обращаться к action-методу всякий раз, как палец пользователя будет сдвигаться по экрану, чтобы мы могли обработать это движение и соответствующим образом обновить UI.</p><p>Одним из основных свойств непрерывных рекогнайзеров, которое нам необходимо обрабатывать в action-методе является <strong><em>state: UIGestureRecognizer.State</em></strong>, которое может принимать следующие значения:</p><ul><li><strong>possible</strong> — рекогнайзер готов к работе</li><li><strong>began</strong> — начался распознаваемый жест</li><li><strong>changed</strong> — изменение состояния, например, движение пальца при скролле</li><li><strong>recognized (</strong>он же<strong> ended)</strong> — жест закончился</li><li><strong>cancelled</strong> — аналог touchesCancelled</li><li><strong>failed</strong> — жест не был распознан (например мы ожидали скролл двумя пальцами, но экрана коснулся лишь один)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*htDVkAIR8WRaBIgKZt28KA.png" /></figure><h3>UIGestureRecognizer и UIView</h3><p>Главное что надо помнить — <strong>UIGestureRecognizer</strong> первым получает право обработки <strong>UITouch</strong> ивентов. <strong>UIGestureRecognizer</strong>’ы стоят немного в стороне от обычного механизма responder chain’а. Система, определив через <em>hitTest</em> самую глубокую <strong>UIView</strong> в которую попал палец пользователя, собирает все рекогнайзеры в цепочке её superview вплоть до <strong>UIWindow</strong>. Среди собранных рекогнайзеров определяется множество тех, которые буду работать и порядок их работы (это поведение задается через делегата рекогнайзера и мы рассмотрим его чуть далее). <strong>UIGestureRecognizer</strong> может перехватить <strong>UITouch</strong> так, что <strong>UIView</strong> о нём никогда не узнает. Более того, если рекогнайзер перехватит <strong>UITouch</strong>, то его не увидит вообще ни одна <strong>UIView</strong> в <strong>responderChain</strong> вне зависимости от того, на какую <strong>UIView</strong> был добавлен рекогнайзер.</p><p>Увидит ли <strong>UIView</strong> эти события зависит от реализации рекогнайзера и/или его настроек. Опустив зависимость от конкретной реализации, рассмотрим какие параметры влияют на доставку событий обрабатываемых в рекогнайзере до <strong>UIView</strong>.</p><ul><li><strong>cancelsTouchesInView: Bool <em>(default: true)</em></strong></li><li><strong>delaysTouchesBegan: Bool <em>(default: false)</em></strong></li><li><strong>delaysTouchesEnded: Bool <em>(default: true)</em></strong></li></ul><p>Разберем по-порядку.</p><p><strong>cancelsTouchesInView </strong>— если рекогнайзер распознает жест, то все <strong>UITouch</strong>, которые уже были переданы к этому моменту в <strong>UIView</strong>,<strong> </strong>но<strong> </strong>имеющие отношение к жесту, будут отменены (<em>touchesCancelled</em>). Те <strong>UITouch</strong> жеста, которые еще не были переданы в <strong>UIView,</strong> никогда до нее не дойдут.</p><p>Для понимания рассмотрим пример: пусть есть ThreeFingerRecognizer, детектирующий касание тремя пальцами. Переопределим методы <em>touches{XXX}</em> в <strong>UIView, </strong>добавив в них print и посмотрим как будет меняться вывод в зависимости от значения флага <em>cancelsTouchesInView.</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/00af593ddcc8848b62c03aa69e0f03be/href">https://medium.com/media/00af593ddcc8848b62c03aa69e0f03be/href</a></iframe><p>В обоих случаях вывод в консоль достаточно похож. Все начинается с того, что пользователь палец за пальцем касается экрана. Различие в поведении наступает в момент касания экрана третьим пальцем. Если у рекогнайзера поднят флаг <em>cancelsTouchesInView, </em>то он полностью <em>“захватывает” </em>жесты и у <strong>UIView</strong> вызывается <em>touchesCancelled </em>для этих объектов <strong>UITouch</strong>. Более <strong>UIView</strong> не будет получать уведомления о состоянии этих <strong>UITouch</strong> объектов. Если же <em>cancelsTouchesInView </em>сброшен, то факт начала распознавания рекогнайзером жеста проходит для <strong>UIView</strong> прозрачно и события <em>touches{XXX}</em> продолжают исправно поступать в <strong><em>UIView</em></strong>.</p><p><strong>delaysTouchesBegan </strong>— ни один <strong>UITouch</strong> не попадет в <strong>UIView</strong> до тех пор, пока рекогнайзер не перейдет в состояние <em>failed</em>. После перехода в <strong>failed</strong> у <strong>UIView</strong> будут вызваны методы <em>touchesBegan</em> и <em>touchesMoved</em> (если надо).</p><p>Обратимся к схожему с предыдущим примеру, но рассмотрим две реализации ThreeFingerRecognizer. Первая, как и в прошлый раз, будет детектировать касание тремя пальцами и игнорировать новые тачи, если на экране уже три пальца. Вторая реализация рекогнайзера будет переходить в состояние failed по факту касания более чем тремя пальцами.</p><p>Установим флаг <strong>delaysTouchesBegan </strong>в<strong> true </strong>и изучим вывод для двух реализаций рекогнайзера.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8c946a262fb53d8eb8470d31b8b6161c/href">https://medium.com/media/8c946a262fb53d8eb8470d31b8b6161c/href</a></iframe><p>Видно, что флаг, оправдывая свое название, задерживает передачу событий о <strong>UITouch</strong>, который потенциально могут быть частью жеста, до момента, когда не станет точно понятно, что жест распознан не будет. При этом, если рекогнайзер не перейдет в состояние failed, то <strong>UIView</strong> и вовсе никогда не получит эти ивенты.</p><p><strong>delaysTouchesEnded </strong>— ни для одного <strong>UITouch</strong>, обрабатываемого рекогнайзером, не будет вызван метод <em>touchesEnded</em> у <strong>UIView</strong> до тех пор пока рекогнайзер не перейдет в состояние <em>failed</em>. В случае успешного распознавания жеста <strong>UIView</strong> получит <em>touchesCancelled</em> для данных <strong>UITouch</strong>. Это гарантирует вызов <em>touchesCancelled </em>для<em> </em><strong>UITouch</strong> являющихся частью распознанного жеста.</p><p>Поведение флага напоминает собой таковое в случае <strong>delaysTouchesBegan </strong>за исключением того, что тут UIView может начать обрабатывать жест сразу, не дожидаясь пока рекогнайзер перейдет в состояние failed. Это позволит реализовать более отзывчивый интерфейс.</p><p>Комбинируя данные флаги можно добиваться требуемого результата. Однако, надо быть аккуратным. Нужно помнить, что часть UI-элементов обрабатывает жесты пользователя через рекогнайзеры (например, UIScrollView), а часть — через прямую обработку UITouch (например, UIButton). Неудачная конфигурация может сделать обработку жестов непредсказуемой.</p><blockquote>Если же стоит задача сделать полностью “прозрачный” для <strong>UIView</strong> рекогнайзер, то надо смело выставлять все три флага (<strong>cancelsTouchesInView, delaysTouchesBegan, delaysTouchesEnded</strong>)в false.</blockquote><h3><strong>UIGestureRecognizerDelegate</strong></h3><p>Разобравшись с настройкой отношения<strong> UIGestureRecognizer ← → UIView, </strong>настало время перейти к конфигурации взаимной работы многих рекогнайзеров.</p><p>Кроме задания action-метода мы можем определить делегата <strong>UIGestureRecognizer</strong>’a. Представим, что мы хотим обрабатывать простой тап и двойной тап по одной и той же <strong>UIView</strong> одновременно. При этом, если пользователь делает двойной тап, то он не должен быть распознан как два простых последовательных. Для этого необходимо настроить взаимосвязь между рекогнайзерами посредствам реализации методов делегата:</p><blockquote><strong>func gestureRecognizer(UIGestureRecognizer, shouldRequireFailureOf: UIGestureRecognizer) -&gt; Bool</strong><br>Должен ли рекогнайзер начинать свою работу только после того, как какой-то другой рекогнайзер перешел в состояние failed</blockquote><blockquote><strong>func gestureRecognizer(UIGestureRecognizer, shouldBeRequiredToFailBy: UIGestureRecognizer) -&gt; Bool</strong></blockquote><blockquote>Может ли какой-то другой рекогнайзер начать свою работу до перехода текущего в состояние faild</blockquote><p>Очевидно, что для корректной реализации поставленной задачи рекогнайзеру простого тапа необходимо дождаться перехода рекогнайзера двойного тапа в состояние failed. Это значит, что двойного тапа не произошло и данный жест можно обработать как нечто другое. Если же имел место именно двойной тап, то рекогнайзер простого тапа не начнет работу и не распознает жест как два отдельных тапа.</p><p>Рассмотрим еще один пример: зум и поворот фотографии. Оба этих жеста должны обрабатываться одновременно, а, значит, сделать какой-либо рекогнайзер приоритетнее как в предыдущем примере не выйдет — необходима их одновременная работа. Для реализации требуемого поведения необходимо обратиться к методу делегата</p><blockquote><strong>func gestureRecognizer(UIGestureRecognizer, shouldRecognizeSimultaneouslyWith: UIGestureRecognizer) -&gt; Bool</strong></blockquote><p>Определив его соответствующим образом можно добиться одновременной работы нескольких рекогнайзеров.</p><p>Кроме того, делегат может решить должен ли рекогнайзер вообще начинать работу в данный момент, и информацию о каких <strong>UITouch</strong> он будет получать.</p><h3>Практика</h3><p>Но лучше один раз увидеть.</p><p>Давайте перенесем поведение фотографии в галерее на обычную <strong>UIView</strong>. Реализуем возможность перетаскавания по экрану, зума и поворота двумя пальцами.</p><p>Начнем с перетаскивания по экрану. Для этого нам понадобится единственный <strong>UIPanGestureRecognizer</strong>, позволяющий отлавливать скроллы по экрану.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0229aa9d982ee79d1dfce2104da32e68/href">https://medium.com/media/0229aa9d982ee79d1dfce2104da32e68/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/180/1*oohBJoJlKqTc6nLnYxNyTQ.gif" /></figure><ol><li>Максимальное число касаний в жесте — 1 (перетаскиваем одним пальцем).</li><li>Сохраняем точку начала жеста.</li><li>При каждом сдвиге пальца обновляем позицию UIView на экране на требуемую величину.</li></ol><p>Дальше по списку зум — щипковым жестом двумя пальцами изменять размер <strong>UIView</strong>. С этим нам поможет <strong>UIPinchGestureRecognizer</strong>. Общая идея аналогична подходу с перетаскиванием.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/daecd695dd1db9465647750949d170f8/href">https://medium.com/media/daecd695dd1db9465647750949d170f8/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/180/1*wUVrWP1jT8pkdf44UJnNUQ.gif" /></figure><p>Запустив приложение можно заметить, что в поведении есть изъян. Что будет, если начать двигать квадрат одним пальцем, а потом, коснувшись экрана вторым, попытаться изменить его размер? <strong>UIPinchGestureRecognizer</strong> не срабатывает и размер <strong>UIView</strong> не меняется. И наоборот, если начать зумить квадрат двумя пальцами, то система уже не даст его сдвинуть с места. Настает время делегата!</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/90ed39896965a79465a1686c97d6f618/href">https://medium.com/media/90ed39896965a79465a1686c97d6f618/href</a></iframe><p>Запустив приложение еще раз можно убедиться, что теперь все работает как и планировалось!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/180/1*7wxTqfn6dNuvqkZOuOx6Pg.gif" /></figure><p>Остается разобраться с поворотом. Если вы дочитали до этой точки, то у вас уже достаточно знаний, чтобы реализовать эту функциональность самостоятельно. Ну а если на вашем пути встретятся проблемы, то вы всегда можете обратиться к <a href="https://github.com/alex1powers/GestureRecognizersExample">полному коду примеров</a>.</p><p>Добавим еще одно требование к нашему приложению. Пусть по тапу на <strong>UIView</strong> будет меняться её цвет, а по двойному тапу возвращаться к начальным значениям размер и позиция. Для обработки тапов будем использовать два <strong>UITapGestureRecognizer</strong>’а и не забудем настроить порядок их работы через определение методов делегата.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5f931c00095197f24f7643bfa984c5e1/href">https://medium.com/media/5f931c00095197f24f7643bfa984c5e1/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/180/1*bvq8aUqswuERYGehJQHzWQ.gif" /></figure><ol><li>Ключевой момент примера — реализация метода делегата, что позволяет задать корректный порядок работы двух <strong>UITapGestureRecognizer</strong>’ов.</li></ol><p>Но не всегда обязательно писать так много кода для работы с делегатами. Если в одной точке имеется доступ к обоим рекогнайзерам, то реализовать схожее поведение можно через явное определение зависимости посредствам метода <a href="https://developer.apple.com/documentation/uikit/uigesturerecognizer/1624203-require?changes=_4"><em>require(toFail otherGestureRecognizer: UIGestureRecognizer)</em></a><em>.</em></p><h3>Кастомный UIGestureRecognizer</h3><p><strong>UIKit</strong> предоставляем нам богатый набор рекогнайзеров всех основных “iOS жестов”, конфигурируя которые можно покрыть большинство стандартных требований и кейсов. Но что, если поставленная задача все же выходит за рамки возможностей стандартных рекогнайзеров? Безусловно можно написать свою реализацию!</p><p>Первым шагом реализации собственного рекогнайзера должно быть добавление строчки <strong><em>import UIKit.UIGestureRecognizerSubclass</em></strong>, что подключит категорию класса <strong>UIGestureRecognizer</strong> с переопределением свойства <strong>state</strong> и сделает его доступным на запись.</p><p>Реализация своего рекогнайзера сводится к переопределению уже знакомых нам методов <strong>touchesBegan/Moved/Ended/Cancelled </strong>в которых должна быть сосредоточена вся логика по обработке событий и вычленения из них требуемых жестов. Также необходимо переопределить метод <strong>reset()</strong> в котором необходимо очищать состояние рекогнайзера. И, последнее, что может нам пригодится — метод <strong>ignore(_ touch: UITouch, for event: UIEvent)</strong>, посредствам которого, мы можем сообщить системе, что конкретный <strong>UITouch</strong> не относится к нашему жесту и мы не хотим далее получать уведомления о его изменениях.</p><p>Собирая все воедино, давайте напишем свой непрерывный рекогнайзер, который будет распознавать сильное нажатие (ForceTouch) и, если сила превысила заданный порог, то уведомлять target о её изменении.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6bce3dabc10c5afda52c4b7575885e53/href">https://medium.com/media/6bce3dabc10c5afda52c4b7575885e53/href</a></iframe><p>Как видите, код сильно похож на то, что мы писали в примере про распознавание долгого нажатия на <strong>UIView</strong>. Но надо не забывать про корректную реализацию метода <strong>reset()</strong>.</p><h3>Вместо заключения</h3><p>Из этой статьи вы могли получить основные знания для работы с UIGestureRecognizer’ами и реализации своих собственных.</p><p>Полный код примеров можно найти на <a href="https://github.com/alex1powers/GestureRecognizersExample">GitHub</a>.</p><p>Кроме того никогда не бывает лишним почитать официальную документацию:</p><ul><li><a href="https://developer.apple.com/documentation/uikit/uigesturerecognizer?changes=_4">UIGestureRecognizer</a></li><li><a href="https://developer.apple.com/documentation/uikit/touches_presses_and_gestures/implementing_a_custom_gesture_recognizer/about_the_gesture_recognizer_state_machine?changes=_4">Gesture recognizer state machine</a></li><li><a href="https://developer.apple.com/documentation/uikit/touches_presses_and_gestures/implementing_a_custom_gesture_recognizer?changes=_4">Implementing custom recognizer</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=83f2128e479d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yandex-maps-mobile/uigesturerecognizer-tutorial-83f2128e479d">UIGestureRecognizer: теория, практика, кастомизация</a> was originally published in <a href="https://medium.com/yandex-maps-mobile">Яндекс.Карты Mobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Objective-C Runtime + Swift = ❤]]></title>
            <link>https://medium.com/yandex-maps-mobile/objc-runtime-in-swift-2cbfbc59c5cb?source=rss-55766948f623------2</link>
            <guid isPermaLink="false">https://medium.com/p/2cbfbc59c5cb</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[objective-c]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Alexander Goremykin]]></dc:creator>
            <pubDate>Sat, 24 Mar 2018 11:18:55 GMT</pubDate>
            <atom:updated>2018-03-24T11:30:35.008Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Snc-IJR79qTZCBMfOF3hZw.jpeg" /></figure><p>Трудно отрицать мощь Objective-C Runtime. В умелых руках с его помощью можно творить... трудно понимаемый код.</p><p>Шутка.</p><p>Так или иначе бывают моменты, когда использование Runtime’а очень кстати. И все становится немного интереснее, если вы пишите на Swift.</p><p>Предлагаю разобрать несколько полезных сниппетов кода.</p><h4><strong>Протаскивание приватного Objective-C метода в Swift</strong></h4><p>Начнем с чего попроще. Предположим у вас есть некоторый класс, написанный на Objective-C, у которого в @implementation секции реализуется некоторый метод:</p><pre>-(void)veryUsefulMethod {</pre><pre>…</pre><pre>}</pre><p>При этом он не объявлен в интерфейсе класса.</p><p>Будь мы в мире победившего Objective-C, то все что нам требовалось бы сделать это реализовать метод с таким же названием в наследнике. Тривиально. Но что делать в Swift?</p><pre>override func veryUsefulMethod()</pre><p>Хорошая попытка, но нет. Безусловно такой код не соберется, ведь в текущем скоупе нету никакого veryUsefulMethod и, соответсвенно, оверайдить нечего.</p><p>На самом деле решение аналогично тому, что мы сделали бы в Objective-C — реализуем метод с аналогичным именем. Остается рассказать о нем Runtime’у и сделать это очень просто: необходимо добавить спецификатор <strong><em>@objc</em></strong> перед нашим свифтовым кодом.</p><pre>@objc func veryUsefulMethod()</pre><p>Если вам интересно глубже разобраться с диспатчем вызовов в Swift и почему <strong><em>@objc</em></strong> сработал, то советую обратиться к <a href="https://www.raizlabs.com/dev/2016/12/swift-method-dispatch/">статье Браина Кинга абсолютно раскрывающей данную тему</a>.</p><p>Ок, мы переопределили приватный метод, но как вызвать super реализацию?</p><h4><strong>Вызов приватных Objective-C методов из Swift</strong></h4><p>Зная подход к Runtime’у можно вытащить из него много полезной информации. Что у нас есть на руках? — Прототип приватного метода. Кажется, этого более чем достаточно, чтобы вызвать его! Действительно, зная прототип метода, мы можем создать его селектор и с его помощью получить посредствам функции <strong>class_getMethodImplementation IMP</strong> метода. IMP — тривиальный указатель на C — функцию. Тривиальный, но из Swift’а мы не сможем просто взять и вызвать его.</p><p>Но и тут от нас требуется не много. В Swift 2 было добавлено ключевое слово <a href="https://developer.apple.com/library/content/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithCAPIs.html"><strong>@convetion</strong></a><strong> </strong>благодаря которому мы можем объявить тип замыкания, к которому в дальнейшем мы можем скастить указатель на C — функцию и без проблем вызвать его. Итак <strong>@convention + unsafeBitCast </strong>— то что нам нужно.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e2d95b22c2d589de0daedcc511876ed2/href">https://medium.com/media/e2d95b22c2d589de0daedcc511876ed2/href</a></iframe><h4><strong>Полноценный оверайд приватного Objective-C метода в Swift</strong></h4><p>Давайте соберем все вместе и полноценно оверайднем метод <strong>veryUsefulMethod</strong> в Swift.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/74550e026cf12265dbc836073cbfa4d2/href">https://medium.com/media/74550e026cf12265dbc836073cbfa4d2/href</a></iframe><p>Казалось бы, за чем вообще писать об этом? Ведь очевидно, что надо просто собрать все то, что было сказано выше вместе. На самом деле, тут кроется одна особенность, на которой я и хочу заострить внимание.</p><p>Очень важно в вызов метода <strong>class_getMethodImplementation </strong><em>передавать тип своего родителя, а не свой тип. </em>Иначе <strong>class_getMethodImplementation</strong> будет возвращать IMP текущего, а не super метода и мы получим бесконечный цикл, который довольно быстро закончится переполнением стека.</p><h4>Method swizzling в Swift</h4><p>Method swizzling позволяет подменить реализацию метода в Runtime. Известная техника, раскрывающая потенциал Objective-C Runtime.</p><p>По большому счету, в Swift method swizzling осуществляется аналогично тому, как это делается в Objective-C. Все что требуется это получить IMP целевого метода и метода который займет его место. Все это мы уже делали в предыдущих примерах. Имея на руках требуемые IMP, с помощью метода <strong>method_exchangeImplementations</strong> мы меняем их местами. Вот и все. Теперь, при попытке вызвать метод A, Runtime будет диспатчить вызов к нашему подставному методу B.</p><p>Однако, с переходом на Swift 4 оверайд <strong>class func initialize()</strong> был запрещен.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XTytCY6I5DfqwH2naTqEWA.png" /></figure><p>Значит, нам надо найти другую потокобезопасную альтернативу, гарантирующую выполнение блока кода один раз за все время работы программы. И такая альтернатива есть —<em> static переменная.</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c674df29b8d27d9e3d33f6fdc900d7e6/href">https://medium.com/media/c674df29b8d27d9e3d33f6fdc900d7e6/href</a></iframe><p>Безусловно, у Objective-C Runtime еще огромное количество всякого интересного. Но, тем не менее, здесь мы рассмотрели самые ходовые техники, которые могут вам пригодиться.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2cbfbc59c5cb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yandex-maps-mobile/objc-runtime-in-swift-2cbfbc59c5cb">Objective-C Runtime + Swift = ❤</a> was originally published in <a href="https://medium.com/yandex-maps-mobile">Яндекс.Карты Mobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Магия UILabel или приватное API Autolayout]]></title>
            <link>https://medium.com/yandex-maps-mobile/uilabel-magic-2c83bc62a0db?source=rss-55766948f623------2</link>
            <guid isPermaLink="false">https://medium.com/p/2c83bc62a0db</guid>
            <category><![CDATA[uikit]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[autolayout]]></category>
            <dc:creator><![CDATA[Alexander Goremykin]]></dc:creator>
            <pubDate>Sat, 24 Mar 2018 11:18:22 GMT</pubDate>
            <atom:updated>2018-03-24T12:05:03.652Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>UILabel</strong> — тривиальный компонент UIKit, который каждый использовал огромное число раз. Простой как топор, но отлично выполняющий свои обязанности. Однако, при встрече с Autolayout, лейбл показывает, что и у него есть свои козыри.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*huAC_Z4-UHFQpEnCxSshbA.png" /></figure><p>Рассмотрим тривиальный пример. UILabel со снятым ограничением на количество строк, прибитый к своей superview констрейнтами с трех сторон: слева, справа и сверху. Высота лейбла никак не ограничивается.</p><p>Что будет, если изменится доступная для UILabel ширина? Ожидаемо, его высота обновится так, чтобы идеально совпадать с высотой контента.</p><blockquote>UILabel автоматически рассчитывает высоту, основываясь на заданных констрейнтах и контенте.</blockquote><p>Ничего удивительного, это именно то, что мы ожидаем, когда оставляем “свободной” высоту. Но как это реализовано?</p><p>Чтобы дальнейшие рассуждения были менее абстрактными и их можно было сразу апробировать, предлагаю пописать немного кода. Давайте напишем свой лейбл! Для начала определимся с тем, к чему мы будем стремиться. Как ни странно, нас абсолютно не будет интересовать собственно рендеринг текста. Его можно реализовать через CoreText, CATextLayer или еще как угодно. Сейчас я предлагаю сосредоточиться только на повторении self-sizing поведения оригинального UILabel. Закрепим основные цели, к которым будем идти. Наша реализация:</p><ul><li>должна быть наследником UIView</li><li>иметь тривиальный интерфес</li></ul><pre>var attributedText: NSAttributedString? { get set }</pre><ul><li>должна работать везде где работает оригинальный UILabel и не требовать написания дополнительного, по сравнению с референсом, кода для использования</li></ul><p>И назовем все это дело <strong><em>ASLabel</em></strong>’ом.</p><p>Звучит несложно. Давайте начинать.</p><blockquote><em>“работать везде ... не требовать написания дополнительного кода” — наша мантра на следующие 10 минут</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SoIy9F48lfDcA7jXkyElVA.png" /><figcaption>Ширина и высота <strong>intrinsicContentSize </strong>определяет константы констрейнтов, которые система неявно добавляет на нашу UIView.</figcaption></figure><p>Первое, что приходит в голову это корректное определение <strong>intrinsicContentSize. </strong>Действительно, это тот мостик, что связывает наш контент с миром Autolayout’а, со стороны которого <strong>intrinsicContentSize </strong>есть ни что иное, как два неявно добавленных констрейнта.</p><blockquote>Определим <strong>intrinsicContentSize</strong> и будем возвращать размер контента, расcчитаный через <a href="https://developer.apple.com/documentation/foundation/nsattributedstring/1529154-boundingrect">boundingRect(with:options:context:)</a></blockquote><p>Однако, одного <strong>intrinsicContentSize </strong>будет недостаточно. Очевидно, что для его расчета мы будем опираться на текущую ширину UIView, но она еще не посчитана. Получаем замкнутый круг: <strong>intrinsicContentSize </strong>использует <strong>bounds.width</strong>, для расчета которого нужно знать <strong>intrinsicContentSize</strong>...</p><p>Но это не проблема. Все что нам надо, так это вызвать <strong>invalidateIntrinsicContentSize()</strong>, когда станет известна ширина. Получается, что все заработает ценой двойного прохода лейаута.</p><p>Первый проход: отдаем некорректный <strong>intrinsicContentSize</strong>, но тут оно нам и не важно, ведь все поправится во втором проходе. Второй проход: да, высота нашей UIView сейчас неверна, но зато мы знаем ширину, основываясь на которой можно рассчитать корректный <strong>intrinsicContentSize.</strong></p><p>Напрашивается тривиальная реализация.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b07e3bbf3370bbd9377b7474548abcdd/href">https://medium.com/media/b07e3bbf3370bbd9377b7474548abcdd/href</a></iframe><p>Хммм, но ведь мы планировали завязать <strong>invalidateIntrinsicContentSize() </strong>на факт обновления <strong>bounds</strong>, так почему пришлось трогать <strong>layoutSubviews</strong>? Поспешу вас остановить от перемещения этого кода в <strong>didSet var bounds: CGRect</strong> или даже в колбек <strong>KVO-обзервера </strong>на<strong> bounds</strong>— работать не будет. Система просто проигнорирует нашу просьбу о пересчете <strong>intrinsicContentSize</strong> и не инициирует второй<strong> layout-pass</strong>. Почему? Остается только гадать.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*g26ONVb3vjShvFlVc5Yo8w.png" /><figcaption>Слева - знакомая нам ситуация с одиноким лейблом. Все работает. Справа — два UITableView. У синего в ячейках лежит ASLabel, у красного — UILabel. Высота ячеек с ASLabel рассчитана некорректно!</figcaption></figure><p>Приведенные выше скриншоты демонстрируют нам, что текущая реализация ASLabel в ячейках UITableView — не работает!</p><p>Давайте разберем эту ситуацию подробнее. На экране представлены две UITableView. В методе делегата <a href="https://developer.apple.com/documentation/uikit/uitableviewdelegate/1614998-tableview"><strong>tableView(_:heightForRowAt:)</strong></a><strong> </strong>возвращается константа<strong> </strong><a href="https://developer.apple.com/documentation/uikit/uitableviewautomaticdimension"><strong>UITableViewAutomaticDimension</strong></a>. В синей таблице в ячейках лежит ASLabel, в красной — UILabel. Видно, что для ячеек с ASLabel система не смогла рассчитать корректную высоту.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nRIvGK_IXV-V1-EPVGmlLg.png" /></figure><p>Рассмотрим алгоритм расчета высоты ячеек таблицы. Когда таблице по какой-либо причине хочется узнать высоту своей ячейки, то, безусловно, все начинается с вызова метода делегата <a href="https://developer.apple.com/documentation/uikit/uitableviewdelegate/1614998-tableview"><strong>tableView( _:heightForRowAt:</strong></a><strong>)</strong>. А далее зависит от возвращенного значения. Если была получена константа <a href="https://developer.apple.com/documentation/uikit/uitableviewautomaticdimension"><strong>UITableViewAutomaticDimension</strong></a>, то расчет высоты делегируется системе Autolayout’а, которая посредством вызова метода <a href="https://developer.apple.com/documentation/uikit/uiview/1622623-systemlayoutsizefitting"><strong>systemLayoutSizeFitting</strong></a><strong>, </strong>основываясь только на добавленных на нее констрейнтах,<strong> </strong>получает размер<strong> </strong>UIView.</p><p>Тут стоит обратиться к документации и почитать как работает <a href="https://developer.apple.com/documentation/uikit/uiview/1622623-systemlayoutsizefitting">systemLayoutSizeFitting</a>. Самое важное сейчас для нас это то, что этот метод никак не влияет на frame и, соответственно, не вызывает layoutSubviews. Отсюда следует невозможность работы нашей текущей имплементации ASLabel, ведь мы опираемся на bounds, который никогда не обновляется.</p><p>Но из той же документации мы узнаем, что параметром в <a href="https://developer.apple.com/documentation/uikit/uiview/1622623-systemlayoutsizefitting">systemLayoutSizeFitting</a><strong> </strong>передается некий <strong>targetSize: CGSize</strong>, который мы как раз и можем использовать как хинт при расчете intrinsicContentSize<strong>. </strong>Встает следующая проблема: targetSize относится только к ячейке, но не к её контенту, который, вообще говоря, может быть добавлен с некоторыми отступами. Если дерево контента ячейки довольно сложное, а ASLabel, очевидно, лежит в одном из листов, то нам придется протащить targetSize до самого низа, учитывая нужные отступы на каждом из слоев дерева.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aILaJLV35LvJtcH8855tXA.png" /><figcaption>Исходный TargetSize необходимо преобразовывать на каждом слое View-Tree по пути до ASLabel, учитывая отступы от superview. LabelTargetSize = CGSize(width: TargetSize — dx1 — dx2 — dx3 — image.size.width, height: TargetSize — dy1 — dy2).</figcaption></figure><blockquote>Переопределим <strong>systemLayoutSizeFitting </strong>у<strong> UITableViewCell </strong>и пробросим переданный системой targetSize до <strong>ASLabel</strong>, пересчитав его на каждом уровне View-Tree в зависимости от требуемого лейаута.</blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dee50e22ccfa6d1176e4b5439b090918/href">https://medium.com/media/dee50e22ccfa6d1176e4b5439b090918/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/69553fffacdc42672613e5f54a491613/href">https://medium.com/media/69553fffacdc42672613e5f54a491613/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/329/1*iV7Xi7ZCdFvLaqKx5zelVg.png" /><figcaption>Все работает как надо, но не так просто как с UILabel.</figcaption></figure><p>Отлично! Мы добились того, что теперь все работает и в UITableView. Кажется, мы все ближе к поставленной цели. Однако, хотя мы и получили работающую имплементацию ASLabel, до UILabel ей еще далеко. В самом деле: нам пришлось поработать с ячейкой таблицы, переопределив systemLayoutSizeFitting, пришлось прокинуть targetSize, применяя к нему необходимые преобразования. Таким образом, мы сделали довольно много дополнительной работы, которую не требует UILabel. Более того, мы довольно плотно поработали с фреймами, хотя планировали реализовать все на Autolayout’е. Пока не дожали. Разбираемся дальше!</p><blockquote>“UILabel — работает сам, не требуя дополнительных усилий с нашей стороны.”</blockquote><p>Пора придумать новый план. Суммируя все, <strong>сделаем предположение</strong> о том, что требуемую задачу можно решить как минимум за два прохода лейаута.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*tnD9Bn25UsVoPBWyKDkQIw.png" /><figcaption>Решение задачи требует два прохода лейаута. Первый для получения опорной ширины, которую в дальнейшем можно использовать для верного расчета <strong>intrinsicContentSize</strong>. В ходе второго мы получим валидные фреймы, учитывающие корректное значение <strong>intrinsicContentSize.</strong></figcaption></figure><p>Настало время заглянуть под капот UILabel и понять, что он такого делает с Autolayout’ом. В этом нам помогут вместе с Objective-C Runtime библиотеки:</p><ul><li><a href="https://github.com/nst/RuntimeBrowser">RuntimeBrowser</a></li><li><a href="https://github.com/johnno1962/Xtrace">Xtrace</a></li></ul><p>Сперва обратимся к <a href="https://github.com/nst/RuntimeBrowser">RuntimeBrowser</a> — сдампим и изучим интерфейсы UIView и UILabel. Чтение тысяч строк прототипов функций не очень радует. Однако, памятуя о нашем предположении о двух проходах, попытаемся поискать по тексту что-то намекающее на эти проходы. Немного везения, перебора ключевых слов и, спустя некоторое время, на глаза попадаются две функции:</p><pre>_prepare<strong>ForFirstIntrinsicContentSizeCalculation</strong></pre><pre>_prepare<strong>ForSecondIntrinsicContentSizeCalculation</strong>WithLayoutEngineBounds</pre><p>Их названия недвусмысленно намекают, на то, что в какой-то момент у UIView появляется еще один шанс обновить свои констрейнты. При этом, для второй попытки нам любезно предоставляется некий <strong>LayoutEngineBounds.</strong></p><p>Как уже было сказано, intrinsicContentSize<strong> </strong>преобразуется в два констрейнта. Таким образом, из возможности обновить свои констрейнты вытекает возможность обновить свой intrinsicContentSize.</p><p>Но давайте удостоверимся, что поведение простой UIView отличается от поведения UILabel. Тривиально переопределим метод, поставим внутри breakpoint и посмотрим что произойдет.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6e915594096b2e834473734526879915/href">https://medium.com/media/6e915594096b2e834473734526879915/href</a></iframe><p>Результат ожидаем: в UILabel этот метод вызывается и туда передается некоторый bounds, в то время как в UIView не происходит ни одного обращения. Кажется наше предположение про два прохода подтверждается, и UILabel действительно обновляет свой intrinsicContentSize после первого <strong>constraint-pass</strong>, имея в своем распоряжении<strong> LayoutEngineBounds</strong>, который и использует как <strong>опорную ширину</strong>.</p><p>Остается понять, как получить второй шанс обновления констрейнтов. Настало время вспомнить про <a href="https://github.com/johnno1962/Xtrace">Xtrace</a>. Эта библиотека позволяет логировать все обращения к объекту. Получившийся лог это своего рода развернутый во времени call-stack. Натравим <a href="https://github.com/johnno1962/Xtrace">Xtrace</a> на инстанс UILabel’а и изучим вызовы методов между обращениями к <strong>_prepareForFirstIntrinsicContentSizeCalculation </strong>и <strong>_prepareForSecondIntrinsicContentSizeCalculationWithLayoutEngineBounds.</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8183a413147cb2c1785061f70ba276ab/href">https://medium.com/media/8183a413147cb2c1785061f70ba276ab/href</a></iframe><p>Глаз сразу цепляется за метод <strong>_needsDoubleUpdateConstraintsPass, </strong>название которого явно намекает на то, что у UIView напрямую спрашивается о необходимости второго<strong> constraint-pass</strong>. При этом, UILabel возвращает <strong>true</strong>.</p><blockquote>UILabel явно говорит, что ему нужен еще один constraint-pass посредствам возврата true из метода _needsDoubleUpdateConstraintsPass.</blockquote><p>Теперь посмотрим, что там с UIView. Повторяем работу c <a href="https://github.com/johnno1962/Xtrace">Xtrace</a> и видим, что в случае обычной вью метод <strong>_needsDoubleUpdateConstraintsPass </strong>возвращает <strong>false</strong>.</p><p>Кажется, мы нашли точку разветвления между <strong>UIView</strong> и <strong>UILabel!</strong></p><p>Ок, у нас есть возможность обновить констрейнты, но ведь чтобы верно посчитать <strong>intrinsicContentSize</strong>, нам надо знать <strong>опорную ширину. </strong>Откуда её достать? Самое простое это как раз завязаться на аргумент <strong>LayoutEngineBounds</strong>, который система нам предоставляет. Сохранить его и далее использовать при расчете размера. Но давайте копнем еще чуть-чуть и поймем, как мы можем вытащить <strong>LayoutEngineBounds</strong> напрямую.</p><p>Предлагаю не расписывать все шаги подробно — они в большей степени повторяют все то, что мы только что сделали. Сразу раскрою основные поинты.</p><p>За решение системы констрейнтов отвечает движок Autolayout’а — <strong>NSISEngine</strong>, инстанс которого мы можем получить через обращение к<strong> nsli_layoutEngine() -&gt; NSISEngine. </strong>После первого расчета констрейнтов в движке уже есть фреймы удовлетворяющие констрейнтам, но пока они не присвоены вьюхам в иерархии. Эти промежуточные фреймы мы можем вытащить через <strong>nsis_compatibleBoundsInEngine(_:)</strong>, передав параметром полученный NSISEngine.</p><p>Собирая все вместе, приходим к следующей упрощенной схеме цикла Autolayout’а:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mj5_Aw3uD-Oq1AJdc6biHw.png" /><figcaption>ICS = IntrinsicContentSize</figcaption></figure><p>Пора применить полученные знания на практике!</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5b1a34d2e4a9991c5af35d66296eeb56/href">https://medium.com/media/5b1a34d2e4a9991c5af35d66296eeb56/href</a></iframe><p>Если вас что-то заинтересовало в приведенном выше коде с технической точки зрения, то предлагаю пройти по <a href="https://medium.com/yandex-maps-ios/objc-runtime-in-swift-2cbfbc59c5cb"><strong>ссылке и ознакомиться с особенностями работы с Objective-C Runtime из Swift</strong></a>. Идейно это компиляция всего того, что мы узнали об устройстве UILabel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/551/1*DG_c6xZzDARb20JxAapoJQ.png" /></figure><p>Запускаем и убеждаемся, что все работает как надо!</p><p>При этом нам не пришлось совершать каких-то действий на стороне ячейки и прокидывать targetSize через View-Tree. Все было сделано строго на стороне ASLabel и является деталями его реализации. Кажется, теперь мы можем утверждать, что выполнили поставленную задачу. Отлично!</p><p>Подведем краткие итоги. Мы получили три подхода в решении задачи. Каждый из них имеет свои плюсы и минусы.</p><ul><li><strong>Тривиальное определение корректного intrinsicContentSize</strong></li></ul><p>Простота реализации несомненный плюс, но стоит помнить, что в сочетании с <a href="https://developer.apple.com/documentation/uikit/uitableviewautomaticdimension"><strong>UITableViewAutomaticDimension</strong></a><strong> </strong>это работать не будет. Тем не менее, если вы уверены, что ваша UIView никогда не попадет в таблицу, то это рабочее решение.</p><ul><li><strong>Переопределение systemLayoutSizeFitting</strong></li></ul><p>Нужны таблицы? Тогда это ваш выбор. Однако, придется смириться с тем, что код будет не так элегантен и потребует плотной работы с фреймами.</p><ul><li><strong>Private API и _needsDoubleUpdateConstraintsPass</strong></li></ul><p>Тут все ясно. Готовы идти в продакшен, используя приватное API — это идеальное для вас решение.</p><blockquote>Вместо заключения.</blockquote><p>Что мы вообще сделали? Зачем кому-то понадобится писать свой лейбл?! На самом деле, я не преследовал цели рассказать, как написать свой контрол для вывода строк текста. Ключевой идеей было показать на примере UILabel как можно реализовывать компоненты с нетривиальным self-sizing поведением. Возможно, перед вами будет стоять задача написать сложную UIView с gl-контекстом, которая будет требовать какого-нибудь хитрого поведения касательно её размеров или вы просто перепишите свою self-sizing таблицу, которая подстраивает свой размер под contentSize... Главное, что вы теперь знаете: Autolayout не так прост и позволяет делать невозможные на первый взгляд вещи.</p><h4>Надо только копнуть.</h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2c83bc62a0db" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yandex-maps-mobile/uilabel-magic-2c83bc62a0db">Магия UILabel или приватное API Autolayout</a> was originally published in <a href="https://medium.com/yandex-maps-mobile">Яндекс.Карты Mobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>