Споры о том, что же лучше и выгоднее - нативная или кроссплатформенная разработка, - не утихают уже который год; особенно остро этот вопрос стоит при необходимости разработать мобильное приложение. С одной стороны, идея разработать одно приложение для всех платформ выглядит очень заманчиво, но с другой - такой подход может не лучшим образом сказаться на удобстве для пользователей, внешнем виде, функциональных возможностях и быстродействии. Мы подготовили краткий обзор, который поможет понять, в чём принципиальное различие между этими двумя подходами, и определиться, какой из них выбрать для своего приложения.

Своё, родное…

Сначала поговорим о нативной разработке. Здесь всё просто: для каждой платформы существует нативный язык : для Android это Java, для iOS - Objective-C или Swift, для Windows Phone - C# и так далее. Для каждого нативного языка существует свой набор технологий и фреймворков.

Преимущества использования нативных языков в том, что разработанное на них приложение будет работать быстрее, будет способно использовать все возможности и “фишки” платформы, а интерфейс будет понятен и удобен любому пользователю платформы. К тому же разрабатывать нативные приложения зачастую проще, чем кроссплатформенные.

Главный минус этого подхода в том, что под каждую платформу приходится создавать отдельное приложение, хотя бОльшая часть функциональных возможностей будет одинакова. К тому же разработка нескольких приложений, как нам подсказывает логика, будет более длительной и более затратной. Именно так и родилась идея написать одно приложение, которое потом запускалось бы на нескольких платформах. Этот подход получил название

Кроссплатформенная разработка

Существует два основных способа разработать кроссплатформенное приложение: сделать это “вручную”, написав код на С++ и обёртки для разных платформ , или использовать одну из специально разработанных технологий .

Разработка “вручную”

Суть первого подхода в том, что код на С++ можно запустить где угодно. В Android для этого используется NDK, Windows Phone - Managed C, другие платформы также имеют свои способы обработать и запустить код. Другое дело - такой код будет ограничен в своих возможностях. Например, в Android он не сможет обратиться к экрану или даже самостоятельно запуститься. Чтобы обойти эти ограничения, сначала пишется библиотека с основной логикой на С++, а затем - обёртка на нативном языке, которая запускает библиотеку и обеспечивает её взаимодействие с устройством. Правда, стоит отметить, что такой подход подойдёт лишь для ограниченного круга приложений - там, где на клиентах находится действительно много логики, которую имеет смысл выносить в отдельную библиотеку.

Технологии

Суть второго подхода - использование одной из технологий кроссплатформенной разработки, которых на сегодняшний день существует немало. Вот самые популярные:

React Native в последнее время пользуется особенной популярностью: с ним активно экспериментируют даже такие гиганты рынка, как Uber или Сбербанк. Речь идёт даже не столько о кроссплатформенных приложениях, сколько о принципе «Learn once - write anywhere», то есть о возможности использовать одну и ту же технологию для создания приложений под разные платформы, обеспечивая высокий процент переиспользования кода.

Ещё один вариант написать кроссплатформенное приложение - использовать HTML5 + JavaScript . Кстати, именно так написаны текстовый редактор Atom, Visual Studio Code и Slack (да-да, даже десктопная версия - по сути браузер, который сделали похожим на обычное приложение).

Интересный факт: недавно компания Амперка выпустила необычный микроконтроллер Espruino. Его главная особенность - прошивка, которая крутится на микроконтроллере. Она написана на чистом Си, загружается единожды в отдельное место флеш-памяти микроконтроллера и занимается тем, что исполняет пользовательский JavaScript-код . Так что теперь можно программировать микроконтроллеры и на JS. На JS, Карл!!!

Эта идея кажется абсурдной, но если подумать, и ей можно найти обоснование. С развитием концепции интернета вещей и ростом количества различных IoT-устройств в будущем можно ожидать всплеск спроса на программистов, которые смогут обеспечить их взаимодействие с окружающим миром. А порог вхождения в JavaScript куда как ниже, чем в C или Assembler, тут не поспоришь!

Не всё так просто

Преимущества кроссплатформенной разработки в том, что можно один раз написать приложение или какую-либо его компоненту, используя, например, С++, и запускать его на различных платформах и устройствах. Логично, что и затрат это потребует меньше. Казалось бы - пиши и радуйся! Однако у такого подхода есть и ряд своих недостатков.

И все они имеют одну причину: все платформы разные .

Рассмотрим основные неудобства, с которыми придётся столкнуться, встав на путь кроссплатформенной разработки.

Негативный пользовательский опыт

Каждая платформа имеет свои стандарты: стандартные жесты и элементы управления, расположение элементов, внешний вид иконок… Например, вам хватит одного взгляда на экран, чтобы понять, iOS перед вами или Android. Разработав приложение, которое будет выглядеть одинаково на всех платформах, вы столкнётесь с тем, что пользователь не сможет использовать привычные ему методы управления и не увидит привычного дизайна, а значит, сочтёт ваше приложение менее удобным, чем нативное.

Этим, например, часто страдают игры, портированные на ПК с PlayStation: многие из них не поддерживают мышь и не позволяют настраивать комбинации клавиш, удобные для игрока, что делает их менее удобными, чем игры, разработанные специально для ПК. И если такие приложения, как Mortal Combat или Final Fantasy могут “выезжать” за счёт ностальгии, то разработчикам новых игр следует подумать, прежде чем лишать пользователей привычных им элементов управления.

