feat: Rest and Realtime clients adapters

Adapters for the Kotlin API for `ably-java` and `ably-android`

pubsub-adapter/src/main/kotlin/io/ably/lib/realtime/RealtimeChannelAdapter.kt

@@ -0,0 +1,53 @@
+package io.ably.lib.realtime
+
+import com.ably.pubsub.RealtimeChannel
+import com.ably.pubsub.RealtimePresence
+import io.ably.lib.types.*
+
+internal class RealtimeChannelAdapter(private val legacyChannel: Channel) : RealtimeChannel {
+  override val name: String
+    get() = legacyChannel.name
+  override val presence: RealtimePresence
+    get() = RealtimePresenceAdapter(legacyChannel.presence)
+  override val state: ChannelState
+    get() = legacyChannel.state
+  override val reason: ErrorInfo
+    get() = legacyChannel.reason
+  override val properties: ChannelProperties
+    get() = legacyChannel.properties
+
+  override fun attach(listener: CompletionListener?) = legacyChannel.attach(listener)
+
+  override fun detach(listener: CompletionListener?) = legacyChannel.detach(listener)
+
+  override fun subscribe(listener: ChannelBase.MessageListener) = legacyChannel.subscribe(listener)
+
+  override fun subscribe(eventName: String, listener: ChannelBase.MessageListener) =
+    legacyChannel.subscribe(eventName, listener)
+
+  override fun subscribe(eventNames: List<String>, listener: ChannelBase.MessageListener) =
+    legacyChannel.subscribe(eventNames.toTypedArray(), listener)
+
+  override fun unsubscribe(listener: ChannelBase.MessageListener) = legacyChannel.unsubscribe(listener)
+
+  override fun unsubscribe(eventName: String, listener: ChannelBase.MessageListener) =
+    legacyChannel.unsubscribe(eventName, listener)
+
+  override fun unsubscribe(eventNames: List<String>, listener: ChannelBase.MessageListener) =
+    legacyChannel.unsubscribe(eventNames.toTypedArray(), listener)
+
+  override fun unsubscribe() = legacyChannel.unsubscribe()
+
+  override fun publish(name: String, data: Any, listener: CompletionListener?) =
+    legacyChannel.publish(name, data, listener)
+
+  override fun publish(message: Message, listener: CompletionListener?) = legacyChannel.publish(message, listener)
+
+  override fun publish(messages: List<Message>, listener: CompletionListener?) =
+    legacyChannel.publish(messages.toTypedArray(), listener)
+
+  override fun history(params: List<Param>): PaginatedResult<Message> = legacyChannel.history(params.toTypedArray())
+
+  override fun historyAsync(params: List<Param>, callback: Callback<AsyncPaginatedResult<Message>>) =
+    legacyChannel.historyAsync(params.toTypedArray(), callback)
+}

pubsub-adapter/src/main/kotlin/io/ably/lib/realtime/RealtimeChannelsAdapter.kt

@@ -0,0 +1,20 @@
+package io.ably.lib.realtime
+
+import com.ably.pubsub.Channels
+import com.ably.pubsub.RealtimeChannel
+import io.ably.lib.types.ChannelOptions
+
+internal class RealtimeChannelsAdapter(private val legacyChannels: AblyRealtime.Channels) : Channels<RealtimeChannel> {
+  override fun contains(name: String): Boolean = legacyChannels.containsKey(name)
+
+  override fun get(name: String): RealtimeChannel = RealtimeChannelAdapter(legacyChannels.get(name))
+
+  override fun get(name: String, options: ChannelOptions): RealtimeChannel =
+    RealtimeChannelAdapter(legacyChannels.get(name, options))
+
+  override fun release(name: String) = legacyChannels.release(name)
+
+  override fun iterator(): Iterator<RealtimeChannel> = iterator {
+    legacyChannels.entrySet().forEach { yield(RealtimeChannelAdapter(it.value)) }
+  }
+}

pubsub-adapter/src/main/kotlin/io/ably/lib/realtime/RealtimeClientAdapter.kt

