Как называется руководство для разработчиков ios

Кратко о главном

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

Зачастую при первом погружении в эту систему у начинающих (и не только) разработчиков возникают серьезные проблемы с пониманием того, как функционирует Apple Developer Center (будем называть его «девцентр» для простоты). В результате, мне в процессе профессиональной деятельности не раз приходилось наблюдать на новых местах работы огромные свалки из профилей и сертификатов в девцентре, в результате чего приходилось приступать к «разбору завалов».

При этом, в сети довольно не такой большой выбор материалов на эту тему. Конечно, в официальной документации Apple все хорошо структурировано и очень подробно описано, но зачастую просто не хватает времени на изучение такого количества материала. Как правило, хочется быстро понять, что именно и в каком порядке нужно сделать для корректной работы приложения на этапах разработки, тестирования и при публикации его в магазин App Store. В русском же сообществе подобных материалов, собранных в одном месте и в удобном доступе, я не видел вовсе, поэтому и решил написать эту статью. Для всех интересующихся — добро пожаловать под кат.

Что мы будем разбирать?

Мы разберем процесс управления вашим приложением в Apple Developer Center от его создания до публикации в магазине App Store. Мы будем говорить только о базовых вещах, таких, как разработка, тестирование и публикация, а также обсудим APNs (Push Notifications).

Отмечу тот факт, что далее я буду описывать принцип работы девцентра по состоянию на 31 марта 2016 года, поэтому если вы читаете эту статью позднее — все уже могло измениться.

Что нам понадобится?

Собственно, для работы нам нужно следующее:

• Рабочий Mac, либо PC с виртуальной машиной и установленной на ней Mac OS.
• Действующий Apple ID. Его всегда можно бесплатно зарегистрировать на официальном сайте компании Apple.
• На вашем Apple ID (либо у одной из компаний, которая добавила ваш Apple ID в свою команду) должна быть активирована так называемая Apple Developer Program — оплачиваемая раз в год «подписка», дающая вам доступ к Apple Developer Center и возможность публиковать ваши приложения в App Store. На текущий момент стоимость в пересчете на год невелика и составляет в районе $99 за год пользования.
• И, конечно же, навыки разработки под iOS.

Ориентировка по разделам

В девцентре для полноценной работы с вашими приложениями нам понадобятся только два пункта:

• Certificates, Identifiers & Profiles. Раздел обеспечивает управление всей системой сертификации ваших приложений. Работу именно с этим разделом мы и будем разбирать в данной статье.
• iTunes Connect. Дает доступ к внутреннему и внешнему тестированию через TestFlight, а также к управлению публикацией ваших приложений в App Store.

Терминология

Давайте подробно разберем понятия, лежащие в основе функционирования девцентра Apple.

Сертификаты (Certificates)

Этот раздел дает доступ к управлению сертификатами, которыми обладает ваша учетная запись Apple ID. Каждый из этапов, которые вы будете проходить, будь то разработка, тестирование или публикация, включая все значимые составляющие экосистемы Apple вроде Push Notifications, требует обязательного наличия актуального (действующего, Active) сертификата. Говоря проще, ваше приложение не сможет даже чихнуть, не имея на то разрешения из Apple Developer Center. Чуть подробнее о подразделах:

• Pending. Запрошенные вами сертификаты, находящиеся в процессе обработки от Apple. Для дев (Development) и прод (Production) сертификатов конкретно в моем случае этот подраздел чаще всего пустует.
• Development. Дев-сертификаты, обеспечивающие возможность отладки вашего приложения на конкретных девайсах (одном либо нескольких) через Xcode, а также создание дев-сборок «в отладочном режиме». Более подробно поговорим о них чуть ниже.
• Production. Прод-сертификаты, обеспечивающие работоспособность приложения при тестировании в TestFlight и при публикации в магазине App Store.

Сертификаты типа «Development»

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