Другой пример - Matlab, который на Mac использует не верхнее меню, а меню внутри окна, что типично для Windows и противоречит всем гайдлайнам iOS. Будучи монополистом, MatLab может себе это позволить, но если вы разрабатываете приложение, которое будет конкурировать с другими, стоит задуматься, не отдадут ли пользователи предпочтение привычному для них нативному интерфейсу.

Ещё один момент - все платформы отличаются внешне: шрифты, размер и форма кнопок, внешний вид календаря, чекбоксов, radio buttons… Даже если вы хотите, чтобы приложение просто выглядело похожим на нативное, придётся разрабатывать таблицы стилей для каждой платформы, что увеличивает как сроки, так и стоимость разработки.

Ограничения при разработке функциональности

Помимо неудобств для пользователя, кроссплатформенная разработка таит в себе и ряд проблем для разработчика. Дело в том, что действия, которые для пользователя выглядят абсолютно одинаково, на разных платформах могут быть реализованы совершенно по-разному. Рассмотрим на примерах.

Такое привычное всем действие, как drag and drop, принципиально отличается для Mac и для других платформ. Если на Windows или Linux это действие обрабатывается самим приложением, то на Mac в игру вступает непосредственно операционная система, а значит, разработчику потребуется создавать отдельное событие “открытие файла” для того, чтобы на Mac это действие работало корректно. А значит, придётся смириться или с ростом трудозатрат на разработку, или с тем, что привычный пользователям drag and drop на этой платформе просто не будет работать.

Ещё один пример - открытие определённого документа. На всех платформах это действие запускает приложение и передаёт ему то, какой документ надо открыть, как параметр, на Mac же используется специальное событие “открытие файла”. И снова мы сталкиваемся с ростом трудозатрат, а значит, и стоимости разработки.

Кроссплатформенные приложения тормозят: миф или реальность?

Практически в любом споре, посвящённом преимуществам и недостаткам кроссплатформенной разработки, вы увидите аргумент о том, что кроссплатформенные приложения значительно медленнее своих нативных собратьев. Это и так, и не так. Например, код, написанный на С++ и запущенный на Android с помощью NDK, будет работать даже быстрее нативных приложений. С другой стороны, если вы используете, например, PhoneGap, приложение начинает работать по принципу “Дома, который построил Джек”: PhoneGap вызывает JS, который обращается к Java, которая запускается на Java-машине, которая работает уже на реальном телефоне. Разумеется, о быстродействии речи уже не идёт.

И что же выбрать?

Кому-то может показаться, что наша цель - убедить всех отказаться от разработки кроссплатформенных приложений. Вовсе нет: мы призываем оценить, какой подход будет оптимальным именно для вас, и не гнаться за кажущейся дешевизной кроссплатформенных решений. Единого рецепта на все случаи жизни тут не существует, каждое приложение нужно оценивать отдельно. Рассмотрим два полюса.

Популярную головоломку 2048, например, лучше разрабатывать как кроссплатформенное приложение. Разработанная на веб-технологиях, она будет запускаться везде: вы можете использовать тот же PhoneGap, чтобы запустить её на мобильных платформах, Electron - для Windows, Linux и Mac, а для сайтов, приложений ВКонтакте и Facebook даже не придётся прикладывать усилий: приложение запустится напрямую. Всё, что вам нужно, - собрать программу при помощи разных упаковщиков и создать иконку для каждой платформы. Готово, приложение не отличить от нативного!

На противоположном конце шкалы находится, например, графический редактор Sketch, снискавший завидную популярность у UX и UI дизайнеров (мы в Noveo тоже его используем!). В настоящее время он существует только для OS X, и вопрос, когда же его выпустят для других платформ, задают настолько часто, что он был даже вынесен в FAQ.

“Is Sketch available for Windows or Linux?

Due to the technologies and frameworks exclusive to OS X that Sketch has been built upon, regrettably we will not be considering supporting Sketch on either of these platforms.”

(Есть ли версии для Windows или Linux?

В связи с тем, что Sketch разработан на технологиях и фреймворках, специфичных для OS X, к сожалению, мы не рассматриваем возможность портирования на любую из этих платформ.)

Большинство приложений, конечно, лежат где-то между этими точками экстремума, так что для выбора одного из подходов потребуется тщательный анализ. Постарайтесь оценить: какой процент ваших пользователей отпугнёт, например, непривычный вид кнопок или неиспользвание верхнего меню на OS X? Будут ли это те пользователи, за счёт которых окупается ваше приложение? Много ли в приложении функциональных возможностей, которые потребуют значительных доработок для одной или нескольких платформ?

Конечно, точные результаты сможет дать только A/B тестирование, но даже поразмыслив над этим, вы много сделаете для выбора подхода к разработке.

Подведём итоги

И нативная, и кроссплатформенная разработка имеют свои достоинства и недостатки. Главные достоинства нативных приложений - быстродействие и использование всех возможностей и фишек каждой из платформ. Главный их недостаток - необходимость разрабатывать одну и ту же функциональность несколько раз.

