```kotlin
-kotlin {
- cocoapods {
- // Configure a dependency on AFNetworking.
- // The CocoaPods version notation is supported.
- // The dependency will be added to all macOS and iOS targets.
- pod("AFNetworking", "~> 3.2.0")
- }
-}
+import cocoapods.AFNetworking.*
+import cocoapods.SDWebImage.*
```
-To use these dependencies from a Kotlin code, import a package `cocoapods.
`.
-In the example above, it's `cocoapods.AFNetworking`.
+You can find a sample project [here](https://github.com/Kotlin/kotlin-with-cocoapods-sample).
-The dependencies declared in this way are added in the podspec file and downloaded during
-the execution of `pod install`.
+### Add a dependency on a Pod library stored locally
-> __Important:__ To correctly import the dependencies into the Kotlin/Native module, the
-Podfile must contain either [`use_modular_headers!`](https://guides.cocoapods.org/syntax/podfile.html#use_modular_headers_bang)
+1. Add a dependency on a Pod library stored locally with `pod()` to `build.gradle.kts` (`build.gradle`) of your
+ project.
+As the third parameter, specify the path to `Podspec` of the local Pod using `project.file(..)`.
+ > You can add local dependencies on subspecs as well.
+ > The `cocoapods` block can include dependencies to Pods stored locally and Pods from the CocoaPods repository at
+ > the same time.
+ {:.note}
+
+
+
+ ```kotlin
+ kotlin {
+ ios()
+
+ cocoapods {
+ summary = "CocoaPods test library"
+ homepage = "https://github.com/JetBrains/kotlin"
+ pod("pod_dependency", "1.0", project.file("../pod_dependency/pod_dependency.podspec"))
+ pod("subspec_dependency/Core", "1.0", project.file("../subspec_dependency/subspec_dependency.podspec"))
+
+ pod("AFNetworking", "~> 4.0.0")
+ pod("SDWebImage/MapKit")
+ }
+ }
+ ```
+
+
+
+2. Re-import the project.
+
+If you want to use dependencies on local pods from Kotlin code, import the corresponding packages.
+
+
+
+```kotlin
+import cocoapods.pod_dependency.*
+import cocoapods.subspec_dependency.*
+```
+
+
+
+You can find a sample project [here](https://github.com/Kotlin/kotlin-with-cocoapods-sample).
+
+## Use a Kotlin Gradle project as a CocoaPods dependency
+
+You can use a Kotlin Multiplatform project with native targets as a CocoaPods dependency (Kotlin Pod). You can include such a dependency
+in the Podfile of the Xcode project by its name and path to the project directory containing the generated Podspec.
+This dependency will be automatically built (and rebuilt) along with this project.
+Such an approach simplifies importing to Xcode by removing a need to write the corresponding Gradle tasks and Xcode build steps manually.
+
+
+You can add dependencies between:
+* [A Kotlin Pod and an Xcode project with one target](#add-a-dependency-between-a-kotlin-pod-and-xcode-project-with-one-target)
+* [A Kotlin Pod and an Xcode project with several targets](#add-a-dependency-between-a-kotlin-pod-with-an-xcode-project-with-several-targets)
+
+> To correctly import the dependencies into the Kotlin/Native module, the
+`Podfile` must contain either [`use_modular_headers!`](https://guides.cocoapods.org/syntax/podfile.html#use_modular_headers_bang)
or [`use_frameworks!`](https://guides.cocoapods.org/syntax/podfile.html#use_frameworks_bang)
directive.
+{:.note}
-Search paths for libraries added in the Kotlin/Native module in this way are obtained
-from properties of the Xcode projects configured by CocoaPods. Thus if the module uses
-CocoaPods libraries, it can be build __only__ __from__ __Xcode__.
+### Add a dependency between a Kotlin Pod and Xcode project with one target
-## Current Limitations
+1. Create an Xcode project with a `Podfile` if you haven’t done so yet.
+2. Add the path to your Xcode project `Podfile` with `podfile = project.file(..)` to `build.gradle.kts` (`build.gradle`)
+of your Kotlin project.
+ This step helps synchronize your Xcode project with Kotlin Pod dependencies by calling `pod install` for your `Podfile`.
+3. Specify the minimum target version for the Pod library.
+ > If you don't specify the minimum target version and a dependency Pod requires a higher deployment target, you may get an error.
+ {:.note}
- - If a Kotlin/Native module uses a CocoaPods library, you can build this module only from an Xcode project.
- Otherwise the CocoaPods library cannot be resolved by the Kotlin/Native infrastructure.
+
+
+ ```kotlin
+ kotlin {
+ ios()
+
+ cocoapods {
+ summary = "CocoaPods test library"
+ homepage = "https://github.com/JetBrains/kotlin"
+ ios.deploymentTarget = "13.5"
+ pod("AFNetworking", "~> 4.0.0")
+ podfile = project.file("../ios-app/Podfile")
+ }
+ }
+ ```
+
+
+
+4. Add the name and path of the Kotlin Pod you want to include in the Xcode project to `Podfile`.
+
+
+
+ ```ruby
+ use_frameworks!
+
+ platform :ios, '9.0'
+
+ target 'ios-app' do
+ pod 'kotlin_library', :path => '../kotlin-library'
+ end
+ ```
+
+
+
+5. Re-import the project.
+
+### Add a dependency between a Kotlin Pod with an Xcode project with several targets
+
+1. Create an Xcode project with a `Podfile` if you haven’t done so yet.
+2. Add the path to your Xcode project `Podfile` with `podfile = project.file(..)` to `build.gradle.kts` (`build.gradle`) of
+ your Kotlin project.
+ This step helps synchronize your Xcode project with Kotlin Pod dependencies by calling `pod install` for your `Podfile`.
+3. Add dependencies to the Pod libraries that you want to use in your project with `pod()`.
+4. For each target, specify the minimum target version for the Pod library.
+
+
+
+ ```kotlin
+ kotlin {
+ ios()
+ tvos()
+
+ cocoapods {
+ summary = "CocoaPods test library"
+ homepage = "https://github.com/JetBrains/kotlin"
+ ios.deploymentTarget = "13.5"
+ tvos.deploymentTarget = "13.4"
+
+ pod("AFNetworking", "~> 4.0.0")
+ podfile = project.file("../severalTargetsXcodeProject/Podfile") // specify the path to Podfile
+ }
+ }
+ ```
+
+
+
+5. Add the name and path of the Kotlin Pod you want to include in the Xcode project to the `Podfile`.
+
+
+
+ ```ruby
+ target 'iosApp' do
+ use_frameworks!
+ platform :ios, '13.5'
+ # Pods for iosApp
+ pod 'kotlin_library', :path => '../kotlin-library'
+ end
+
+ target 'TVosApp' do
+ use_frameworks!
+ platform :tvos, '13.4'
+
+ # Pods for TVosApp
+ pod 'kotlin_library', :path => '../kotlin-library'
+ end
+ ```
+
+
+
+6. Re-import the project.
+
+You can find a sample project [here](https://github.com/Kotlin/multitarget-xcode-with-kotlin-cocoapods-sample).
\ No newline at end of file
diff --git a/CONCURRENCY.md b/CONCURRENCY.md
index 03f10ef416c..21b340cb9fb 100644
--- a/CONCURRENCY.md
+++ b/CONCURRENCY.md
@@ -94,6 +94,9 @@ future.consume {
concurrent threads, if the worker mechanisms are insufficient for a particular task. Note, that object detachment
may require explicit leaving function holding object references and then performing cyclic garbage collection.
For example, code like:
+
+
+
```kotlin
val graph = DetachedObjectGraph {
val map = mutableMapOf()
@@ -103,7 +106,13 @@ val graph = DetachedObjectGraph {
map
}
```
+
+
+
will not work as expected and will throw runtime exception, as there are uncollected cycles in the detached graph, while:
+
+
+
```kotlin
val graph = DetachedObjectGraph {
{
@@ -117,6 +126,9 @@ val graph = DetachedObjectGraph {
}
}
```
+
+
+
will work properly, as holding references will be released, and then cyclic garbage affecting reference counter is
collected.
@@ -207,4 +219,4 @@ that are potentially parts of shared cyclic data should be zeroed out once no lo
If atomic reference value is attempted to be set to non-frozen value runtime exception is thrown.
Freezable atomic reference is similar to the regular atomic reference, but until frozen behaves like regular box
-for a reference. After freezing it behaves like an atomic reference, and can only hold a reference to a frozen object.
+for a reference. After freezing it behaves like an atomic reference, and can only hold a reference to a frozen object.
\ No newline at end of file