@@ -0,0 +1,55 @@
+package io.ably.lib.realtime
+
+import com.ably.pubsub.Channels
+import com.ably.pubsub.RealtimeChannel
+import com.ably.pubsub.RealtimeClient
+import io.ably.lib.http.HttpCore
+import io.ably.lib.push.Push
+import io.ably.lib.rest.Auth
+import io.ably.lib.types.*
+
+/**
+ * Wrapper for Realtime client
+ */
+fun RealtimeClient(legacyClient: AblyRealtime): RealtimeClient = RealtimeClientAdapter(legacyClient)
+
+internal class RealtimeClientAdapter(private val legacyClient: AblyRealtime) : RealtimeClient {
+  override val channels: Channels<out RealtimeChannel>
+    get() = RealtimeChannelsAdapter(legacyClient.channels)
+  override val connection: Connection
+    get() = legacyClient.connection
+  override val auth: Auth
+    get() = legacyClient.auth
+  override val options: ClientOptions
+    get() = legacyClient.options
+  override val push: Push
+    get() = legacyClient.push
+
+  override fun time(): Long = legacyClient.time()
+
+  override fun timeAsync(callback: Callback<Long>) = legacyClient.timeAsync(callback)
+
+  override fun stats(params: List<Param>): PaginatedResult<Stats> = legacyClient.stats(params.toTypedArray())
+
+  override fun statsAsync(params: List<Param>, callback: Callback<AsyncPaginatedResult<Stats>>) =
+    legacyClient.statsAsync(params.toTypedArray(), callback)
+
+  override fun request(
+    method: String,
+    path: String,
+    params: List<Param>,
+    body: HttpCore.RequestBody,
+    headers: List<Param>
+  ) = legacyClient.request(method, path, params.toTypedArray(), body, headers.toTypedArray())!!
+
+  override fun requestAsync(
+    method: String,
+    path: String,
+    params: List<Param>,
+    body: HttpCore.RequestBody,
+    headers: List<Param>,
+    callback: AsyncHttpPaginatedResponse.Callback
+  ) = legacyClient.requestAsync(method, path, params.toTypedArray(), body, headers.toTypedArray(), callback)
+
+  override fun close() = legacyClient.close()
+}

pubsub-adapter/src/main/kotlin/io/ably/lib/realtime/RealtimePresenceAdapter.kt

@@ -0,0 +1,65 @@
+package io.ably.lib.realtime
+
+import com.ably.pubsub.RealtimePresence
+import io.ably.lib.types.*
+import java.util.*
+
+internal class RealtimePresenceAdapter(private val legacyPresence: Presence) : RealtimePresence {
+  override fun get(clientId: String?, connectionId: String?, waitForSync: Boolean): List<PresenceMessage> {
+    val params = buildList {
+      clientId?.let { add(Param(Presence.GET_CLIENTID, it)) }
+      connectionId?.let { add(Param(Presence.GET_CONNECTIONID, it)) }
+      add(Param(Presence.GET_WAITFORSYNC, waitForSync))
+    }
+    return legacyPresence.get(*params.toTypedArray()).toList()
+  }
+
+  override fun subscribe(listener: Presence.PresenceListener, completionListener: CompletionListener?) =
+    legacyPresence.subscribe(listener, completionListener)
+
+  override fun subscribe(
+    action: PresenceMessage.Action,
+    listener: Presence.PresenceListener,
+    completionListener: CompletionListener?
+  ) = legacyPresence.subscribe(action, listener, completionListener)
+
+  override fun subscribe(
+    actions: EnumSet<PresenceMessage.Action>,
+    listener: Presence.PresenceListener,
+    completionListener: CompletionListener?
+  ) = legacyPresence.subscribe(actions, listener, completionListener)
+
+  override fun unsubscribe(listener: Presence.PresenceListener) = legacyPresence.unsubscribe(listener)
+
+  override fun unsubscribe(action: PresenceMessage.Action, listener: Presence.PresenceListener) =
+    legacyPresence.unsubscribe(action, listener)
+
+  override fun unsubscribe(actions: EnumSet<PresenceMessage.Action>, listener: Presence.PresenceListener) =
+    legacyPresence.unsubscribe(actions, listener)
+
+  override fun unsubscribe() = legacyPresence.unsubscribe()
+
+  override fun enter(data: Any?, listener: CompletionListener?) = legacyPresence.enter(data, listener)
+
+  override fun update(data: Any?, listener: CompletionListener?) = legacyPresence.update(data, listener)
+
+  override fun leave(data: Any?, listener: CompletionListener?) = legacyPresence.leave(data, listener)
+
+  override fun enterClient(clientId: String, data: Any?, listener: CompletionListener?) =
+    legacyPresence.enterClient(clientId, data, listener)
+
+  override fun updateClient(clientId: String, data: Any?, listener: CompletionListener?) =
+    legacyPresence.updateClient(clientId, data, listener)
+
+  override fun leaveClient(clientId: String?, data: Any?, listener: CompletionListener?) =
+    legacyPresence.leaveClient(clientId, data, listener)
+
+  override fun updatePresence(msg: PresenceMessage, listener: CompletionListener?) =
+    legacyPresence.updatePresence(msg, listener)
+
+  override fun history(params: List<Param>): PaginatedResult<PresenceMessage> =
+    legacyPresence.history(params.toTypedArray())
+
+  override fun historyAsync(params: List<Param>, callback: Callback<AsyncPaginatedResult<PresenceMessage>>) =
+    legacyPresence.historyAsync(params.toTypedArray(), callback)
+}

pubsub-adapter/src/main/kotlin/io/ably/lib/rest/RestChannelAdapter.kt