Существует множество фреймворков и технологий кроссплатформенной разработки. Среди самых популярных можно назвать Ionic, Unity 3D, Xamarin, React Native, а также использование HTML + JavaScript.

Основные недостатки кроссплатформенной разработки - негативный пользовательский опыт и сложности при разработке функциональности. Попытки кастомизировать приложение для каждой из платформ приводят к увеличению трудозатрат, так что в некоторых случаях кроссплатформенное приложение может оказаться дороже ряда нативных при том, что будет уступать им и по возможностям, и по взаимодействию с пользователем. Также кроссплатформенные приложения нередко работают медленнее нативных.

Для того, чтобы понять, какому подходу отдать предпочтение, оцените сложность и уникальность вашего приложения. Простые решения выгоднее разрабатывать на кроссплатформенных технологиях, но чем сложнее функциональность - тем более выгодной становится нативная разработка.

Конечно, разобрать все тонкости и нюансы нативной и кроссплатформенной разработки в одной статье невозможно. Нашей целью было дать понятие об основных понятиях и сложностях, которые заключены в этом вопросе. Делитесь своим мнением и опытом в комментариях!

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter .

С чего вы начинаете своё утро? Раньше люди очень любили за завтраком почитать свежую газету, из которой узнавали о последних новостях, событиях в мире, находили объявления, читали анекдоты. Однако, светлое научно-фантастическое будущее уже наступило, и на смену газетам пришли смартфоны и планшеты, а рубрика анекдотов эволюционировала в целое приложение. Из приложений мы узнаём погоду, курс валют, новости, смотрим, где есть пробки, следим за деятельностью любимых артистов, листаем афиши и так далее. Они прочно вошли в жизнь современного человека. И современный человек частенько берётся разрабатывать их. И нередко бывает так, что он и понятия не имеет о том, что бывают нативные приложения, а бывают гибридные и web-приложения, не ведает он, как их отличить, и какой тип лучше подойдёт концепции его проекта.

О нативных и гибридных приложениях мы сегодня поговорим с Денисом Алтуховым - Android-разработчиком в Anadea.

Привет, Денис!
Привет!

Скажи, как профессионал: чем отличаются нативные приложения от гибридных?
Ну смотри: нативные создаются под конкретную платформу, будь то Android, iOS или Windows. Они пишутся на нативных языках - Java в случае Android и Objective C в случае iOS. Скачиваются исключительно из официальных магазинов.

Вроде PlayMarket?
Да, у нас это PlayMarket и AppStore для Apple. Установка и распространение ведётся через эти магазины. Открывается как отдельное приложение, имеет свои окна. Не-нативное, написанное на JavaScript - по сути, это приложение, которое открывается в браузере и там имеется какая-то мобильная вёрстка.

По сути, это web-приложение?
Да. И его преимущество в том, что оно кроссплатформенное - пишешь сразу под все платформы, Windows, Android и iPhone или что угодно откроют их. Но здесь накладывается такое ограничение, что ко многим техническим функциям, которые требует заказчик, ты не достучишься. К примеру, он хочет активную работу с камерой - в не-нативном ты этого не сделаешь. Не сделаешь и дизайн по гайдам, которые есть для iOS и Android.

В разных браузерах гибридное приложение может отображаться по-разному?
Оно может "плыть", но глобально всё будет выглядеть одинаково. Но, к примеру, если человек привык использовать Android, то он будет ожидать увидеть некоторые стандартные "андроидовские" штучки. И когда браузерное приложение свёрстано не так, как ты ожидаешь, это уже, говоря откровенно, раздражает.

Все крупные приложения в основном нативные. Почему?
Отсутствие каких бы то ни было ограничений - это основная причина. Ты можешь достучаться до любого функционала, который тебе предоставляет операционная система. Такое приложение более гибкое, намного лучше работает с батареей благодаря правильной архитектуре нативного языка. Сама операционка смотрит на твоё приложение и выстраивает правильную работу с батареей, экраном и так далее. Ту же работу с картами реализовать в гибридном приложении, не используя для этого нативные инструменты от Google и Apple, будет куда сложнее.

Сталкивался с гибридными приложениями в своей практике?
Да. Например, год назад приходил проект, который как раз работал с картами - написан на JavaScript, в особой студии с трудом запускается, сам проект ломаный. Я кое-как смог его запустить лишь на эмуляторе iPhone!

О, Господи!
И это для того, чтобы хоть что-то увидеть! И то, осознать, что там происходит, было довольно трудно. В конце концов, заказчик пришёл к тому, что вместо одного гибридного он заказал два нативных приложения - для iOS и для Android.

То есть, он просто потратил время?
Да. Но его нельзя в этом винить - гибридные приложения разрабатывать и дешевле, и быстрее по времени. Ну и выбор разработчиков куда шире - уже необязателен специалист по мобильным платформам, достаточно обратиться к фронтендеру, который адекватно владеет JavaScript. Зная синтаксис языка, он сможет выполнить заказ, но без глубокого знания платформы многое может упустить и уровень приложения будет низким.