• Создать отдельный дев-сертификат конкретно для вашего Mac, скачать и установить его. Плюс понадобится сгенерировать и установить на свой Mac девелоперский профиль на основе этого сертификата, но об этом позже.
• Либо экспортировать с машины, на которую заведен сертификат, файл *.p12/*.pfx (это можно сделать в связке ключей Apple). Такой файл защищается паролем при экспорте, и, зная этот пароль, информацию о сертификате можно будет импортировать на любом другом Mac. В этом случае отпадает необходимость создавать для каждого Mac отдельные Development-сертификаты и отдельные Development-профили. Небольшая оговорка: профиль хоть и должен быть сгенерирован для той машины, на которую выпущен экспортируемый сертификат, но в этот профиль понадобится добавить UDID вашего устройства прежде, чем выдавать профиль вам для установки, иначе ничего работать не будет.

Наличие дев-сертификата означает, что, скачав его и установив двойным кликом в Связку Ключей (Apple Keychain), вы сможете запускать ваше приложение напрямую через Xcode в режиме отладки на устройстве, подключив это устройство проводом к вашему Mac. Перечень разрешенных конкретных устройств Apple нужно будет обязательно указать при генерации девелоперского профиля, но об этом позже. Также, вы сможете собрать и экспортировать сборку с дев-профилем, но стоит учесть, что в этом случае ваше приложение не будет иметь доступа к продакшн-возможностям (APNs будет только в режиме sandbox, например).

Сертификаты типа «Production»

Для начала на всякий случай поясню, что сборкой iOS-приложения называют *.ipa-файл, архив, выпускаемый с соблюдением правил сертификации Apple через команду Project — Archive в Xcode.

Теперь о сертификации. Прод-сертификаты обеспечивают функционирование различных подсистем приложения в «боевых» условиях, то есть в магазине App Store, а также на устройствах, где выполняется внутреннее и внешнее тестирование приложения через TestFlight. Здесь, по аналогии с Development-сертификацией, есть тип App Store & Ad Hoc Production, а также тип APNs Production, использующийся веб-сервером для рассылки push-уведомлений. Если вы планируете выпустить приложение, поддерживающее работу с пушами, то вам понадобятся оба сертификата, как App Store & Ad Hoc (на основе которого вы сделаете сборку и отправите приложение в iTunes Connect), так и APNs Production (его вы отдадите серверу, а тот воспользуется им для получения прав на рассылку пушей). В довесок к уже упомянутым подсистемам есть еще несколько других, обеспечивающих доступ к Wallet, Apple Watch и так далее, но их обзор выходит за рамки данной статьи.

Очень часто возникает вопрос о том, в чем же разница между App Store и тем самым Ad Hoc. Ранее они были представлены разными сертификатами, с некоторого времени Apple объединила их в единое целое, за что им большое спасибо. Чуть подробнее об этих разновидностях:

• Выпуск сборок типа App Store. Обеспечивает возможность тестировать приложение в TestFlight, как в режиме внутреннего, так и в режиме внешнего тестирования. Также дает возможность опубликовать приложение в App Store.
• Выпуск сборок типа Ad Hoc. Термин «Ad Hoc» можно перевести как «специальный», «для конкретной цели». Такой тип сертификации обеспечивает возможность запускать ваше приложение (включая все нужные подсистемы типа APNs) в боевых условиях, но только на конкретных девайсах, и без участия Xcode в процессе запуска. Другими словами, Ad Hoc необходим, если вы захотите поставить ваше приложение на стороннее устройство, не имея к нему прямого доступа (то есть не подсоединяя его проводом к вашему Mac, так как в этом случае вам бы хватило Development-сертификата), но при этом и не выкладывая приложение в iTunes Connect. Такой сертификат используется при создании специального Ad Hoc-профиля, о котором пойдет речь чуть позже.

Intermediate Certificates

Некоторое время назад Apple внесла изменения в логику работы девцентра и своей системы сертификации, после чего на большинстве компьютеров пропала возможность делать сборки приложений, несмотря на наличие активных дев- и прод-сертификатов и актуальных профилей. Причина этого была в том, что Apple добавила дополнительное требование, чтобы на вашем Mac в связке ключей был установлен специальный сертификат под названием «Worldwide Developer Relations Certificate Authority». Он устанавливается автоматически с новыми версиями Xcode, но те, у кого Xcode уже был установлен ранее, просто должны были установить этот сертификат вручную, скачав его по прямой ссылке из секции Intermediate Certificates в девцентре Apple, после чего проблемы со сборками исчезали. Больше никакой смысловой нагрузки этот сертификат не несет.

Идентификаторы (Identifiers)

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

В буквальном переводе «App ID» означает «идентификатор приложения», что полностью отражает его суть. Любое ваше приложение, которое вы хотите отлаживать на устройстве Apple, тестировать через TestFlight и/или публиковать в магазин App Store, должно обладать собственным уникальным именем, по которому его можно однозначно идентифицировать среди тысяч других приложений. При добавлении нового App ID вам будет предложено ввести несколько элементов:

• App ID Description. Имя вашего приложения. К примеру, если ваше приложение называется Mail Printer, то прямо так его и записываем в это текстовое поле.
• App ID Prefix. Префикс вашего приложения, он выдается вам автоматически и будет общим для конкретной команды Apple Team, где подключена и активна Apple Developer Program.
• App ID Suffix. Здесь нам понадобится выбрать Explicit App ID, чтобы указать бандл (bundle) приложения. Это идентификатор, обычно имеющий вид com.mycompany.myappname, где mycompany — имя вашей компании или вашего домена. Например, com.homecompany.MailPrinter. Обращаю ваше внимание, что точно такой же бандл должен быть выставлен в настройках таргета (Target) вашего приложения в Xcode (секция настроек General, поле Bundle Identifier).
• App Services. Здесь вам нужно отметить те сервисы, которые вы планируете использовать в вашем приложении. По умолчанию там отмечены только Game Center и In-App Purchase, их использование обязательно, удалить их нельзя. Остальные сервисы подключайте по мере необходимости.

Устройства (Devices)

В этом разделе размещено управление всеми устройствами Apple, которые вы можете использовать в рамках вашей Apple Developer Program. Есть ограничение, максимум 100 зарегистрированных девайсов одного типа (iPhone, iPad и так далее) на одну учетную запись в год, обычно этого более чем достаточно. При необходимости отладки на устройстве или выпуска Ad Hoc-сборки просто добавляйте сюда UDID нужных вам девайсов и используйте их при генерации профилей.

Профили (Provisioning Profiles)

Дословно название этого раздела переводится как «Профили обеспечения». Чуть более развернуто я бы описал понятие «профиль» как «Специальный файл, обеспечивающий доступ к некоторой функциональности в конкретной сборке вашего приложения». В данном разделе девцентра вы можете управлять вашими профилями, обеспечивая себе возможность выпускать сборки приложения для различных целей, то есть «профилировать» его. По сути, профиль является результатом объединения двух (иногда трех) компонентов:

• Активного сертификата определенного типа (раздел Certificates). С помощью сертификата профиль подтверждает, что ваше приложение имеет право на выполнение определенной группы действий.
• App ID (раздел Identities). Определяет конкретное приложение, для которого выпускается профиль.
• В некоторых случаях, еще нужен список зарегистрированных устройств (раздел Devices). Определяет перечень устройств, на которые разрешено устанавливать вашу сборку. Используется только с некоторыми типами профилей.

Профили типа «Development»

Это профиль для разработки, то есть его основное назначение — отладка вашего приложения на конкретных устройствах через Xcode с прямым подключением устройства проводом к вашему Mac. Дев-профили представлены двумя видами:

• iOS App Development. Требует указания перечня разрешенных устройств из раздела Devices.
  Используется для отладки iOS-приложений.
• tvOS App Development. Аналогично, только используется для tvOS-приложений.

Профили типа «Distribution»

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

• App Store. Используется для тестирования (как внутреннего, так и внешнего) в TestFlight, а также для выпуска приложения в App Store.
• tvOS App Store. Аналогично предыдущему, только для tvOS.
• Ad Hoc. Требует указания перечня разрешенных устройств из раздела Devices.
  Используется, если вы хотите выпустить сборку, которую можно будет поставить в режиме «Production», но только на некоторых устройствах. Реальная ситуация, когда это может понадобится, например, следующая. Вы разрабатываете приложение, а в процессе работы заказчик попросил у вас «дать ему пощупать приложение» на своем Apple-устройстве. В iTunes Connect для активации внешнего тестирования вы еще выходить не готовы, но просьбу заказчика нужно выполнять — вот тут как раз и пригодится Ad Hoc-профиль, сгенерированный на базе прод-сертификата App Store & Ad Hoc Production Certificate. Важный момент: в моем случае часто возникали проблемы при экспорте сборок подобным способом, если в Xcode не был также установлен и Development-сертификат. Ошибки были разного рода, от невозможности подписать сборку до абсурдного «App ID is not available», хотя это фактически не так (замена на другой бандл ничего не давала). Поэтому, по моему предположению, для удачного экспорта Ad Hoc-сборок необходимо, чтобы, помимо Ad Hoc-профиля, был также установлен и дев-сертификат с соответствующим профилем.
• tvOS Ad Hoc. Аналогично предыдущему, только для tvOS.

Вкратце об iTunes Connect

Этот сервис предоставляет вам возможность управлять внутренним и внешним тестированием в TestFlight, а также выкладывать приложение в App Store. Рассмотрение этого процесса выходит за рамки данной статьи, упомяну лишь тот факт, что для корректной работы этому сервису необходимы сборки, созданные на базе профиля типа Distribution — App Store (для iOS либо tvOS). Другие типы профилей здесь не поддерживаются.

Резюмируем

По сути, при получении доступа к девцентру с активной Apple Developer Program ваш алгоритм действий должен сводиться к следующему:

1. Определиться, с каких конкретно машин будет производиться прямая отладка на устройствах через Xcode. Определить среди них основную машину (это может быть Mac разработчика, с которого чаще всего планируется производить отладку). Сгенерировать для основного Mac сертификаты группы Development, скачать и установить их. По необходимости, экспортировать информацию об этих сертификатах в файлы *.p12/*.pfx, которые потом можно будет разослать на другие целевые машины, где также планируется проводить отладку приложений.
2. Узнать, с какой машины планируется собирать сборки для тестирования и/или публикации в App Store. Сгенерировать для нее сертификат группы Distribution. Повторить процедуру с экспортом из предыдущего пункта, если требуется поддержка нескольких машин.
3. Проконтролировать наличие нужного идентификатора приложения в разделе App IDs и соответствие указанного там бандла значению поля Bundle Identifier в проекте в Xcode, при наличии несовпадения — устранить его либо в девцентре, либо в Xcode (где именно это править — зависит от вашей конкретной ситуации).
4. Убрать (Revoke/Delete) все сертификаты, а затем и профили, которые обладают пометкой Expired (истекший сертификат) или Invalid (некорректный профиль). Также отмечу, что, в отличие от сертификатов, профили можно редактировать. То есть, сгенерировав новые сертификаты, вместо удаления старых профилей вы можете просто отредактировать их, указав им новые сертификаты в качестве подписи.
5. Если профилей нет, либо не хватает нужных, то сгенерировать необходимые профили.
6. Скачать и установить нужные для вашей машины сертификаты и профили на свой компьютер. Установка производится двойным кликом на файле. Сертификаты будут установлены в Связку Ключей (Apple Keychain), профили — в Xcode.
7. Указать в настройках проекта Xcode нужные вам сертификаты в секции Build Settings — Code Signing Identity — Development/Distribution, а также указать необходимый Provisioning Profile.

• Произвести запуск в режиме отладки (Project — Run) через Xcode на разрешенном устройстве, используя дев-профиль.
• Создать сборку (Project — Archive с выбранным целевым устройством Generic iOS Device) на базе продакшн-профиля Ad Hoc для установки на конкретные устройства (такую сборку можно будет выслать, например, по электронной почте заказчику, чтобы он установил ее на свое разрешенное устройство).
• Создать сборку аналогично предыдущему пункту, но на базе продакшн-профиля App Store. Это будет сборка для внутреннего и/или внешнего тестирования, а также для выкладки в App Store, которую можно использовать в iTunes Connect.

• ios
• ios development
• ios разработка
• ios programming
• ios sdk
• xcode
• apple
• apple store
• app store
• app store program development
• apple developer program
• apple developer center
• apple development
• objective-c

• Разработка под iOS
• Objective C
• Xcode

Основы

Swift — новый язык программирования для разработки приложений под iOS, macOS, watchOS и tvOS. Несмотря на это, многие части Swift могут быть вам знакомы из вашего опыта разработки на C и Objective-C.

Swift предоставляет свои собственные версии фундаментальных типов C и Objective-C, включая Int для целых чисел, Double и Float для значений с плавающей точкой, Bool для булевых значений, String для текста. Swift также предоставляет мощные версии трех основных типов коллекций, Array , Set и Dictionary , как описано в разделе Типы коллекций.

Подобно C, Swift использует переменные для хранения и обращения к значениям по уникальному имени. Swift также широко использует переменные, значения которых не могут быть изменены. Они известны как константы, и являются гораздо более мощными, чем константы в C. Константы используются в Swift повсеместно, чтобы сделать код безопаснее и чище в случаях, когда вы работаете со значениями, которые не должны меняться.

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

Swift также включает опциональные типы, которые позволяют работать с отсутствующими значениями. Опциональные значения говорят либо «здесь есть значение, и оно равно х», либо «здесь нет значения вообще». Опциональные типы подобны использованию nil с указателями в Objective-C, но они работают со всеми типами, не только с классами. Опциональные значения безопаснее и выразительнее чем nil указатели в Objective-C, и находятся в сердце многих наиболее мощных особенностей Swift.

Swift — язык типобезопасный, что означает, что Swift помогает вам понять, с какими типами значений ваш код может работать. Если кусок вашего кода ожидает String , безопасность типов не даст вам передать ему Int по ошибке. Кроме того, безопасность типов не позволит вам случайно передать опциональный String куску кода, который ожидает неопциональный String . Безопасность типов позволяет вам улавливать и исправлять ошибки как можно раньше в процессе разработки.

Константы и переменные

Константы и переменные связывают имя (например, maximumNumberOfLoginAttempts или welcomeMessage ) со значением определенного типа (например, число 10 или строка «Hello» ). Значение константы не может быть изменено после его установки, тогда как переменной может быть установлено другое значение в будущем.

Объявление констант и переменных

Константы и переменные должны быть объявлены, перед тем как их использовать. Константы объявляются с помощью ключевого слова let , а переменные с помощью var . Вот пример того, как константы и переменные могут быть использованы для отслеживания количества попыток входа, которые совершил пользователь:

let maximumNumberOfLoginAttempts = 10 var currentLoginAttempt = 0

Этот код можно прочесть как:

«Объяви новую константу с именем maximumNumberOfLoginAttempts , и задай ей значение 10 . Потом, объяви новую переменную с именем currentLoginAttempt , и задай ей начальное значение 0 .»

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

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

var x = 0.0, y = 0.0, z = 0.0

Заметка

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

Аннотация типов

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

Этот пример добавляет обозначение типа для переменной с именем welcomeMessage , чтобы обозначить, что переменная может хранить String :

var welcomeMessage: String

Двоеточие в объявлении значит «. типа. «, поэтому код выше может быть прочитан как:

«Объяви переменную с именем welcomeMessage , тип которой будет String »

Фраза «тип которой будет String » означает «может хранить любое String значение». Представьте, что словосочетание «тип которой будет такой-то» означает — значение, которое будет храниться.

Теперь переменной welcomeMessage можно присвоить любое текстовое значение, без каких либо ошибок:

welcomeMessage = "Hello"

Вы можете создать несколько переменных одного типа в одной строке, разделенной запятыми, с одной аннотацией типа после последнего имени переменной:

var red, green, blue: Double

Заметка

Редко когда вам понадобится обозначать тип на практике. Когда вы даете начальное значение константе или переменной на момент объявления, Swift всегда может вывести тип, который будет использовать в константе или переменной. Это описано в Строгая типизация и Вывод типов. В примере welcomeMessage выше, не было присвоения начального значения, так что тип переменной welcomeMessage указывается с помощью обозначения типа вместо того, чтобы вывести из начального значения.

Название констант и переменных

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

let π = 3.14159 let 你好 = "你好世界" let ?? = "dogcow"

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

Заметка

Если вам нужно объявить константу или переменную тем же именем, что и зарезервированное слово Swift, то вы можете воспользоваться обратными кавычками (`) написанными вокруг этого слова. Однако старайтесь избегать имен совпадающих с ключевыми словами Swift и используйте такие имена только в тех случаях, когда у вас абсолютно нет выбора.

Вы можете изменить значение переменной на другое значение совместимого типа. В примере ниже значение friendlyWelcome изменено с “Hello!” на “Bonjour!” :

var friendlyWelcome = “Hello!” friendlyWelcome = “Bonjour!” // теперь friendlyWelcome имеет значение “Bonjour!”

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

let languageName = "Swift" languageName = "Swift++" // Это ошибка компилляции: languageName cannot be changed (значение languageName не может быть изменено).

Печать констант и переменных

Вы можете напечатать текущее значение константы или переменной при помощи функции print(_:separator:terminator:) :

print(friendlyWelcome) // Выведет "Bonjour!"

Функция print(_:separator:terminator:) является глобальной, которая выводит одно или более значений в подходящем виде. В Xcode, например, функция print(_:separator:terminator:) выводит значения в консоль. Параметры separator и terminator имеют дефолтные значения, так что при использовании функции их можно просто пропустить. По умолчанию функция заканчивает вывод символом переноса строки. Чтобы вывести в консоль значения без переноса на новую строку, вам нужно указать пустую строку в параметре terminator, например, print(someValue, terminator: «») . Для получения дополнительной информации по дефолтным значениям параметров обратитесь в раздел «Значения по умолчанию для параметров».

Swift использует интерполяцию строки для включения имени константы или переменной в качестве плейсхолдера внутри строки, что подсказывает Swift подменить это имя на текущее значение, которое хранится в этой константе или переменной. Поместите имя константы или переменной в круглые скобки, а затем добавьте обратный слеш ( \ ) перед открывающей скобкой:

print("Текущее значение friendlyWelcome равно \(friendlyWelcome)") // Выведет "Текущее значение friendlyWelcome равно Bonjour!"

Заметка

Все опции, которые вы можете использовать в интерполяции строки вы сможете найти в разделе «Интерполяция строк».

Комментарии

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

Комментарии в Swift очень похожи на комментарии в C. Однострочные комментарии начинаются с двух слешей ( // ):

// это комментарий

Вы также можете написать многострочные комментарии, которые начинаются со слеша и звездочки ( /* ) и заканчиваются звездочкой, за которой следует слеш ( */ ):

