Взаимодействие с Swift/Objective-C

Перевод имен

Классы Objective-C импортируются в Kotlin с их оригинальными именами. Протоколы импортируются как интерфейсы с суффиксом Protocol имени, т.е. @protocol Foo-> interface FooProtocol. Эти классы и интерфейсы размещаются в пакете, указанном в настройках сборки (platform.* пакеты для предварительно настроенных системных фреймворков).

Имена классов и интерфейсов Kotlin при импорте в Objective-C предваряются префиксом. Префикс получен из имени фреймворка.

Objective-C не поддерживает пакеты в фреймворке. Если компилятор Kotlin обнаруживает классы Kotlin в одном фреймворке, которые имеют одинаковое имя, но разные пакеты, он переименовывает их. Этот алгоритм еще не стабилен и может меняться между версиями Kotlin. Чтобы обойти это, можно переименовать конфликтующие классы Kotlin во фреймворке.

Чтобы избежать переименования объявлений Kotlin, используйте аннотацию @ObjCName. Она сообщает компилятору Kotlin использовать пользовательское имя Objective-C и Swift для классов, интерфейсов и других концепций Kotlin:

@ObjCName(swiftName = "MySwiftArray")
class MyKotlinArray {
    @ObjCName("index")
    fun indexOf(@ObjCName("of") element: String): Int = TODO()
}

// Usage with the ObjCName annotations
let array = MySwiftArray()
let index = array.index(of: "element")

Инициализаторы

Инициализаторы Swift/Objective-C импортируются в Kotlin как конструкторы и методы-фабрики с именем create. Последнее происходит с инициализаторами, объявленными в категории Objective-C или как расширение Swift, потому что в Kotlin нет понятия расширения конструкторов.

Конструкторы Kotlin импортируются как инициализаторы в Swift/Objective-C.

Сеттеры

Записываемые свойства Objective-C, перезаписывающие только для чтения свойства суперкласса, представлены как метод setFoo() для свойства foo. То же самое относится к свойствам только для чтения протокола, которые реализованы как изменяемые.

Функции и свойства верхнего уровня

Функции и свойства Kotlin верхнего уровня доступны как члены специальных классов. Каждый файл Kotlin преобразуется в такой класс. Например:

// MyLibraryUtils.kt
package my.library

fun foo() {}

можно вызвать из Swift так:

MyLibraryUtilsKt.foo()

Перевод имен методов

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

[player moveTo:LEFT byMeters:17]
[player moveTo:UP byInches:42]

В Kotlin это будет:

player.moveTo(LEFT, byMeters = 17)
player.moveTo(UP, byInches = 42)

Методы kotlin.Any (equals(), hashCode() и toString()) сопоставляются с методами isEquals:, hash и description в Objective-C и с методом isEquals(_:) и свойствами hash, description в Swift.

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

Ошибки и исключения

В Kotlin нет понятия проверочных исключений, все исключения Kotlin являются непроверенными. Swift имеет только проверочные ошибки. Поэтому, если код Swift или Objective-C вызывает метод Kotlin, который выбрасывает исключение для обработки, то метод Kotlin должен быть помечен аннотацией @Throws , указывающей список «ожидаемых» классов исключений.

При компиляции в фреймворк Objective-C/Swift функции, не являющиеся suspend и имеющие или наследующие аннотацию @Throws, представляются как методы, генерирующие NSError* в Objective-C и как методы throws в Swift. Представления для suspend функций всегда имеют параметр NSError*/Error в обработчике завершения.

Когда функция Kotlin, вызываемая из кода Swift/Objective-C, выбрасывает исключение, которое является экземпляром одного из указанных в @Throws классах или их подклассах, оно распространяется как NSError. Другие исключения Kotlin, достигающие Swift/Objective-C, считаются необработанными и приводят к завершению программы.

Функции suspend без @Throws распространяют только CancellationException как NSError. Функции, не являющиеся suspend без @Throws вообще не распространяют исключения Kotlin.

Обратите внимание, что обратный перевод не реализован: методы Swift/Objective-C, бросающие ошибки, не импортируются в Kotlin как бросающие исключения.

Подвешенные функции

Подвешенные функции Kotlin (подвешенные функции) (suspend) представлены в сгенерированных заголовках Objective-C как функции с обратными вызовами или обработчиками завершения в терминологии Swift/Objective-C.

Начиная с Swift 5.5, подвешенные функции Kotlin suspend также доступны для вызова из Swift как функции async без использования обработчиков завершения. В настоящее время эта функциональность является высокоэкспериментальной и имеет определенные ограничения. Подробности см. в этом вопросе YouTrack.