Именно поэтому не-нативные приложения чаще низкого качества?
Да - они "вылетают" или некорректно работают, потому что кто-то пришёл со стороны. Ещё одним проблематичным аспектом "гибридов" является организация нотификаций. Может там эти сервисы как-то и работают, но, к примеру, сейчас мы работаем над социальным приложением для обмена фотографиями, и там в iOS и Android нотификации строятся совсем по-разному. Вот тебе весомое отличие. Как будут выглядеть нотификации в web-приложении на заявленных трёх платформах (iOS, Android, Windows), где у каждой свои индивидуальные особенности… да кто его знает?

А что касается безопасности?
Здесь гибридные тоже проигрывают. Apk-файл ты можешь скачать только из одного места - из магазина. Плюс у тебя есть возможность перед тем как выложить приложение стандартными инструментами всё зашифровать, скрыть реализацию и так далее. Помимо шифрования, используется ещё такая вещь, как proguard - она разбивает ссылки, стирает имена. В не-нативном ничего этого нет, а это значит, что кто угодно сможет его разобрать, украсть твой код, скачать из каких-то других мест.

То есть, сейчас гибридным приложениям до нативных ещё очень и очень далеко?
Разумеется. Смысл в них есть, если ты разрабатываешь что-то очень простенькое, обобщённое, если бюджет невысок и сроки поджимают. Что-то, что не требует всех мощностей устройства, не привязывается к "железу". Если же требуется весь функционал, то в родных операционных системах Google и Apple уже встроена целая гора методов и способов работы с камерой, картами, bluetooth и прочим. И конечно же это будет лучше и качественнее, нежели пере-изобретённый велосипед от каких-то третьих разработчиков.

Абсолютно с тобой согласен. Спасибо, что нашёл время побеседовать!
Всегда пожалуйста.

Подведём итоги нашей беседы с Денисом:

• если вам требуется высокая скорость работы и ваше приложение будет непосредственно использовать "железо" (камера, оперативная память, видеочип, bluetooth, wi-fi, экран и прочее) устройства - разрабатывайте нативное приложение;
• если вас интересует высокий уровень безопасности - разрабатывайте нативное приложение;
• если вы работаете над действительно большим проектом - разрабатывайте нативное приложение;
• если же вам нужно что-то очень простенькое и вышеперечисленные пункты вашему проекту не нужны - тогда можно обойтись и гибридным приложением.

Когда-нибудь отсутствие элементарных знаний о мобильных приложениях, наверное, станет дурным тоном. А пока поговорим о том, какие вообще бывают приложения. Заходя издалека, можно выделить всего три типа: что такое нативное приложение, веб-приложение и гибридные.

Вы знаете что такое нативное приложение?

Для пользователя нативными являются приложения, которые требуют установки. В целом, это верно, как и то, что такие приложения разрабатываются специально под мобильные платформы (iOS, Android, Windows Phone). Поэтому от разработчика требуются навыки программирования в конкретной среде разработки (xCode для iOS, eclipse для Android).

На выходе это дает приятный внешний вид и беспроблемное взаимодействие приложения с мобильной ОС. Нативное приложение также намного опережает и гибридное и веб-приложение в вопросах безопасности. Такие приложения с наименьшим поглощением ресурсов используют камеру, микрофон, акселерометр, плеер и прочие функции. Условно нативное приложение можно поделить на две группы: приложения, которым необходимо интернет-соединение, и оффлайн приложения.

Веб-приложения отличаются от нативного приложения

Пользоваться обычным сайтом на смартфоне в лучшем случае неудобно, в худшем – верстка сайта рассыпается, и работать с ним после этого вообще невозможно. Веб-приложения для того и создаются, чтобы пользоваться сайтом с телефона. Так что, по сути, это тот же сайт, оптимизированный под мобильные устройства. В отличие от нативного приложения, веб-приложения устанавливать не нужно – они работают в браузере телефона. Поэтому от модели телефона (от мобильной платформы, если быть точнее) ровным счетом ничего не зависит. Так же, вне зависимости от платформы, веб-приложения не могут работать с нативными функциями телефона.

Но что же тогда нативное приложение по сравнению с мобильным сайтом? Грань между веб-приложением и мобильным сайтом очень тонка. И в этом вопросе путаются не то что пользователи, но в некоторых случаях – и сами разработчики. А разница есть. Говоря условно, сайт содержит более или менее статичную информацию, и представляет собой нечто вроде цифровой брошюры. В веб-приложении пользователь может управлять какой-то частью этой информации – создать собственные страницы, менять местами ссылки, тексты и пр.

Так что проще веб-приложениями называть все, что принято называть онлайн-сервисами. Веб-приложением может называться еще и то, что когда-то делалось на флэше, а теперь – на HTML5.

Гибридные приложения

Гибридное приложение потому и называется гибридным, что сочетает некоторые функции что имеет нативное приложение и веб-приложение. Это кроссплатформенное приложение, которое имеет возможность работать с ПО телефона. Эти приложения также как и нативные загружаются из магазина приложений, но данные обновляют автономно. Поэтому им всегда нужно подключение к интернету – без него веб функции не работают.

Что выбрать? нативное приложение, гибридное или веб?