/* это тоже комментарий, но написанный на двух строках */

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

/* это начало первого многострочного комментария /* это второго, вложенного многострочного комментария */ это конец первого многострочного комментария */

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

Точки с запятой

В отличие от многих других языков, Swift не требует писать точку с запятой ( ; ) после каждого выражения в коде, хотя вы можете делать это, если хотите. Однако точки с запятой требуются, если вы хотите написать несколько отдельных выражений на одной строке:

let cat = "?"; print(cat) // Выведет "?" 

Целые числа

Integer (целое число) — это число, не содержащее дробной части, например, как 42 и -23 . Целые числа могут быть либо знаковыми (положительными, ноль или отрицательными) либо беззнаковыми (положительными или ноль).

Swift предусматривает знаковые и беззнаковые целые числа в 8, 16, 32 и 64 битном форматах. Эти целые числа придерживаются соглашения об именах, аналогичных именам в C, в том, что 8-разрядное беззнаковое целое число имеет тип UInt8 , а 32-разрядное целое число имеет тип Int32 . Как и все типы в Swift, эти типы целых чисел пишутся с заглавной буквы.

Границы целых чисел

Вы можете получить доступ к минимальному и максимальному значению каждого типа целого числа с помощью его свойств min и max :

let minValue = UInt8.min // minValue равен 0, а его тип UInt8 let maxValue = UInt8.max // maxValue равен 255, а его тип UInt8

Тип значения этих свойств соответствует размеру числа (в примере выше этот тип UInt8 ) и поэтому может быть использован в выражениях наряду с другими значениями того же типа.

Int

В большинстве случаев вам не нужно будет указывать конкретный размер целого числа для использования в коде. В Swift есть дополнительный тип целого числа — Int , который имеет тот же размер что и разрядность системы:

• На 32-битной платформе, Int того же размера что и Int32
• На 64-битной платформе, Int того же размера что и Int64

Если вам не нужно работать с конкретным размером целого числа, всегда используйте в своем коде Int для целых чисел. Это придает коду логичность и совместимость. Даже на 32-битных платформах, Int может хранить любое значение в пределах -2 147 483 648 и 2 147 483 647 , а этого достаточно для многих диапазонов целых чисел.

UInt

Swift также предусматривает беззнаковый тип целого числа — UInt , который имеет тот же размер что и разрядность системы:

• На 32-битной платформе, UInt того же размера что и UInt32
• На 64-битной платформе, UInt того же размера что и UInt64

Заметка

Используйте UInt , только когда вам действительно нужен тип беззнакового целого с размером таким же, как разрядность системы. Если это не так, использовать Int предпочтительнее, даже когда известно, что значения будут неотрицательными. Постоянное использование Int для целых чисел способствует совместимости кода, позволяет избежать преобразования между разными типами чисел, и соответствует выводу типа целого числа, как описано в Строгая типизация и Вывод Типов.

Числа с плавающей точкой

Число с плавающей точкой — это число с дробной частью, например как 3.14159 , 0.1 , и -273.15 .

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

• Double — представляет собой 64-битное число с плавающей точкой. Используйте его когда число с плавающей точкой должно быть очень большим или чрезвычайно точным
• Float — представляет собой 32-битное число с плавающей точкой. Используйте его, когда значение не нуждается в 64-битной точности.

Заметка

Double имеет точность минимум 15 десятичных цифр, в то время как точность Float может быть всего лишь 6 десятичных цифр. Соответствующий тип числа с плавающей точкой используется в зависимости от характера и диапазона значений, c которыми вы должны работать в коде. В случаях, где возможно использование обоих типов, предпочтительным считается Double.

Строгая типизация и Вывод типов

Swift — язык со строгой типизацией. Язык со строгой типизацией призывает вас иметь четкое представление о типах значений, с которыми может работать ваш код. Если часть вашего кода ожидает String , вы не сможете передать ему Int по ошибке.

Поскольку Swift имеет строгую типизацию, он выполняет проверку типов при компиляции кода и отмечает любые несоответствующие типы как ошибки. Это позволяет в процессе разработки ловить и как можно раньше исправлять ошибки.

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

Благодаря выводу типов, Swift требует гораздо меньше объявления типов, чем языки, такие как C или Objective-C. Константам и переменным все же нужно присваивать тип, но большая часть работы с указанием типов будет сделана за вас.

Вывод типов особенно полезен, когда вы объявляете константу или переменную с начальным значением. Часто это делается путем присвоения литерального значения (или литерала) к константам или переменным в момент объявления​​. (Литеральное значение — значение, которое появляется непосредственно в исходном коде, например как 42 и 3,14159 в примерах ниже.)