Дополнительные сведения о механизме async/await в Swift.

Расширения и члены категорий

Члены категорий Objective-C и расширений Swift обычно импортируются в Kotlin в качестве расширений. Поэтому эти объявления нельзя переопределять в Kotlin. А инициализаторы расширений недоступны в качестве конструкторов Kotlin.

Расширения Kotlin для «обычных» классов Kotlin импортируются в Swift и Objective-C в качестве расширений и членов категорий соответственно. Расширения Kotlin для других типов обрабатываются как глобальные объявления с дополнительным параметром получателя. К этим типам относятся:

• Тип Kotlin String

• Типы коллекций Kotlin и их подтипы

• Типы Kotlin interface

• Примитивные типы Kotlin

• Классы Kotlin inline

• Тип Kotlin Any

• Типы функций Kotlin и их подтипы

• Классы и протоколы Objective-C

Kotlin-синглтоны

Синглтон Kotlin (созданный с объявлением object, включая companion object) импортируется в Swift/Objective-C как класс с единственным экземпляром.

Экземпляр доступен через свойства shared и companion.

Для следующего кода Kotlin:

object MyObject {
    val x = "Some value"
}

class MyClass {
    companion object {
        val x = "Some value"
    }
}

Доступ к этим объектам осуществляется следующим образом:

MyObject.shared
MyObject.shared.x
MyClass.companion
MyClass.Companion.shared

NSNumber

Упаковки примитивных типов Kotlin сопоставляются со специальными классами Swift/Objective-C. Например, упаковка kotlin.Int представлена экземпляром класса KotlinInt в Swift (или экземпляром ${prefix}Int в Objective-C, где prefix — префикс имени фреймворка). Эти классы производятся от NSNumber, поэтому экземпляры являются надлежащими NSNumber , поддерживая все соответствующие операции.

Тип NSNumber не автоматически переводится в примитивные типы Kotlin, когда используется в качестве типа параметра или возвращаемого значения Swift/Objective-C. Причина в том, что тип NSNumber не предоставляет достаточной информации о типе обернутого примитивного значения, т.е. статически неизвестно, является ли NSNumber типом Byte, Boolean или Double. Поэтому примитивные значения Kotlin должны быть приводимы к/от NSNumber вручную (см. ниже).

NSMutableString

Класс Objective-C NSMutableString недоступен из Kotlin. Все экземпляры NSMutableString копируются при передаче в Kotlin.

Коллекции

Коллекции Kotlin преобразуются в коллекции Swift/Objective-C, как описано в таблице выше. Коллекции Swift/Objective-C отображаются в Kotlin аналогичным образом, за исключением NSMutableSet и NSMutableDictionary. NSMutableSet не преобразуется в Kotlin MutableSet. Чтобы передать объект для Kotlin MutableSet, вы можете явно создать эту коллекцию Kotlin, например, создав ее в Kotlin с помощью mutableSetOf(), или используя класс KotlinMutableSet в Swift (или ${prefix}MutableSet в Objective-C, где prefix — префикс имени фреймворка). То же самое относится к MutableMap.

Типы функций

Объекты типа функции Kotlin (например, лямбды) преобразуются в функции Swift/блоки Objective-C. Однако есть разница в том, как отображаются типы параметров и возвращаемых значений при переводе функции и типа функции. В последнем случае примитивные типы отображаются в их упакованное представление. Возвращаемое значение Kotlin Unit представляется соответствующим синглтоном Unit в Swift/Objective-C. Значение этого синглтона можно получить так же, как и для любого другого синглтона Kotlin (см. синглтоны в таблице выше). Подводя итог:

fun foo(block: (Int) -> Unit) { ... }

будет представлено в Swift как

func foo(block: (KotlinInt) -> KotlinUnit)

и может быть вызвано так

foo {
    bar($0 as! Int32)
    return KotlinUnit()
}

Обобщенные типы

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

Поддержка обобщенных типов для Objective-C и Swift отличается от Kotlin, поэтому перевод неизбежно потеряет некоторую информацию, но поддерживаемые функции сохраняют значимую информацию.

class Sample<T>() {
    fun myVal(): T
}

class Sample<T>() {
    fun myVal(): T?
}

class Sample<T : Any>() {
    fun myVal(): T
}

data class SomeData(val num: Int = 42) : BaseData()
class GenVarOut<out T : Any>(val arg: T)

let variOut = GenVarOut<SomeData>(arg: sd)
let variOutAny : GenVarOut<BaseData> = variOut as! GenVarOut<BaseData>

binaries.framework {
    freeCompilerArgs += "-Xno-objc-generics"
}