Разработка гибридного приложения дешевле и быстрее, чем создать нативное приложение. А пользователи разницы все равно не заметят. Поэтому гибридные технологии наиболее популярны. Несмотря на всю эту многосложность определиться с выбором технологии для разработки приложения очень просто. Если ваше приложение никак не может работать без нативных функций мобильных устройств, если очень важна высокая скорость обработки данных (игры, соцсети, геолокация), то лучше чем нативное приложение ничего не найти. Когда скоростью работы можно пренебречь, подойдет гибридное приложение. Веб-приложение стоит делать, когда пользователю от вас не нужно ничего, кроме информации, которую он мог бы получить с телефона при наличии интернета.

Смартфоны продолжают отвоевывать все больше места под солнцем не только как инструмент потребления фотографий котиков и ххх-роликов, но и в качестве рабочего инструмента. Поэтому и спрос на мобильную разработку растет. Принято считать, что тру и кул - это Objective-C/Swift для iOS и Java/Kotlin для Android. Спору нет, тру и кул, но существует большое количество реальных сценариев, в которых использование кросс-платформенных фреймворков более предпочтительно в сравнении с нативными инструментами.

Одни разработчики ждут от кросс-платформенных фреймворков решения всех своих жизненных проблем, другие же воспринимают их в штыки. В обоих «враждующих лагерях» есть свои заблуждения, вызванные непониманием того, как и что работает. Это подливает масла в огонь, так как вместо технических доводов в ход идут эмоции.

Также среди разработчиков, особенно начинающих, существует множество мифов о кросс-платформенных мобильных фреймворках. В нашей статье мы разберем самые популярные из них. Но для начала посмотрим на мобильную разработку глазами бизнеса, дающего деньги на весь айтишный блек-джек.

Зачем нужны кросс-платформенные инструменты?

Исторически на рынке компьютеров всегда была конкуренция, и каждый производитель предоставлял оптимальный набор так называемых нативных (родных) инструментов для разработки приложений под свои операционные системы и устройства.

Нативные инструменты = предоставляются владельцем экосистемы.

Все остальные признаки «нативности» ВТОРИЧНЫ - поведение и интерфейс приложений, доступ к возможностям ОС, производительность и прочее.

К тому же практически всегда оказывалось, что нативные инструменты несовместимы друг с другом не только на уровне языков разработки, принятых соглашений и архитектур, но и на уровне механизмов работы с операционной системой и библиотеками. В результате для реализации одних и тех же алгоритмов и интерфейсов требовалось написать приложение для нескольких сред на разных языках программирования, а потом его поддерживать из расчета «одна команда на платформу». При этом возможности и внешний вид приложений на разных платформах практически всегда идентичны на 90%. Сравни ради интереса реализацию любимых программ для iOS и Android.

Второй важный момент - наличие необходимых знаний и опыта внутри команды: если их нет, то потребуется время на обучение.

Для того чтобы решить обе эти проблемы, на рынке уже давно появились инструменты кросс-платформенной разработки (не только mobile), предлагающие:

• максимизировать общую базу кода на едином языке программирования, чтобы продукт было проще разрабатывать и поддерживать;
• использовать существующие компетенции и специалистов для реализации приложений на новых платформах.

Так как языков программирования (и сред) сейчас наплодилось очень много (и специалистов, владеющих этими языками), то и инструментов для кросс-платформенной разработки существует изрядное количество. Мы в качестве примера остановимся на популярных в наших краях PhoneGap, Xamarin, React Native и Qt .

Теперь можно поговорить и о мифах.

Миф 1. Магия

Самый частый миф, будоражащий умы начинающих девелоперов, связан с верой в сверхалгоритмы (и сверхпрограммистов, их создавших), которые волшебным образом превращают кросс-платформенные приложения в нативные. Что-то в духе «преобразования кода JavaScript в Swift и дальнейшая компиляция уже Swift-приложения». Этот миф подогревают и сами разработчики кросс-платформенных инструментов, обещая на выходе создание «нативных приложений». И не то чтобы кто-то здесь лукавил, но богатая фантазия и непонимание базовых механизмов иногда наводят разработчиков на мысли о шаманских приемах.

Главный принцип, лежащий в основе кросс-платформенных решений, - разделение кода на две части:

• кросс-платформенную , живущую в виртуальном окружении и имеющую ограниченный доступ к возможностям целевой платформы через специальный мост;
• нативную , которая обеспечивает инициализацию приложения, управление жизненным циклом ключевых объектов и имеет полный доступ к системным API.

Для того чтобы связывать между собой мир «нативный» и мир «кросс-платформенный», необходимо использовать специальный мост (bridge) , именно он и определяет возможности и ограничения кросс-платформенных фреймворков.

При использовании bridge производительность всегда снижается за счет преобразования данных между «мирами», а также конвертации вызовов API и библиотек.

Итак, все кросс-платформенные приложения обязаны иметь нативную часть, иначе операционная система просто не сможет их запустить. Поэтому давай рассмотрим подробнее, какие системные API и механизмы предоставляются самими iOS, Android и Windows. Переходим к следующему мифу.

Миф 2. Ненативно!

Итак, у нас есть кросс-платформенная часть приложения, живущая в виртуальном окружении и взаимодействующая с операционной системой через инфраструктуру фреймворка и мост.

Все операционные системы: iOS, Android и Windows UWP - предоставляют доступ к следующим подсистемам (наборы системных API):