Например, если вы присваиваете литеральное значение 42 к новой константе не сказав какого она типа, Swift делает вывод, что вы хотите чтобы константа была Int , потому что вы присвоили ей значение, которое похоже на целое число:

let meaningOfLife = 42 // meaningOfLife выводится как тип Int

Точно так же, если вы не указали тип для литерала с плавающей точкой, Swift делает вывод, что вы хотите создать Double :

let pi = 3.14159 // pi выводится как тип Double

Swift всегда выбирает Double (вместо Float ), когда выводит тип чисел с плавающей точкой.

Если объединить целые литералы и литералы с плавающей точкой в одном выражении, в этом случае тип будет выводиться как Double :

let anotherPi = 3 + 0.14159 // anotherPi тоже выводится как тип Double

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

Числовые литералы

Числовые литералы могут быть написаны как:

• Десятичное число, без префикса
• Двоичное число, с префиксом 0b
• Восьмеричное число, с префиксом 0o
• Шестнадцатеричное число, с префиксом 0x

Все эти литералы целого числа имеют десятичное значение 17 :

let decimalInteger = 17 let binaryInteger = 0b10001 // 17 в двоичной нотации let octalInteger = 0o21 // 17 в восмеричной нотации let hexadecimalInteger = 0x11 // 17 в шестнадцатеричной нотации

Литералы с плавающей точкой могут быть десятичными (без префикса) или шестнадцатеричными (с префиксом 0x ). Они всегда должны иметь число (десятичное или шестнадцатеричное) по обе стороны от дробной точки. Они также могут иметь экспоненту, с указанием в верхнем или нижнем регистре е для десятичных чисел с плавающей точкой, или в верхнем или нижнем регистре р для шестнадцатеричных чисел с плавающей точкой.

Для десятичных чисел с показателем степени ехр , базовое число умножается на 10 exp :

• 1.25e2 означает 1.25 × 10 2 , или 125.0 .
• 1.25e-2 означает 1.25 × 10 -2 , или 0.0125 .

Для шестнадцатеричных чисел с показателем степени ехр , базовое число умножается на 2 exp :

• 0xFp2 означает 15 × 2 2 , или 60.0 .
• 0xFp-2 означает 15 × 2 -2 , или 3.75 .

Все эти числа с плавающей точкой имеют десятичное значение 12.1875 :

let decimalDouble = 12.1875 let exponentDouble = 1.21875e1 let hexadecimalDouble = 0xC.3p0

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

let paddedDouble = 000123.456 let oneMillion = 1_000_000 let justOverOneMillion = 1_000_000.000_000_1

Преобразования числовых типов

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

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

Преобразования целых чисел

Диапазон значений, который может храниться в целочисленных константах и переменных, различен для каждого числового типа. Int8 константы и переменные могут хранить значения между -128 и 127 , тогда как UInt8 константы и переменные могут хранить числа между 0 и 255 . Если число не подходит для переменной или константы с определенным размером, выводится ошибка во время компиляции:

let cannotBeNegative: UInt8 = -1 // UInt8 не может хранить отрицательные значения, поэтому эта строка выведет ошибку let tooBig: Int8 = Int8.max + 1 // Int8 не может хранить число больше своего максимального значения, // так что это тоже выведет ошибку

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

Чтобы преобразовать один числовой тип в другой, необходимо создать новое число желаемого типа из существующего значения. Ниже, в примере, константа twoThousand имеет тип UInt16 , тогда как константа one — UInt8 . Сложить их напрямую не получится, потому что они разного типа. Вместо этого, в примере вызывается функция UInt16 ( one ) для создания нового числа UInt16 из значения константы one :

let twoThousand: UInt16 = 2_000 let one: UInt8 = 1 let twoThousandAndOne = twoThousand + UInt16(one)

Теперь, из-за того, что обе части сложения имеют тип UInt16 — операция сложения допустима. Для конечной константы ( twoThousandAndOne ) выведен тип UInt16 , потому что это сложение двух UInt16 значений.

НазваниеТипа(начальноеЗначение) — стандартный способ вызвать инициализатор типов Swift и передать начальное значение. Честно говоря, у UInt16 есть инициализатор, который принимает UInt8 значение, и, таким образом, этот инициализатор используется, чтобы создать новый UInt16 из существующего UInt8 . Здесь вы не можете передать любой тип, однако это должен быть тип, для которого у UInt16 есть инициализатор. Расширение существующих типов с помощью создания инициализаторов, которые принимают новые типы (включая объявление вашего типа) рассматривается в главе Расширения.

Преобразования целых чисел и чисел с плавающей точкой

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

let three = 3 let pointOneFourOneFiveNine = 0.14159 let pi = Double(three) + pointOneFourOneFiveNine // pi равно 3.14159, и для него выведен тип Double

Здесь, значение константы three используется для создания нового значения типа Double , так что обе части сложения имеют один тип. Без этого преобразования сложение не будет проходить. Обратное преобразование числа с плавающей точкой в целое число тоже должно происходить явно. Так что тип целого числа может быть инициализирован с помощью Double и Float значений:

let integerPi = Int(pi) // integerPi равен 3, и для него выведен тип Int

Числа с плавающей точкой всегда урезаются, когда вы используете инициализацию целого числа через этот способ. Это означает, что 4.75 будет 4 , а -3.9 будет -3 .

Заметка

Правила объединения числовых констант и переменных отличается от правил числовых литералов. Литеральное значение 3 может напрямую сложиться с литеральным значением 0.14159 , потому что числовые литералы сами по себе не имеют явного типа. Их тип выводится только в момент оценки значения компилятором.

Псевдонимы типов

Псевдонимы типов задают альтернативное имя для существующего типа. Можно задать псевдоним типа с помощью ключевого слова typealias .

Псевдонимы типов полезны, когда вы хотите обратиться к существующему типу по имени, которое больше подходит по контексту, например, когда вы работаете с данными определенного размера из внешнего источника:

typealias AudioSample = UInt16

После того как вы один раз задали псевдоним типа, вы можете использовать псевдоним везде, где вы хотели бы его использовать

var maxAmplitudeFound = AudioSample.min // maxAmplitudeFound теперь 0

Здесь AudioSample определен как псевдоним для UInt16 . Поскольку это псевдоним, вызов AudioSample.min фактически вызовет UInt16.min , что показывает начальное значение 0 для переменной maxAmplitudeFound .

Логические типы

В Swift есть простой логический тип Bool . Этот тип называют логическим, потому что он может быть только true или false. Swift предусматривает две логические константы, true и false соответственно :

let orangesAreOrange = true let turnipsAreDelicious = false

Типы для orangesAreOrange и turnipsAreDelicious были выведены как Bool , исходя из того факта, что мы им присвоили логические литералы. Так же как с Int и Double в предыдущих главах, вам не нужно указывать константы или переменные как Bool , если при создании вы присвоили им значения true или false . Вывод типов помогает сделать код Swift кратким и читабельным тогда, когда вы создаете константы или переменные со значениями которые точно известны.

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

if turnipsAreDelicious < print("Mmm, tasty turnips!") >else < print("Eww, turnips are horrible.") >// Выведет "Eww, turnips are horrible."

Условные операторы, такие как оператор if детально рассматриваются в главе Управление потоком.

Строгая типизация Swift препятствует замене значения Bool на не логическое значение. Следующий пример выведет ошибку компиляции:

let i = 1 if i < // этот пример не скомпилируется, и выдаст ошибку компиляции >

Тем не менее, альтернативный пример ниже правильный:

let i = 1 if i == 1 < // этот пример выполнится успешно >

Результат сравнения i == 1 имеет тип Bool , и поэтому этот второй пример совершает проверку типов. Такие сравнения как i == 1 обсуждаются в главе Базовые операторы.

Как в других примерах строгой типизации в Swift, этот подход предотвращает случайные ошибки и гарантирует, что замысел определенной части кода понятен.

Кортежи

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

В данном примере (404, «Not Found») это кортеж, который описывает код HTTP статуса. Код HTTP статуса — особое значение, возвращаемое веб-сервером каждый раз, когда вы запрашиваете веб-страницу. Код статуса 404 Not Found возвращается, когда вы запрашиваете страницу, которая не существует.

let http404Error = (404, "Not Found") // http404Error имеет тип (Int, String), и равен (404, "Not Found")

Чтобы передать код статуса, кортеж (404, «Not Found») группирует вместе два отдельных значения Int и String : число и понятное человеку описание. Это может быть описано как «кортеж типа (Int, String) «.

Вы можете создать кортеж с любой расстановкой типов, и они могут содержать сколько угодно нужных вам типов. Ничто вам не мешает иметь кортеж типа (Int, Int, Int) , или типа (String, Bool) , или же с любой другой расстановкой типов по вашему желанию.

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

let (statusCode, statusMessage) = http404Error print("The status code is \(statusCode)") // Выведет "The status code is 404" print("The status message is \(statusMessage)") // Выведет "The status message is Not Found"

Если вам нужны только некоторые из значений кортежа, вы можете игнорировать части кортежа во время разложения с помощью символа подчеркивания ( _ ):

