Docs
Launch GraphOS Studio
You're viewing documentation for a previous version of this software. Switch to the latest stable version.

Get started with Multiplatform (Experimental)


Note: Multiplatform support is experimental and still under heavy development, expect the API to change. If you have feedback, we'd love to hear it. Please see

for how to get in touch.

You can also check out the

for more details.

Kotlin multiplatform allows to use the same queries and generated models on both Android and iOS. On Android it uses

to handle the HTTP calls. On iOS, it uses
NSUrlSession
.

In addition to jvm, the supported native platforms currently are:

  • iosArm64
  • iosX64

Furthermore, the js target is also available for the apollo-api dependency - meaning you could use the models and in a JavaScript project.

Add the Gradle plugin

In your app Gradle file, apply the com.apollographql.apollo plugin:

Using the

:

plugins {
// ...
id("com.apollographql.apollo").version("x.y.z")
}
plugins {
// ...
id("com.apollographql.apollo").version("x.y.z")
}

Or using the

:

buildscript {
// ...
classpath("com.apollographql.apollo:apollo-gradle-plugin:x.y.z")
}
apply(plugin = "com.apollographql.apollo")
buildscript {
// ...
classpath("com.apollographql.apollo:apollo-gradle-plugin:x.y.z")
}
apply plugin: "com.apollographql.apollo"

The plugin is hosted on the Gradle plugin portal, Jcenter and Maven Central.

Add the runtime dependencies

Multiplatform uses a different artifact from apollo-runtime. Its goal is to offer a coroutine-first API and is named apollo-runtime-kotlin:

build.gradle.kts
kotlin {
// targets
jvm()
iosArm64("ios")
sourceSets {
commonMain {
dependencies {
//
implementation("com.apollographql.apollo:apollo-runtime-kotlin:x.y.z")
}
}
}
}

Multithreaded coroutines

If using the x.y.z-native-mt branch of coroutines, gradle will replace the -native-mt version with the non-mt version as outlined

. To prevent this happening add the following to your root build.gradle.kts:

allprojects {
configurations {
all {
resolutionStrategy {
force("org.jetbrains.kotlinx:kotlinx-coroutines-core:x.y.z-native-mt")
}
}
}
}

This ensures that the same version is used everywhere and that Gradle doesn't fail because -native-mt is a pre-release version

Download your schema.json file

Apollo Android requires your 's schema as a schema.json file. You can obtain the contents of this file by running an on your server.

Note: If you don't have a GraphQL server yet, you can use the server from the

:
https://apollo-fullstack-tutorial.herokuapp.com/graphql
.

The Apollo Gradle plugin exposes a downloadApolloSchema task to help you obtain your schema. Provide this task your server's endpoint and the output location for the schema.json file:

./gradlew downloadApolloSchema \
--endpoint="https://your.domain/graphql/endpoint" \
--schema="src/main/graphql/com/example/schema.json"

If your GraphQL endpoint requires authentication, you can pass custom HTTP headers:

./gradlew downloadApolloSchema \
--endpoint="https://your.domain/graphql/endpoint" \
--schema="app/src/main/graphql/com/example/schema.json" \
--header="Authorization: Bearer $TOKEN"

Add your query

Add your schema.json and other .graphql files under src/commonMain/graphql. Build your module and generated code will be available under commonMain sourceSet. That means you can use them both in commonMain or platform specific Kotlin code. Once the Kotlin plugin builds the iOS Framework, generated code can even be called from Swift code.

Executing your query

You use an instance of the ApolloClient class to interact with your server and cache.

To make a query using your generated models:

// First, create an `ApolloClient`
// Replace the serverUrl with your GraphQL endpoint
val apolloClient = ApolloClient(
networkTransport = ApolloHttpNetworkTransport(
serverUrl = "https://your.domain/graphql/endpoint",
headers = mapOf(
"Accept" to "application/json",
"Content-Type" to "application/json",
)
)
)
// in your coroutine scope, call `ApolloClient.query(...).execute()`
scope.launch {
// execute() returns a Flow, here we only take the first item
val response = apolloClient.query(LaunchDetailsQuery(id = "83")).execute().single()
// launch now contains a typesafe model of your data
println("Launch site: ${response.data?.launch?.site"})
}
Previous
Get started with Java
Next
0. Introduction
Edit on GitHubEditForumsDiscord

© 2024 Apollo Graph Inc.

Privacy Policy

Company