• WebView (встроенный в приложение веб-браузер) используется в гибридных приложениях на базе PhoneGap и фактически выступает средой выполнения локального веб-сайта;
• JavaScript-движки используются в React Native и аналогах для быстрого выполнения JS-кода и обмена данными между Native и JS;
• OpenGL ES (или DirectX) используется в игровых движках и приложениях на Qt/QML или аналогах для отрисовки интерфейса;
• UI-подсистема отвечает за нативный пользовательский интерфейс приложения, что актуально для React Native и Xamarin.

Кросс-платформенные приложения имеют нативную часть и такой же полный доступ к системным API, что и «нативные» приложения. Разница в том, что вызов системного метода идет через мост и инфраструктуру фреймворка:

WebView - приложение живет в своем веб-браузере по аналогии с одностраничным веб-сайтом. Нет доступа к нативным контролам (кнопки, списки и прочее), все основано на HTML/CSS/JavaScript. С другой стороны, веб-разработчик почувствует себя как рыба в воде.

JavaScript-движки стали популярны относительно недавно, так как в iOS подобный механизм был добавлен только в версии 7.0. Из особенностей стоит учитывать необходимость сериализации в JSON сложных структур данных, передаваемых между средами JavaScript и Native. Если коротко описать подобный класс решений, то в JavaScript-среде выполняется JS-код, управляющий нативным приложением.

OpenGL ES и DirectX являются подсистемами низкого уровня и используются для отрисовки пользовательского интерфейса в играх и, например, Qt/QML. То есть при использовании OpenGL/DirectX разработчики сами рисуют контролы и анимации, которые могут быть лишь похожи на нативные. С другой стороны, это подсистема низкого уровня с очень высокой производительностью, поэтому она используется и в кросс-платформенных игровых движках.

Все кросс-платформенные приложения имеют нативную часть, а следовательно, потенциально такой же полный доступ к системным API, что и «нативные». Также кросс-платформенные приложения собираются и упаковываются «нативными» инструментами в «нативные» установочные пакеты. Ключевой вопрос - как организовано взаимодействие между кросс-платформенной частью и нативной. Например, внутри WebView или с помощью Open GL ES / DirectX нет возможности создать пользовательский интерфейс с полностью нативным look’n’feel, но при этом есть полный доступ к GPS, Push-уведомлениям и другой функциональности. А код на JavaScript или C# вполне свободно может управлять нативным приложением и его поведением, обеспечивая полностью нативный look’n’feel.

Если резюмировать - то да, «ненативно» с точки зрения используемых инструментов разработки (не от Apple, Google). Но приложение может быть полностью нативным с точки зрения доступа к системным API и обеспечивать полностью нативный внешний вид и поведение. А мы движемся к следующему мифу.

Миф 3. Костыль на костыле

Здесь стоит понимать, что нативные API по умолчанию костылями не считаются (хотя и здесь есть разные мнения), поэтому все негодование направлено на кросс-платформенную часть. Очевидно, что исполняющую среду (например, WebView, JavaScript-движок или Mono) костылем тоже назвать сложно - взрослые зрелые решения с длительной историей.

Похоже, что костылем называют то, как кросс-платформенная часть интегрируется с нативной. Чтобы лучше понять, как работают различные фреймворки, мы на примере PhoneGap, Xamarin, Qt и React Native рассмотрим те механизмы операционных систем, которые используются для связывания кросс-платформенной и «нативной» частей.

Начнем мы с PhoneGap. Ниже представлена верхнеуровневая архитектура приложения на базе этого фреймворка.

Приложение на PhoneGap - это по факту нативное приложение, которое в качестве единственного UI-контрола отображает WebView. Именно через него и идет взаимодействие с нативной частью. Все стандартные WebView в iOS, Android и Windows UWP поддерживают возможность добавить свои нативные обработчики для JS-свойств и методов. При этом JS-код живет в своей изолированной среде и ничего не знает о нативной части - просто дергает нужные JS-методы или меняет нужные JS-свойства. Все внутри стандартного вебовского DOM, в который просто добавляются новые элементы, связанные с нативной реализацией.

При создании приложений на React Native разработчику практически всегда будет необходимо реализовывать нативную часть на Objective-C, Java или C#, а само управление нативным приложением будет идти из JavaScript. По факту JavaScript-движок - это элемент WebView, который доступен отдельно. Взаимодействие идет через такой же JS-мост, как и в случае с PhoneGap. Однако в React Native JS-код управляет не вебовским DOM-деревом, а нативным приложением.

Необходимо учитывать, что из-за ограничений iOS (нет возможности реализовать JIT) код JavaScript на лету интерпретируется, а не компилируется. В целом это не особо сказывается на производительности в реальных приложениях, но помнить об этом стоит.

Теперь рассмотрим классический Xamarin.iOS и Xamarin.Android, так как Xamarin.Forms (поддерживающий Windows UWP) - это надстройка над ними.

Xamarin использует библиотеку Mono для взаимодействия с целевой операционной системой, которая позволяет вызывать нативный код с помощью механизма P/Invoke . Он же задействуется и для общения с нативными API в iOS/Android. То есть для всех публичных нативных API-методов создаются обертки на C#, которые, в свою очередь, вызывают системные API. Таким образом, из Xamarin-приложения можно обращаться ко всем системным API.