let (justTheStatusCode, _) = http404Error print("The status code is \(justTheStatusCode)") // Выведет "The status code is 404"

В качестве альтернативы можно получать доступ к отдельным частям кортежа, используя числовые индексы, начинающиеся с нуля:

print("The status code is \(http404Error.0)") // Выведет "The status code is 404" print("The status message is \(http404Error.1)") // Выведет "The status message is Not Found"

Вы можете давать имена отдельным элементам кортежа во время объявления:

let http200Status = (statusCode: 200, description: "OK")

Когда вы присвоили имя элементу кортежа, вы можете обратиться к нему по имени:

print("The status code is \(http200Status.statusCode)") // Выведет "The status code is 200" print("The status message is \(http200Status.description)") // Выведет "The status message is OK"

Кортежи особенно полезны в качестве возвращаемых значений функций. Функция, которая пытается получить веб-страницу, может вернуть кортеж типа (Int, String) , чтобы описать успех или неудачу в поиске страницы. Возвращая кортеж с двумя отдельными значениями разного типа, функция дает более полезную информацию о ее результате, чем, если бы, возвращала единственное значение одного типа, возвращаемое функцией. Для более подробной информации смотрите главу Функции, возвращающие несколько значений.

Заметка

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

Опциональные типы (опционалы)

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

Заметка

В C или Objective-C нет понятия опционалов. Ближайшее понятие в Objective-C это возможность вернуть nil из метода, который в противном случае вернул бы объект. В этом случае nil обозначает «отсутствие допустимого объекта». Тем не менее, это работает только для объектов, и не работает для структур, простых типов C, или значений перечисления. Для этих типов, методы Objective-C, как правило, возвращают специальное значение (например, NSNotFound ), чтобы указать отсутствие значения. Этот подход предполагает, что разработчик, который вызвал метод, знает, что есть это специальное значение и что его нужно учитывать. Опционалы Swift позволяют указать отсутствие значения для абсолютно любого типа, без необходимости использования специальных констант.

Приведем пример, который покажет, как опционалы могут справиться с отсутствием значения. У типа Int в Swift есть инициализатор, который пытается преобразовать значение String в значение типа Int . Тем не менее, не каждая строка может быть преобразована в целое число. Строка «123» может быть преобразована в числовое значение 123 , но строка «hello, world» не имеет очевидного числового значения для преобразования.

В приведенном ниже примере используется метод Int() для попытки преобразовать String в Int :

let possibleNumber = "123" let convertedNumber = Int(possibleNumber) // для convertedNumber выведен тип "Int?", или "опциональный Int"

Поскольку метод Int() может иметь недопустимый аргумент, он возвращает опциональный Int , вместо Int . Опциональный Int записывается как Int? , а не Int . Знак вопроса означает, что содержащееся в ней значение является опциональным, что означает, что он может содержать некое Int значение, или он может вообще не содержать никакого значения. (Он не может содержать ничего другого, например, Bool значение или значение String . Он либо Int , либо вообще ничто)

nil

Мы можем установить опциональную переменную в состояние отсутствия значения, путем присвоения ему специального значения nil

var serverResponseCode: Int? = 404 // serverResponseCode содержит реальное Int значение 404 serverResponseCode = nil // serverResponseCode теперь не содержит значения

Заметка

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

Если объявить опциональную переменную без присвоения значения по умолчанию, то переменная автоматически установится в nil для вас:

var surveyAnswer: String? // surveyAnswer автоматически установится в nil

Заметка

nil в Swift не то же самое что nil в Objective-C. В Objective-C nil является указателем на несуществующий объект. В Swift nil не является указателем, а является отсутствием значения определенного типа. Устанавливаться в nil могут опционалы любого типа, а не только типы объектов.

Инструкция If и Принудительное извлечение

Вы можете использовать инструкцию if , сравнивая опционал с nil , чтобы проверить, содержит ли опционал значение. Это сравнение можно сделать с помощью оператора «равенства» ( == ) или оператора «неравенства» ( != ).

Если опционал имеет значение, он будет рассматриваться как «неравным» nil :

if convertedNumber != nil < print("convertedNumber contains some integer value.") >// Выведет "convertedNumber contains some integer value."

Если вы уверены, что опционал содержит значение, вы можете получить доступ к его значению, добавив восклицательный знак ( ! ) в конце имени опционала. Восклицательный знак фактически говорит: «Я знаю точно, что этот опционал содержит значение, пожалуйста, используй его». Это выражение известно как Принудительное извлечение значения опционала:

if convertedNumber != nil < print("convertedNumber has an integer value of \(convertedNumber!).") >// Выведет "convertedNumber has an integer value of 123."

Более подробную информацию об инструкции if можно получить в главе Управление потоком.

Заметка

Попытка использовать ! к несуществующему опциональному значению вызовет runtime ошибку. Всегда будьте уверены в том, что опционал содержит не- nil значение, перед тем как использовать ! чтобы принудительно извлечь это значение.

Привязка опционалов

Можно использовать Привязку опционалов, чтобы выяснить содержит ли опционал значение, и если да, то сделать это значение доступным в качестве временной константы или переменной. Привязка опционалов может использоваться с инструкциями if и while , для проверки значения внутри опционала, и извлечения этого значения в константу или переменную, в рамках одного действия. Инструкции if и while более подробно представлены в главе Управление потоком.

Привязку опционалов для инструкции if можно писать как показано ниже:

1. if let constantName = someOptional
2. statements
3. >

Мы можем переписать пример possibleNumber сверху, используя привязку опционалов, а не принудительное извлечение:

if let actualNumber = Int(possibleNumber) < print("\(possibleNumber) has an integer value of \(actualNumber)") >else < print("\(possibleNumber) could not be converted to an integer") >// Выведет "123" has an integer value of 123

Это может быть прочитано как:

«Если опциональный Int возвращаемый Int(possibleNumber) содержит значение, установи в новую константу с названием actualNumber значение, содержащееся в опционале.»

Если преобразование прошло успешно, константа actualNumber становится доступной для использования внутри первого ветвления инструкции if . Он уже инициализируется значением, содержащимся внутри опционала, и поэтому нет необходимости в использовании ! для доступа к его значению. В этом примере, actualNumber просто используется, чтобы напечатать результат преобразования.

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

Вы можете включать столько опциональных привязок и логических условий в единственную инструкцию if , сколько вам требуется, разделяя их запятыми. Если какое-то значение в опциональной привязке равно nil , или любое логическое условие вычисляется как false , то все условия выражения будет считаться false . Следующие инструкции if эквиваленты:

if let firstNumber = Int("4"), let secondNumber = Int("42"), firstNumber < secondNumber && secondNumber < 100 < print("\(firstNumber) < \(secondNumber) < 100") >// Выведет "4 < 42 < 100" if let firstNumber = Int("4") < if let secondNumber = Int("42") < if firstNumber < secondNumber && secondNumber < 100 < print("\(firstNumber) < \(secondNumber) < 100") >> > // Выведет "4 < 42 < 100"

Заметка

Константы и переменные, созданные через опциональную привязку в инструкции if , будут доступны только в теле инструкции if . В противоположность этому, константы и переменные, созданные через инструкцию guard , доступны в строках кода, следующих за инструкцией guard , что отражено в разделе Ранний Выход.

Неявно извлеченные опционалы

Как описано выше, опционалы показывают, что константам или переменным разрешено не иметь «никакого значения». Опционалы можно проверить с помощью инструкции if , чтобы увидеть существует ли значение, и при условии, если оно существует, можно извлечь его с помощью привязки опционалов для доступа к опциональному значению.

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

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

Вместо того, чтобы ставить восклицательный знак ( ! ) после опционала, когда вы его используете, поместите восклицательный знак ( ! ) после опционала, когда вы его объявляете.

Неявно извлеченные опционалы полезны, когда известно, что значение опционала существует непосредственно после первого объявления опционала, и точно будет существовать после этого. Неявно извлечённые опционалы в основном используются во время инициализации класса, как описано в разделе "Бесхозные ссылки и неявно извлеченные опциональные свойства".

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

let possibleString: String? = "An optional string." let forcedString: String = possibleString! // необходим восклицательный знак let assumedString: String! = "An implicitly unwrapped optional string." let implicitString: String = assumedString // восклицательный знак не нужен

Вы можете считать неявно извлеченные опционалы обычными опционалами дающими разрешение на принудительное извлечение, если это требуется. Когда вы используете неявно извлеченный опционал, то Swift сначала пробует использовать его в качестве обычного опционального значения, если так его использовать не получается, то уже пробует принудительно извлечь значение. В коде выше опциональное значение assumedString является принудительно извлеченным прежде, чем будет записано в implicitString , так как implicitString имеет явный неопциональный тип String . В коде ниже optionalString не имеет явного типа, так что является обычным опционалом.

let optionalString = assumedString // Тип optionalString является "String?" и assumedString не является принудительно извлеченным значением.

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

Вы можете проверить не является ли неявно извлеченный опционал nil точно так же как вы проверяете обычный опционал:

