Adding iOS dependencies

1. Download the library source code and place it somewhere where you can reference it from your project.

2. Build a library (library authors usually provide a guide on how to do this) and get a path to the binaries.

3. In your project, create a .def file, for example DateTools.def.

4. Add a first string to this file: language = Objective-C. If you want to use a pure C dependency, omit the language property.

5. Provide values for two mandatory properties:

   • headers describes which headers will be processed by cinterop.

   • package sets the name of the package these declarations should be put into.

   For example:

   headers = DateTools.h
   package = DateTools

6. Add information about interoperability with this library to the build script:

   • Pass the path to the .def file. This path can be omitted if your .def file has the same name as cinterop and is placed in the src/nativeInterop/cinterop/ directory.

   • Tell cinterop where to look for header files using the includeDirs option.

   • Configure linking to library binaries.

   Kotlin

   Groovy

   kotlin {
       iosArm64() {
           compilations.getByName("main") {
               val DateTools by cinterops.creating {
                   // Path to the .def file
                   definitionFile.set(project.file("src/nativeInterop/cinterop/DateTools.def"))
   
                   // Directories for header search (an analogue of the -I<path> compiler option)
                   includeDirs("include/this/directory", "path/to/another/directory")
               }
               val anotherInterop by cinterops.creating { /* ... */ }
           }
   
           binaries.all {
               // Linker options required to link to the library.
               linkerOpts("-L/path/to/library/binaries", "-lbinaryname")
           }
       }
   }

   kotlin {
       iosArm64 {
           compilations.main {
               cinterops {
                   DateTools {
                       // Path to the .def file
                       definitionFile = project.file("src/nativeInterop/cinterop/DateTools.def")
   
                       // Directories for header search (an analogue of the -I<path> compiler option)
                       includeDirs("include/this/directory", "path/to/another/directory")
                   }
                   anotherInterop { /* ... */ }
               }
           }
   
           binaries.all {
               // Linker options required to link to the library.
               linkerOpts "-L/path/to/library/binaries", "-lbinaryname"
           }
       }
   }

7. Build the project.

Now you can use this dependency in your Kotlin code. To do that, import the package you've set up in the package property in the .def file. For the example above, this will be:

import DateTools.*

1. Download the framework source code and place it somewhere that you can reference it from your project.

2. Build the framework (framework authors usually provide a guide on how to do this) and get a path to the binaries.

3. In your project, create a .def file, for example MyFramework.def.

4. Add the first string to this file: language = Objective-C. If you want to use a pure C dependency, omit the language property.

5. Provide values for these two mandatory properties:

   • modules – the name of the framework that should be processed by the cinterop.

   • package – the name of the package these declarations should be put into.

   For example:

   modules = MyFramework
   package = MyFramework

6. Add information about interoperability with the framework to the build script:

   • Pass the path to the .def file. This path can be omitted if your .def file has the same name as the cinterop and is placed in the src/nativeInterop/cinterop/ directory.

   • Pass the framework name to the compiler and linker using the -framework option. Pass the path to the framework sources and binaries to the compiler and linker using the -F option.

   Kotlin

   Groovy

   kotlin {
       iosArm64() {
           compilations.getByName("main") {
               val DateTools by cinterops.creating {
                   // Path to the .def file
                   definitionFile.set(project.file("src/nativeInterop/cinterop/DateTools.def"))
   
                   compilerOpts("-framework", "MyFramework", "-F/path/to/framework/")
               }
               val anotherInterop by cinterops.creating { /* ... */ }
           }
   
           binaries.all {
               // Tell the linker where the framework is located.
               linkerOpts("-framework", "MyFramework", "-F/path/to/framework/")
           }
      }
   }

   kotlin {
       iosArm64 {
           compilations.main {
               cinterops {
                   DateTools {
                       // Path to the .def file
                       definitionFile = project.file("src/nativeInterop/cinterop/MyFramework.def")
   
                       compilerOpts("-framework", "MyFramework", "-F/path/to/framework/")
                   }
                   anotherInterop { /* ... */ }
               }
           }
   
           binaries.all {
               // Tell the linker where the framework is located.
               linkerOpts("-framework", "MyFramework", "-F/path/to/framework/")
           }
       }
   }

7. Build the project.

Now you can use this dependency in your Kotlin code. To do this, import the package you've set up in the package property in the .def file. For the example above, this will be:

import MyFramework.*

Learn more about Objective-C and Swift interop and configuring cinterop from Gradle.