+ Version 0.4.0 introduces breaking changes.
+
+ This version brings changes to service definitions. Starting with this version, service definitions require
+ the @Rpc annotation.
+
+ Prior to 0.4.0, a service was defined as follows:
+
+ Starting from 0.4.0, the new service definition should be:
+
+ This definition is sufficient for the project to build. However, it will not fully support IDE features,
+ such as code highlighting.
+ All interfaces annotated with @Rpc are inherently of type RemoteService, which is
+ added by the compiler plugin, but IDEs won't be able to resolve it.
+
+ To ensure proper IDE support, add explicit typing: +
+
+ The reasoning behind this update is that the Kotlin Compiler Plugin API has changed.
+ Versions 2.0.0 and 2.0.10 allowed our plugin to resolve marker interfaces (like RPC)
+ before the code generation phase. Starting from version 2.0.20, this behaviour changed,
+ making annotations the only reliable way to detect RPC services.
+
+ To track changes in this regard, we raised an issue + with the compiler team. + Note that this approach is subject to change, and the final API design may be updated before the stable + release. +
+
+ We stopped publishing compiler plugin artifacts for Kotlin versions prior to 2.0.0.
+ The reason being its high maintenance cost with little to no usage.
+ We encourage the migration to Kotlin 2.0, where all stable versions are now supported.
+
+
+ Currently supported Kotlin versions: 2.0.0, 2.0.10, 2.0.20, 2.0.21
+
+ The Gradle plugin with id org.jetbrains.kotlinx.rpc.platform is not being published anymore.
+ The reason is that it's sole role was to set BOM in the project, which is now considered unnecessary.
+ Gradle version catalogs
+ can be used instead.
+
+ The Gradle plugin with id org.jetbrains.kotlinx.rpc.plugin
+ does not set BOM for the project anymore.
+
+ To configure BOM manually, add the following dependency: +
+Note that this API is experimental and may be removed in future releases.
+
+ Another way of managing streams is to do it manually.
+ For this, you can use the StreamScope constructor function together with
+ withStreamScope:
+
Our protocol provides you with an ability to declare service fields:
diff --git a/docs/pages/kotlinx-rpc/topics/get-started.topic b/docs/pages/kotlinx-rpc/topics/get-started.topic index 1b2652ec..6ba7fe8f 100644 --- a/docs/pages/kotlinx-rpc/topics/get-started.topic +++ b/docs/pages/kotlinx-rpc/topics/get-started.topic @@ -110,21 +110,8 @@kotlinx.rpc provides two Gradle plugins:
- To add a plugin to your project, you need to define the following in your
To learn more about versioning, see .
+ ++ This will configure code generation for your project. +
kotlinx.rpc requires you to add
+
kotlinx.rpc requires you to add the
kotlinx.serialization
Gradle plugin to your project.
- The kotlinx.rpc library offers plugins that simplify project configuration by automating repetitive
- tasks.
- Specifically, kotlinx.rpc provides two Gradle plugins:
+ The kotlinx.rpc library offers a Gradle plugin
+ that simplifies project configuration by automating repetitive tasks: `org.jetbrains.kotlinx.rpc.plugin`
The org.jetbrains.kotlinx.rpc.platform plugin
- is particularly useful for versioning project dependencies.
- It adds BOM
- dependency to your project, that specifies proper versions for kotlinx.rpc dependencies.
- With this, you can skip specifying versions for each runtime dependency:
Using this plugin with version catalogs, your code can be rewritten like this:
- -
- The org.jetbrains.kotlinx.rpc.plugin plugin
- has the same BOM functionality as org.jetbrains.kotlinx.rpc.platform and it also sets
- up code generation configurations.
+ The org.jetbrains.kotlinx.rpc.plugin plugin sets up code generation configurations.
It is useful for multi-project setups - where you define your RPC services in one set of subprojects and use in the - other. In such a setup, you can add the plugin only to modules with service definitions - to save time on building your project.
-- If you are using a version of Kotlin prior to 2.0, - you must also add the KSP (Kotlin Symbol Processing) Gradle plugin: -
-+ For multi-project setups + where you define your RPC services in one set of subprojects and use them in + another, you can add the plugin only to modules with service definitions. +
Services are the centerpieces of the library.
- A service is an interface annotated with the RPC annotation,
+ A service is an interface annotated with the @Rpc annotation,
and contains a set of methods and fields
that can be executed or accessed remotely.
- A simple service can be declared as follows:
RemoteService,
+ which can be specified explicitly, or assumed implicitly by the compiler.
+
+ A simple service can be declared as follows:
As kotlinx.rpc uses Kotlin compiler plugin and KSP plugins,
+
As kotlinx.rpc uses Kotlin compiler plugin,
we rely on internal functionality that may change over time with any new Kotlin version.
To prevent the library from breaking with an incompatible Kotlin version,
we use version prefix for artifacts with code generating functionality.
@@ -69,9 +69,12 @@
id("org.jetbrains.kotlinx.rpc.plugin") version "%kotlinx-rpc-version%"
}