if assumedString != nil < print(assumedString!) >// Выведет "An implicitly unwrapped optional string."

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

if let definiteString = assumedString < print(definiteString) >// Выведет "An implicitly unwrapped optional string."

Заметка

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

Обработка ошибок

Вы используете обработку ошибок в ответ на появление условий возникновения ошибок во время выполнения программы.

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

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

func canThrowAnError() throws < // эта функция может сгенерировать ошибку >

Функция сообщает о возможности генерации ошибки, включив ключевое слово throws в объявление. Когда вы вызываете функцию, которая может выбросить ошибку, вы добавляете ключевое слово try в выражение. Swift автоматически передает ошибки из их текущей области, пока они не будут обработаны условием catch .

do < try canThrowAnError() // ошибка не была сгенерирована >catch < // ошибка сгенерирована >

Выражение do создает область, содержащую объект, которая позволяет ошибкам быть переданными в одно или несколько условий catch .

Вот пример того, как обработка ошибок может быть использована в ответ на различные условия возникновения ошибок:

func makeASandwich() throws < // . >do < try makeASandwich() eatASandwich() >catch SandwichError.outOfCleanDishes < washDishes() >catch SandwichError.missingIngredients(let ingredients)

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

Если ошибка не генерируется, то вызывается функция eatASandwich() . Если ошибка все таки генерируется, и она соответствует SandwichError.outOfCleanDishes , то вызывается функция washDishes() . Если генерируется ошибка, и она соответствует SandwichError.missingIngredients , то функция buyGroceries(_:) вызывается с соответствующим значением [String] , захваченным шаблоном catch .

Генерация, вылавливание и передача ошибок рассмотрены более подробно в главе Обработка ошибок.

Утверждения и предусловия

Утверждения и предусловия являются проверками во время исполнения. Вы используете их для того, чтобы убедиться, что какое-либо условие уже выполнено, прежде чем начнется исполнение последующего кода. Если булево значение в утверждении или в предусловии равно true , то выполнение кода просто продолжается далее, но если значение равно false , то текущее состояние исполнения программы некорректно и выполнение кода останавливается и ваше приложение завершает работу.

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

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

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

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

Отладка с помощью утверждений

Утверждения записываются как функция стандартной библиотеки Swift assert(_:_:file:line:) . Вы передаете в эту функцию выражение, которые оценивается как true или false и сообщение, которое должно отображаться, если результат условия будет false . Например:

let age = -3 assert(age >= 0, "Возраст человека не может быть меньше нуля") // это приведет к вызову утверждения, потому что age >= 0, а указанное значение < 0.

В этом примере, выполнение кода продолжится, только если age >= 0 вычислится в true , что может случиться, если значение age не отрицательное. Если значение age отрицательное, как в коде выше, тогда age >= 0 вычислится как false , и запустится утверждение, завершив за собой приложение.

Сообщение утверждения можно пропускать по желанию, как в следующем примере:

assert(age >= 0)

Если код уже проверяет условие, то вы используете функцию assertionFailure(_:file:line:) для индикации того, что утверждение не выполнилось. Например:

if age > 10 < print("Ты можешь покататься на американских горках и чертовом колесе.") >else if age > 0 < print("Ты можешь покататься на чертовом колесе.") >else

Обеспечение предусловиями

Используйте предусловие везде, где условие потенциально может получить значение false , но для дальнейшего исполнения кода оно определенно должно равняться true . Например, используйте предусловие для проверки того, что значение сабскрипта не вышло за границы диапазона или для проверки того, что в функцию было передано корректное значение.

Для использования предусловий вызовите функцию precondition(_:_:file:line:) . Вы передаете этой функции выражение, которое вычисляется как true или false и сообщение, которое должно отобразиться, если условие будет иметь значение как false . Например:

 // В реализации сабскрипта. precondition(index > 0, "Индекс должен быть больше нуля.")

Вы так же можете вызвать функцию preconditionFailure(_:_:file:line:) для индикации, что отказ работы уже произошел, например, если сработал дефолтный кейс инструкции switch , когда известно, что все валидные значения должны быть обработаны любым кейсом, кроме дефолтного.

Заметка

Если вы компилируете в режиме -0unchecked , то предусловия не проверяются. Компилятор предполагает, что предусловия всегда получают значения true, и он оптимизирует ваш код соответствующим образом. Однако, функция fatalError(_:file:line:) всегда останавливает исполнение, несмотря на настройки оптимизации.

Вы можете использовать функцию fatalError (_:file:line:) во время прототипирования или ранней разработки для создания заглушек для функциональности, которая еще не реализована, написав fatalError ("Unimplemented") в качестве реализации заглушки. Поскольку фатальные ошибки никогда не оптимизируются, в отличие от утверждений или предусловий, вы можете быть уверены, что выполнение кода всегда прекратится, если оно встречает реализацию заглушки.

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

Как называется руководство для разработчиков ios

IDE от Apple используется для написания iOS-приложений. Xcode – это среда разработки с удобным графическим интерфейсом, заточенная под языки программирования Objective-C и Swift. Она включает отладчик, систему контроля версий и управлением устройствами, iPhone Simulator, инструменты профилирования, Interface Builder и многое другое.

Минимальные системные требования для Xcode:

• Mac с macOS 11 и выше.
• ОЗУ от 4 ГБ.
• Не менее 8 ГБ свободного места на диске.
• Mac, MacBook, iMac или Mac mini 2013-2015 или новее.

Xcode выпускается только для macOS, а значит вам понадобится Mac. Xcode не работает на iPad. Доступно несколько сторонних альтернатив для Windows, но они далеки от идеала. Добро пожаловать в инфраструктуру Apple, которая никогда не славилась открытостью.

Политика Apple в отношении загрузки приложений в App Store

Жесткие требования корпорации неоднократно заставляли разработчиков менять подход к созданию продуктов. Чтобы не потратить время напрасно, ознакомьтесь с рекомендациями Apple в отношении загружаемых на App Store приложений. Также стоит изучить список распространенных причин, по которым приложения отклоняются модераторами. Туда входят сбои, неработающие ссылки, недобросовестная реклама и неполная информация для пользователя. Также может блокироваться политический контент и контент для взрослых.

Разработчики часто ругают Apple за отсутствие гибкости. Бесконечные списки требований создают им проблемы, зато пользователи получают более качественные и более безопасные приложения. Не абсолютно безопасные (единичные случаи попадания вредоносного кода в AppStore известны) конечно, но в магазине Apple нет такого количества зловредов как в Google Play. Самое главное – аудитория AppStore гораздо охотнее расстается с деньгами, поэтому приложение для iOS намного проще монетизировать.

Помимо требований к техническим деталям есть набор рекомендаций по внешнему виду. Конечно, соответствие приложений одному стандарту не всегда означает хороший дизайн, но тут ничего не попишешь. Чтобы научиться грамотно проектировать интерфейс, посетите страницу Apple Human Interface Guidelines . Чтобы немного упростить это массивное руководство, из него выделили базовый набор правил (что можно, а что нельзя).

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

Потребление памяти

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

Удобные игровые платформы и инструменты для создания мобильных игр

Помимо двух наиболее популярных движков ( Unity и Unreal engine 4 ) существует ряд неплохих платформ для разработки игр для iOS:

• GameMaker – это набор средств для создания непрерывной игры с интерфейсом перетаскивания и экспортом различных инструментов. Система имеет собственный встроенный скриптовый язык, похожий на JavaScript и позволяющий вам экспортировать игру прямо на платформу iOS.
• Используя Stencyl , вы можете создавать 2D-игры без каких-либо навыков программирования. Это игровой движок, позволяющий разрабатывать приложения для iOS, Windows, Linux или OS X, просто передвигая блоки с кодом.
• LiveCode – мощная платформа для создания собственных игр и приложений. С помощью различных виджетов, расширений и библиотек вы можете ускорить процесс разработки. Это хороший вариант для обучения начинающих программистов.
• Cocos 2D . Бесплатная программа для разработки игр. Построение логики реализуется за счет перемещаемых спрайтов. Обеспечивает реалистичную физику двухмерным объектам.
• Kobold 2D – это улучшенная версия Cocos2D для IPhone. Она более удобна в использовании и имеет мощную функциональность.
• PhoneGap – это бесплатная платформа для разработки приложений, использующая стандартные веб-API для всех типов мобильных операционок, в том числе для iOS.
• Marmalade SDK– н абор инструментов, библиотек, шаблонов и документов, необходимых для разработки приложений для мобильных ОС.
• AppCelerator– основанная на Eclipse легкая IDE с возможностью создавать приложения с нативным интерфейсом.

Как создать игру? Несколько советов начинающим

Чтобы начать создавать iOS-игры, необходимо учесть несколько моментов:

• План. Продумайте все до мелочей – сюжет, физику, логику, реализацию объектов и магические плюшки, зафиксировав последовательность своих будущих действий в неком документе.
• Графика. Весь графический интерфейс игры легко реализуется при помощи специальных движков и библиотек, рассмотренных в предыдущем пункте. Если вы хотите создать уникальный дизайн, вот несколько полезных инструментов с готовыми решениями: Assembly, Canva, Lighto, Font Candy, PicLab.
• Звуки, музыка, диалоги. Все звуковое сопровождение можно создать самому, но проще воспользоваться готовыми наработками из популярных библиотек: PXL APPS, Sound Kit for Prototypes, octave и др.
• Динамика. Чтобы оживить персонажей, без написания кода не обойтись. Однако описанные выше nocode-платформы с сервисом перетаскивания блоков также вполне подойдут.
• Тестирование. Можно погонять уже готовое приложение самостоятельно, но без свежего беспристрастного взгляда будет сложно создать что-то стоящее. Тестирующих компаний немало – testflight, firebase, AWS Device Farm и пр. Выбор зависит от вас.
• Релиз. После тестирования не пожалейте времени и устраните все мелкие баги. Поверьте, куда приятнее получать позитивные отзывы от пользователей приложения.

Полезные ссылки на обучающие материалы

• Официальное руководство Apple для начинающих разработчиков. Здесь вы узнаете про настройку Xcode, структурирование приложения, его реализацию и отправку в App Store.
• Swift . Основы программирования под iOS.
• Видеоролики Apple по разработке . Отличный ресурс для изучения приемов и знакомства с базовым набором инструментов.
• Возможности API . Обзор различных API для доступа к расширениям приложений, Touch ID, фотографиям, HealthKit и многому другому. Информация об интеграции продвинутых функций в приложение.
• Документация по фреймворку UIKit от Apple. Информация будет полезна и новичкам и профессионалам.
• Список iOS-приложений с открытым исходным кодом, размещенный на GitHub.
• Статья Apple об оптимизации работы приложений.
• Книга об устройстве iOS и macOS , автор – Джонатан Левин. Все самое необходимое для работы с операционными системами от Apple.

Для полноценной iOS-разработки потребуется macOS, но приобретение Mac новичку не всегда по карману. Даже на Mac mini последних конфигураций цены у Apple начинают кусаться. В этой ситуации можно воспользоваться ресурсом hackintosh.com или установить виртуальную машину. Дело тут даже не в железе, а в желании. Главное – не терять уверенности в себе и четко поставив цель, продвигаться к перспективной высокооплачиваемой профессии. Дорогу осилит идущий. Удачи!

Дополнительные материалы:

• Карьерный гид от новичка до профи: дорожная карта iOS-разработчика
• Где изучать iOS-разработку в 2021 году: каналы, блоги, комьюнити и курсы
• 5 навыков, необходимых iOS-разработчику

Управление корпоративными iOS-устройствами при помощи OS X Server, а также распространение приложений внутри компании

Рано или поздно в доброй части крупных компаний возникает вопрос разработки внутреннего корпоративного мобильного приложения. В связи с этим, перед IT-специалистами встает задача проработки двух сценариев: когда нужно установить приложения на личные устройства сотрудников и когда нужно раздать устройства, являющиеся собственностью компании, для выполнения сотрудниками конкретных задач. В рамках данной статьи рассматривается работа с iOS-устройствами через OS X Server.

Введение

Сегодня при желании можно легко найти информацию по настройке OS X Server, MDM-решений и т.п. на английском языке, и в целом конфигурирование не представляет какую-то сложность. Данная статья адресована людям в русскоязычном сегменте, впервые столкнувшимся с данной задачей и желающим понять, что их ждет и насколько все сложно и страшно.
Излагаемый материал был составлен как краткое руководство к действию и за ненадобностью направлялся прямиком в Корзину, но перед тем как нажать «Очистить корзину», я подумал, что, возможно, он будет полезен кому-то еще, кто не знаком с этой темой.

Поэтому, отдельную категорию комментаторов прошу быть снисходительными

Постановка задачи

Итак, давайте определимся с задачами, которые перед нами поставила компания (или заказчик).

• Корпоративное мобильное приложение для сотрудников компании, которое они устанавливают на личные устройства, в нашем случае на iOS-девайсы. К примеру, основной функционал — это чтение новостей и календарь мероприятий;
• Узкоспециализированное мобильное приложение для отдельных категорий сотрудников, например, социологов, которые делают опросы, скажем, на улице. Им выдаются iOS-устройства специально для этих задач, и руководство, конечно, надеясь на сознательность этих людей, тем не менее, хочет исключить саму возможность нецелевого использования, как рабочего времени, так и устройств. Проще говоря, нужно запретить делать все: слушать музыку, пользоваться интернетом, устанавливать игры из магазина приложений и т.п., оставить только возможность пользоваться приложением для проведения соц. опросов;

Ликбез

Несмотря на то, что эти два направления отличаются, у них есть что-то общее, а именно — распространение приложений внутри компании, т.е. по программе Apple Developer Enterprise Program. Для неподготовленного разработчика может показаться, что это просто регистрация компании-разработчика как юридического лица, с какими-то Enterprise примочками. К сожалению, дословно суть программы звучит так «The Apple AppStore: no place to distribute enterprise apps», т.е. вступая в эту программу вы приобретаете возможность распространять iOS-приложения в обход AppStore, но теряете возможность публиковать в официальный AppStore.

Давайте теперь взглянем на вопрос распространения корпоративных мобильных приложений несколько шире и не только глазами Apple. Сегодня на рынке есть три крупных игрока — это Google, Apple и Microsoft.
Итак, как видит распространение приложений в обход магазина каждая из этих технологических компаний.

Google
Тут все просто. Android открытая операционная система. Формируй пакет приложения (*.apk) и далее делай с ним все, что хочешь. Все что нужно — это заплатить разовый взнос в Google Play Developer Program.

Microsoft
Две программы. Для публикации в официальный магазин — небольшой разовый взнос. Для публикации в обход магазина, вы должны раз в год покупать специальный сертификат — Enterprise Mobile Code Signing, которым подписываются ваши приложения. Он, грубо говоря, как пропуск для приложения в гараж приложений смартфона — «Я VIP, мне можно устанавливаться с черного хода».

Apple
Купертиновцы, в свою очередь, видят подход к разработке мобильных приложений следующим образом.
Для публикации в официальный магазин AppStore существует Apple Developer Program в которой могут участвовать как физические, так и юридические лица, цена одна и та же. Если у вас есть потребность в публикации приложений внутри компании, т.е. не для всех, то Apple предоставляет программу Apple Developer Enterprise Program, правда в ней вы уже не сможете публиковать приложения в AppStore.
Но что, если вам нужно публиковать приложения по обоим сценариям? Или пока нет возможности зарегистрировать юридическое лицо, вы только начали делать прототип и можете зарегистрировать физическое лицо, т.е. одного разработчика.
На этот случай в классической Apple Developer Program предусмотрена возможность заливать приложения напрямую на 100 устройств различных типов (iPhone, iPad), зарегистрированных в консоли разработчика. По научному это называется AdHoc, т.е. распространение с целью тестирования.
Как ни странно, эта штука часто решает целый пласт проблем на начальных этапах и о ней мы и поговорим в рамках данной статьи.

Отлично, у нас есть прототип мобильного приложения, есть учетная запись разработчика в Apple Developer Program и огромное желание решить задачу.

Теперь перейдем к модели управления iOS устройствами. Если вы раньше пользовались iPhone или iPad, то наверняка слышали о такой штуке как Профиль. Нет, не тот профиль пользователя из SharePoint, а профиль, описывающий полномочия устройства. Например, доступ к Beta-версиям iOS. Именно, на этой штуке все и крутится в мире Apple: установка приложений, ограничение возможностей устройства, конфигурирование устройств и т.п. И как вы наверно уже поняли, мы будем этими профилями рулить. С кем-то добровольно, с кем-то принудительно.

Apple Configurator 2

• Приложение Apple Configurator 2 (Бесплатно);
• Приложение OS X Server (1.490 руб);

Т.е. все под контролем, а именно так

OS X Server, а вернее Profile Manager, входящий в его состав, необходим для удаленного конфигурирования профилей, т.к. Apple Configurator 2 работает только «по шнурку».

Таким образом, чтобы вы четко поняли схему: посредством профилей (по сути — конфигурационного файла, который летает туда-сюда) осуществляется удаленная установка приложений и конфигурирование устройств. Apple Configurator 2 позволяет гарантировать, что профиль, установленный с его помощью, не будет удален пользователем, а Profile Manager в OS X Server позволяет конфигурировать установленные профили удаленно. В первом приближении картинка такая.

Теперь, когда вы собрали мысли в кучку, осталось добавить еще пару недостающих элементов в пазл. Помимо профилей, существует еще одно звено механизма, называемое Supervising, которое предоставляет Apple Configurator 2. Оно заключается в сбросе устройства к заводским настройкам, жесткое конфигурирование на использование вашего Profile Manager, и запрет на хард-ресет устройства. Также в нем поддерживается функция снятия образов памяти, проще говоря, бекапов.

И последнее, думаю вы уже подумали, а как же тогда обычным сотрудникам получить корпоративные приложения без всех этих страшных сбросов и конфигурировании? Для них в рамках Profile Manager предоставляется веб-сайт, по умолчанию называющийся «MyDevices», с которого они могут скачать профиль, настраивающий автоматически устанавливающий нужные приложения на их смартфон. Да, вот так все просто с рядовыми сотрудниками.