@@ -0,0 +1,29 @@
+package io.ably.lib.rest
+
+import com.ably.pubsub.RestChannel
+import com.ably.pubsub.RestPresence
+import io.ably.lib.realtime.CompletionListener
+import io.ably.lib.types.*
+
+internal class RestChannelAdapter(private val legacyChannel: Channel) : RestChannel {
+  override val name: String
+    get() = legacyChannel.name
+
+  override val presence: RestPresence
+    get() = RestPresenceAdapter(legacyChannel.presence)
+
+  override fun publish(name: String, data: Any) = legacyChannel.publish(name, data)
+
+  override fun publish(messages: List<Message>) = legacyChannel.publish(messages.toTypedArray())
+
+  override fun publishAsync(name: String, data: Any, listener: CompletionListener) =
+    legacyChannel.publishAsync(name, data, listener)
+
+  override fun publishAsync(messages: List<Message>, listener: CompletionListener) =
+    legacyChannel.publishAsync(messages.toTypedArray(), listener)
+
+  override fun history(params: List<Param>): PaginatedResult<Message> = legacyChannel.history(params.toTypedArray())
+
+  override fun historyAsync(params: List<Param>, callback: Callback<AsyncPaginatedResult<Message>>) =
+    legacyChannel.historyAsync(params.toTypedArray(), callback)
+}

pubsub-adapter/src/main/kotlin/io/ably/lib/rest/RestChannelsAdapter.kt

@@ -0,0 +1,20 @@
+package io.ably.lib.rest
+
+import com.ably.pubsub.Channels
+import com.ably.pubsub.RestChannel
+import io.ably.lib.types.ChannelOptions
+
+internal class RestChannelsAdapter(private val legacyChannels: AblyBase.Channels) : Channels<RestChannel> {
+  override fun contains(name: String): Boolean = legacyChannels.containsKey(name)
+
+  override fun get(name: String): RestChannel = RestChannelAdapter(legacyChannels.get(name))
+
+  override fun get(name: String, options: ChannelOptions): RestChannel =
+    RestChannelAdapter(legacyChannels.get(name, options))
+
+  override fun release(name: String) = legacyChannels.release(name)
+
+  override fun iterator(): Iterator<RestChannel> = iterator {
+    legacyChannels.entrySet().forEach { yield(RestChannelAdapter(it.value)) }
+  }
+}

pubsub-adapter/src/main/kotlin/io/ably/lib/rest/RestClientAdapter.kt

@@ -0,0 +1,52 @@
+package io.ably.lib.rest
+
+import com.ably.pubsub.Channels
+import com.ably.pubsub.RestChannel
+import com.ably.pubsub.RestClient
+import io.ably.lib.http.HttpCore
+import io.ably.lib.push.Push
+import io.ably.lib.types.*
+
+/**
+ * Wrapper for Rest client
+ */
+fun RestClient(legacyClient: AblyRest): RestClient = RestClientAdapter(legacyClient)
+
+internal class RestClientAdapter(private val legacyClient: AblyRest) : RestClient {
+  override val channels: Channels<out RestChannel>
+    get() = RestChannelsAdapter(legacyClient.channels)
+  override val auth: Auth
+    get() = legacyClient.auth
+  override val options: ClientOptions
+    get() = legacyClient.options
+  override val push: Push
+    get() = legacyClient.push
+
+  override fun time(): Long = legacyClient.time()
+
+  override fun timeAsync(callback: Callback<Long>) = legacyClient.timeAsync(callback)
+
+  override fun stats(params: List<Param>): PaginatedResult<Stats> = legacyClient.stats(params.toTypedArray())
+
+  override fun statsAsync(params: List<Param>, callback: Callback<AsyncPaginatedResult<Stats>>) =
+    legacyClient.statsAsync(params.toTypedArray(), callback)
+
+  override fun request(
+    method: String,
+    path: String,
+    params: List<Param>,
+    body: HttpCore.RequestBody,
+    headers: List<Param>
+  ) = legacyClient.request(method, path, params.toTypedArray(), body, headers.toTypedArray())!!
+
+  override fun requestAsync(
+    method: String,
+    path: String,
+    params: List<Param>,
+    body: HttpCore.RequestBody,
+    headers: List<Param>,
+    callback: AsyncHttpPaginatedResponse.Callback
+  ) = legacyClient.requestAsync(method, path, params.toTypedArray(), body, headers.toTypedArray(), callback)
+
+  override fun close() = legacyClient.close()
+}

pubsub-adapter/src/main/kotlin/io/ably/lib/rest/RestPresenceAdapter.kt

@@ -0,0 +1,18 @@
+package io.ably.lib.rest
+
+import com.ably.pubsub.RestPresence
+import io.ably.lib.rest.ChannelBase.Presence
+import io.ably.lib.types.*
+
+internal class RestPresenceAdapter(private val legacyPresence: Presence) : RestPresence {
+  override fun get(params: List<Param>): PaginatedResult<PresenceMessage> = legacyPresence.get(params.toTypedArray())
+
+  override fun getAsync(params: List<Param>, callback: Callback<AsyncPaginatedResult<PresenceMessage>>) =
+    legacyPresence.getAsync(params.toTypedArray(), callback)
+
+  override fun history(params: List<Param>): PaginatedResult<PresenceMessage> =
+    legacyPresence.history(params.toTypedArray())
+
+  override fun historyAsync(params: List<Param>, callback: Callback<AsyncPaginatedResult<PresenceMessage>>) =
+    legacyPresence.historyAsync(params.toTypedArray(), callback)
+}