И в завершение рассмотрим Qt, так как о нем появляется много вопросов от опытных разработчиков.

Qt - «вещь в себе», в этом есть и плюсы, и ограничения. Библиотеки Qt просто подключаются к системным API на C++, которые есть во всех операционных системах. Для отрисовки пользовательского интерфейса используются механизмы низкого уровня, но свой графический движок, поддерживающий стилизации «под нативку». При этом на Android приходится обращаться к Java API через специальный мост (JNI bridge), а для Windows UWP использовать конвертер вызовов Open GL ES в DirectX, так как Open GL недоступен для UWP.

Подведем итог: все кросс-платформенные фреймворки используют стандартные нативные возможности операционных систем, являются зрелыми, создаются опытными командами и сообществом open source при поддержке гигантов IT-индустрии. И наконец, пришло время для самого «сильного» аргумента.

Миф 4. Медленно

Важный козырь, которым любят пользоваться в спорах о кросс-платформенных фреймворках, - низкая производительность. Опять же, смотря что с чем сравнивать и в каких попугаях считать.

Напомним, что особенность кросс-платформенных приложений заключается в параллельном существовании двух миров, связанных мостом:

• PhoneGap: HTML/JS и Native Java / Objective-C / C#;
• React Native: JS и Native Java / Objective-C / C#;
• Xamarin: Mono и Native Java / Objective-C;
• Qt: С++ и Native Java / Objective-C.

Таким образом, при сравнении производительности надо учитывать скорость работы:

• кросс-платформенной части;
• нативной части;
• моста.

Если набрать в поисковике, например, react native vs swift performance, то можно посмотреть множество различных тестов, и во многих из них отмечается, что производительность резко падает при активном использовании моста, включая активное манипулирование UI из кросс-платформенного кода. Для Xamarin ситуация выглядит таким же образом - кросс-платформенная часть очень быстра и сопоставима с нативной в обработке данных, однако при использовании моста может падать производительность. Qt вообще работает на уровне С++, который быстр сам по себе. Если же рассматривать решения на базе PhoneGap, то здесь производительность будет сильно зависеть от WebView, но все же не следует активно менять UI в JavaScript-коде или проводить научные вычисления.

Медленно? Да, возможны падения производительности при неумелом взаимодействии с операционной системой через мост. Однако сами по себе кросс-платформенные миры такие же быстрые, как и нативные.

Под нативной (родной) разработкой подразумевается использование оригинальных языков и инструментов разработки мобильной операционной системы. Приложения для iOS создаются в среде разработки XCode на языках Objective-C, Swift, C и С++. Для создания приложений под Android используется среда Android Studio и язык Java. Каждая среда разработки содержит целый комплекс утилит для написания кода, проектирования интерфейса, отладки, профилирования (мониторинга) и сборки приложений. И среда, и соответствующий набор утилит созданы специально под каждую мобильную операционную систему и являются максимально удобными и мощными средствами разработки мобильных приложений.

Кроссплатформенная разработка подразумевает использование специальных утилит (фреймворков) для создания приложения на основе семейства языков JavaScript. Вся структура и логика приложения создается с помощью таких инструментов (PhoneGap, Titanium, Xamarin, Cordova и др.) на JavaScript, а затем оборачивается в нативный запускающий элемент, т.е. интегрируется в базовый проект для XCode или Android Studio. Что позволяет создавать сборки проекта с одной и той же логикой под несколько операционных систем сразу.

Ближайшая аналогия в случае с персональными компьютерами. MS Word, Skype, почтовые агенты, календари – это нативно разработанные приложения под настольную операционную систему. Все, что происходит в браузере (сайты, онлайн-редакторы текста и графики, социальные сети, чаты, форумы) – кроссплатформенные технологии.

Плюсы кроссплатформенной разработки

Кроссплатформенный подход к разработке имеет следующие положительные моменты:

1. Требуется меньше ресурсов для реализации приложения сразу под несколько платформ. В этом, собственно, и суть кроссплатформенного подхода – один и тот же код работает и на iOS, и на Android. Программистов, занимающихся проектом, нужно ровно в два раза меньше. Дизайнер делает только один набор графики. Все это снижает количество рабочих часов и бюджет проекта.
   ⋅
2. Меньшее время на разработку. За счет отсутствия уникальных элементов интерфейса и более простых технологий, время на создание простых продуктов, как правило, меньше.
   ⋅
3. Упрощенный цикл обновления продукта. Если в проект нужно что-то добавить или исправить какую-то ошибку, это делается сразу для всех платформ, на которые распространяется проект.
   ⋅
4. Возможность использования мобильной версии сайта. Большинство кроссплатформенных решений используют семейство JavaScript языков. Поэтому если у вас уже есть мобильная версия сайта, значительная часть кода и материалов может быть использована в приложении без изменений.
   ⋅