Хорошо, вернемся к Apple Configurator 2.

Так он выглядит в AppStore

Еще раз перечислим его основные возможности:

• Сброс iOS-устройства к заводским настройкам;
• Создание профилей устройства;
• Создание Blueprint образов;
• Установка iOS-устройства в Supervised-режим, который позволяет контролировать устройство (сбрасывать и т.п.) только с этого компьютера;
• Создание бэкапов iOS-устройств;

Профили в Apple Configurator 2

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

• Настройки для подключения к WiFi;
• Ограничения на использование мультимедийных возможностей устройства;
• Запрет на установку приложений из AppStore;
• Фильтр на доступные веб-сайты, либо запретить использование браузера Safari;

Список доступных настроек через профиль
Общая информация об устройстве

Пароль на экране брокировки

Ограничения на функциональность устройства

Ограничения на использование приложений

Ограничения на использование медиа-контента

Настройки глобального прокси-сервера

Список разрешенных сайтов

Политика в отношении доменов

Доступ к WiFi точкам

Настройки VPN

Настройки AirPlay

Настройки AirPrint

Настройки учетных записей электронной почты

Настройки Exchange ActiveSync

Настройки LDAP

Синхронизация календарей

Синхронизация контактов

Подписка на календари

Иконки быстрого перехода на веб-сайт

Шрифты

Сертификаты

Настройка SCEP-сервера

Настройки APN-точек для 3G

Blueprints в Apple Configurator 2

Blueprints — это быстрые «образы» желаемых настроек и приложений, которые можно применить к подключенному устройству в один клик.

Работа с Blueprints

Выбор типа устройства

Добавление нужных корпоративных приложений в образ

Добавить *.ipa -пакет приложения

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

Apple OS X Server

OS X Server — это приложение, до 2014 года предустановливаемое на топовые версии компьютеров Apple Mac mini. В настоящее время распространяется как отдельное приложение через AppStore и доступно для установки на любые компьютеры Apple.
Представляет из себя набор служб для обслуживания парка Apple устройств, а также удаленного управления iOS- и OSX- устройствами.

Так он выглядит в AppStore

• Администрирование пользователей в рамках Open Directory (возможна интеграция с Active Directory);
• Синхронизация календарей;
• Синхронизация контактов;
• Обмен файлами (File Sharing);
• Почтовый сервер;
• Групповые чаты пользователей;
• Менеджер профилей для удаленного управления iOS и OSX устройствами;
• Сервер TimeMachine (бекапы);
• VPN;
• Хостинг веб-сайтов на PHP и Python;
• CMS Wiki;
• Сервер XCode для непрерывной интеграции;
• DHCP сервер;
• DNS сервер;
• FTP сервер;

Синхронизация OS X Server с Active Directory

Конечно, я не мог пройти мимо Active Directory, так как мы работаем в корпоративном сегменте, и, как минимум, пару слов я обязан сказать на эту тему. Подобно Microsoft, Apple работает со своей службой каталогов — Open Directory, которая концептуально не отличается от Active Directory.
Для интеграции с Active Directory используется механизм «связывания» (Binding). Настраивается он достаточно просто, однако, не отличается железной стабильностью (на разных комбинациях версий Windows Server и OS X Server разный результат, т.е. можете потерять связь).

Настройка синхронизации с Active Directory

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

Алгоритм действий для настройки инфраструктуры конфигурирования iOS-устройств и распространения приложений

1. Устанавливаем Apple Configurator 2 из AppStore.

2. Устанавливаем Apple OS X Server из AppStore.

3. Создаем профиль с настройками WiFi для iOS-устройства через Apple Configurator 2, если сотрудники должны пользоваться определенной закрытой корпоративной сетью, к которой мы не хотим давать им пароль.

Подробнее

Указываем пароль, который нужно ввести, чтобы удалить профиль. Это один из возможных вариантов. Можем вообще запретить удаление.

4. Перейдем к настройке OS X Server. Зададим имя хоста, доступность из сетей и параметры удаленного доступа. Это начальное конфигурирование нашего сервера.

Подробнее

5. Настроим Open Directory в OS X Server, чтобы далее хранить в ней пользователей.
Подробнее

6. Создадим пользователей в OS X Server, или синхронизируем сервер с Active Directory. Нам потребуется еще один администратор и простой пользователь (он же — сотрудник).

Подробнее

7. Создадим группы пользователей (по бригадам/отделам/подразделениям) и распределим пользователей по этим группам в OS X Server. Это понадобится нам для конфигурирования групп устройств.

Подробнее

8. Включим Apple Push Notifications в OS X Server.
Подробнее

Включение Apple Push Notifications необходимо для управления устройствами через интернет, так как через push-уведомления доставляются команды от OS X сервера.

Здесь нам уже понадобится учетная запись нашего разработчика, с активной Apple Developer Program.

9. Настроим синхронизацию контактов в OS X Server. Это опционально, если вы не планируете вести общий список контактов между сотрудниками.

Подробнее

10. Теперь самое интересное. Настроим менеджер профилей в OS X Server.
Подробнее

Сервер управления мобильными устройствами

Profile Manager позволяет централизованно администрировать и управлять зарегистрированными мобильными устройствами, работающими под OS X 10.7 и выше или iOS 4 и выше.

Следует отметить, что Apple предоставляет управление API своих устройств сторонним разработчикам MDM-решений, чтобы использовать их опыт.

Как правило эти системы управления мобильными устройствами (MDM — Mobile Device Management) имеют больше возможностей для настройки.
Для осуществления инициируемой со стороны сервера загрузки настроек, программного обеспечения понадобится push-сервис. Push сервер является частью OS X Server (иногда push-сервис реализуется как часть MDM-решения, в этом случае push-сервис от Apple не нужен). Push сервер будет выполнять функции по загрузке команд, связанных с конфигурацией или установкой ПО мобильных устройств, взаимодействуя с магазином приложений компании Apple. Это обеспечивает выполнение срочных действий, таких как блокировка похищенных устройств или удаление информации с них.

Если планируется управление только устройствами Apple, а какие-либо специальные требования отсутствуют, то Profile Manager — оптимальное решение по соотношению стоимость/функциональность. В этом случае для централизованной загрузки настроек корпоративного ПО следует использовать Apple Push Server. А возможность установки политик на устройства, подключенные даже за периметром корпоративной сети, обеспечит Apple Push Notification Service (APNS).

Алгоритм настройки менеджера профилей

11. Через Profile Manager в OS X Server включим возможность привязывать iOS-устройства, настроенные в Apple Configurator 2.

Подробнее

12. Через Profile Manager в OS X Server зададим пользователю (лучше группе пользователей) ограничения к его iOS-устройству.

Подробнее

13. Пришло время поработать с физическим устройством. Переведем iOS-устройство в Supervised-режим через Apple Configurator 2 с принятием настроек от удаленного MDM-сервера (Mobile Device Management), которым является OS X Server.

Подробнее

После перезагрузки (до принятия приветствия) iOS-устройства через Apple Configurator 2 загрузим в него созданный ранее профиль с настройками WiFi и описанием принадлежности.

Принять приветствие на iOS-устройстве, переведенном в Supervised-режим, и залогиниться под нужным пользователем, созданным в OS X Server.

14. Добавим все iOS-устройства в учетную запись Apple-разработчика.
Подробнее

• Увидеть через iTunes;
• Увидеть через Apple Configurator 2;
• Запросить программно, через установку профиля;

15. Подготовим корпоративное приложение в XCode для распространения внутри компании в XCode (Archive).

Подробнее

Публиковать приложение в AppStore мы не собираемся, поэтому нажимаем Export…

16. Загрузим *.ipa -пакет приложения в Profile Manager в OS X Server.
Подробнее

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

17. В Profile Manager в OS X Server укажем для нужного пользователя (лучше группы пользователей) — какие корпоративные приложения установить на его устройство. Сделаем Push приложений (начнем удаленную установку).

Подробнее

Так выглядит iOS-устройство до назначения приложений пользователю.

Добавим приложения пользователям.

Видим статус применения настроек / установки приложений.

«Внезапно» началась установка корпоративных приложений на устройство. Пользователь не предпринимает никаких действий.

Установка приложений завершена.

Настройка инфрастуктуры завершена.

Распространение приложений среди сотрудников с личными iOS-устройствами

Алгоритм действий сотрудника

Зайти на сайт сервера;

http://os-x-server.com/mydevices

Послесловие

Концептуальное описание OS X Server на русском языке, хоть и немного устаревшее, советую почитать здесь.

Актуальные видео по настройке отдельных компонентов OS X Server можно посмотреть здесь.

Примечание
Описанный в статье метод распространения применим для любых приложений созданных для iOS, т.е. он идентичен для приложений, написанных на Xamarin, Cordova или нативно. Все что вам нужно — это сформировать пакет приложения *.ipa и загрузить его в Profile Manager.

Надеюсь, статья покажется полезной начинающим, или не очень, iOS-разработчикам. Успехов!

• Разработка под iOS
• Разработка мобильных приложений