5. Использование единой логики приложения. Логика, заложенная в работу приложения, будет работать гарантированно одинаково для всех платформ. Довольно часто это может являться и минусом из-за разной архитектуры операционных систем. Яркий пример – кнопка “Назад” в навигации между экранами. В Android предусмотрена аппаратная кнопка Back для этих целей. У iOS – движение пальцем от левой части экрана или же наличие кнопки в левой части навигационной панели. Если кнопку не делать вовсе, пользователи iOS не смогут вернуться назад. Если сделать, но не на том месте и выглядящую нестандартно, пользователям iOS будет непривычно и неудобно; а если сделать как в iOS, будет непривычно пользователям Android. Однако написанная и отлаженная один раз логика содержит потенциально меньшее количество ошибок и расхождений в своей работе. Поэтому вам не придется проделывать двойную и тройную работу по поиску проблем на каждой платформе.

Плюсы нативной разработки

Разработка на родных технологиях и языках под iOS и Android имеет следующие положительные моменты:

1. Скорость работы приложения.

Так как приложение создается с использованием оригинальных инструментов разработки (XCode, Android Studio), получаемый в результате компиляции проекта код является оптимальным для данной платформы. Приложение получает полную аппаратную поддержку устройства (обработка тех же изображений осуществляется отдельным процессором, специально для этого предназначенным – GPU), используется многопоточность для реализации сложных задач и загрузки контента в фоне. В процессе разработки программисты могут измерять скорость работы всех участков кода и при необходимости их оптимизировать. В их распоряжении также есть инструменты по мониторингу использования оперативной памяти, поиску возможных утечек и т.д.

2. Гибкость в реализации.

В отличие от ограничений в построении интерфейса и сложности визуальных эффектов, накладываемых фреймворками для кроссплатформенной сборки проектов, в нативной разработке реализовать можно все, на что способны технологии той или иной мобильной операционной системы.

3. Использование последних технологий и зависимость от кроссплатформенных фреймворков.

Новый программный и аппаратный функционал, предоставленный компаниями-производителями устройства и операционной системы, становится доступен для реализации сразу после выпуска соответствующих обновлений. К примеру, в iOS 9 заложена возможность поиска внутри приложений. В каждом из них должен быть реализован специальный метод, который возвращает результаты по определенному поисковому запросу. В результате для тех приложений, в которых этот функционал реализован, доступна возможность поиска контента через системный раздел поиска в iOS. Там же, где осуществляется поиск приложений, контактов, событий и прочей информации. В случае с кроссплатформенной разработкой для реализации подобного функционала придется ждать не только релиза iOS 9, но и обновления соответствующего фреймворка, причем когда появится поддержка тех или иных новых возможностей и появится ли вообще, предсказать невозможно.

⋅ 4. Легкость и качество тестирования.

Помимо упомянутого в п. 1 инструментария для контроля использования приложением аппаратных ресурсов устройства в распоряжении разработчиков и тестировщиков есть целых комплекс технологий. Во-первых, все параметры системы в процессе работы приложения контролируются автоматически. Если приложение стало использовать больше памяти, чем это ожидается, или больше ресурсов центрального процессора, это не останется незамеченным. Во-вторых, возможности в широком применении юнит-тестов – автоматического тестирования практически каждого метода в приложении. Если какая-то часть приложения перестала работать корректно вследствие каких-либо изменений кода, новая версия просто не соберется, а программист сразу увидит причину. В-третьих, доступны широкие возможности в интеграции систем удаленного мониторинга ошибок. В каждый нативный проект встраивается соответствующий функционал, который позволяет увидеть ошибку и ее причину, возникшую на устройстве любого пользователя.

5. Полная поддержка со стороны магазинов приложений App Store и Google Play.

Обе компании заинтересованы, чтобы пользователи получали максимально положительный опыт при использовании приложений на соответствующих платформах, который возможен на текущий момент. Это означает, что приложение должно выглядеть максимально качественно (если у экрана высокое разрешение, а изображения расплывчаты, в App Store приложение просто не пропустят), работать настолько быстро, насколько это возможно (если приложение отображает небольшой список элементов за 20-30 секунд, его так же не пропустят), и вообще все должно быть красиво и удобно. Если какие-то из этих параметров слишком низки или вообще не выполнены, приложение не пропустят в магазин. Если же они не на высоте, чего добиться с кроссплатформенными технологиями крайне сложно, а часто и невозможно в принципе, ваше приложение никогда не будет рассмотрено соответствующими компаниями для размещения в специальных рекламных разделах (Featured). Среди приложений, находящихся во Featured-разделах и App Store, и Google Play, нет ни одного, сделанного с помощью кроссплатформенных технологий. За исключением игровых проектов, в которых интерфейс не является системным.

Выводы

С технической точки зрения и с точки зрения качества создаваемого интерфейса нативная разработка имеет гораздо больше плюсов. Однако есть сферы, в которых кроссплатформенные технологии являются оправданными: это игровой сектор и тестовые проекты.

Современные игры пишутся в подавляющем большинстве на кроссплатформенных технологиях. Это сильно ускоряет разработку без ущерба для качества, т.к. в этом случае используются специальные графические фреймворки (самый популярный – Unity 3D). Если какой-то проект нужно сделать быстро для проведения каких-либо тестов, при этом ситуация требует работы проекта именно на нескольких платформах одновременно, кроссплатформенная реализация может быть оптимальным решением.

Если проект не является игровым, направлен на долгосрочное развитие и требует положительного впечатления от пользователей, нативная разработка остается более подходящим вариантом.