{"id":714,"date":"2017-06-05T09:29:41","date_gmt":"2017-06-05T09:29:41","guid":{"rendered":"http:\/\/smartfoxserver.com\/blog\/?p=714"},"modified":"2017-06-05T09:38:53","modified_gmt":"2017-06-05T09:38:53","slug":"kotlin-and-smartfoxserver-2x-part-2","status":"publish","type":"post","link":"https:\/\/smartfoxserver.com\/blog\/kotlin-and-smartfoxserver-2x-part-2\/","title":{"rendered":"Kotlin and SmartFoxServer 2X, part 2"},"content":{"rendered":"

In the last article<\/a> we’ve introduced\u00a0Kotlin, a modern language for the JVM and now a Google approved\u00a0language for Android development. We have shown how simple it is to use Kotlin on the server side to develop SmartFoxServer Extensions.<\/p>\n

Now it’s the time to see how to integrate the SFS2X Java API with Kotlin to build a client application.<\/p>\n

\u00bb Setting up the project<\/h2>\n

In the previous episode we have talked about\u00a0 Jetbrain\u2019s IntelliJ<\/a>, a multi-language IDE that is also provided\u00a0as a\u00a0\u201cCommunity Edition\u201d, free of charge. This is the easiest way to get started, as the IDE supports Java and Kotlin out of the box without additional downloads.<\/p>\n

We also need\u00a0a copy of the latest SmartFoxServer client API for Java<\/a>, which we will unzip in a folder of our choice. Once IntelliJ is installed we can go ahead and create a new project, from File<\/strong> > New<\/strong> > Project<\/strong>, choose Kotlin (Java)<\/strong> as the project type and continue\u00a0with the procedure.<\/p>\n

Next,\u00a0we need to add the SFS2X client API to our project: right-click on the project’s name, select Open Module\u00a0Settings<\/strong>, and select the Libraries<\/strong>\u00a0item from the left-side column. From the second column click the plus (+) sign<\/strong> and navigate to the folder where you have previously \u00a0unzipped the API.<\/p>\n

\"kot-client-step1\"<\/a><\/p>\n

\u00bb\u00a0A basic Kotlin\/SFS2X client<\/h2>\n

We can now write our client code:<\/p>\n

\r\nimport sfs2x.client.SmartFox\r\nimport sfs2x.client.core.BaseEvent\r\nimport sfs2x.client.core.IEventListener\r\nimport sfs2x.client.core.SFSEvent\r\nimport sfs2x.client.requests.LoginRequest\r\nimport sfs2x.client.util.ConfigData\r\n\r\nclass SFSEventListener : IEventListener\r\n{\r\n    override fun dispatch(evt: BaseEvent?)\r\n    {\r\n        when (evt?.type)\r\n        {\r\n            SFSEvent.CONNECTION -> onConnection(evt)\r\n            SFSEvent.CONNECTION_LOST -> println("Connection lost")\r\n            SFSEvent.LOGIN -> println("Logged in as: ${sfs.mySelf.name}")\r\n            SFSEvent.LOGIN_ERROR ->\r\n            {\r\n                val errorMsg = evt.arguments.get("errorMessage");\r\n                println("Login failed: ${errorMsg}")\r\n            }\r\n        }\r\n    }\r\n\r\n    fun onConnection(evt:BaseEvent)\r\n    {\r\n        val success = evt.arguments.get("success") as Boolean\r\n\r\n        if (success)\r\n        {\r\n            println("Connected to server...")\r\n            sfs.send(LoginRequest("", "", cfg.zone))\r\n        }\r\n\r\n        else println("Connection failed!")\r\n    }\r\n}\r\n\r\nval sfs = SmartFox()\r\nval cfg = ConfigData()\r\nval listener = SFSEventListener()\r\n\r\nfun main(args: Array<String>)\r\n{\r\n    println("SFS2X API Version: ${sfs.version}")\r\n\r\n    cfg.host = "127.0.0.1"\r\n    cfg.port = 9933\r\n    cfg.zone = "BasicExamples"\r\n\r\n    sfs.setClientDetails("Kotlin", "")\r\n    sfs.addEventListener(SFSEvent.CONNECTION, listener)\r\n    sfs.addEventListener(SFSEvent.CONNECTION_LOST, listener)\r\n    sfs.addEventListener(SFSEvent.LOGIN, listener)\r\n    sfs.addEventListener(SFSEvent.LOGIN_ERROR, listener)\r\n\r\n    \/\/ Start connection\r\n    sfs.connect(cfg)\r\n}\r\n<\/pre>\n
Before we start with the main()<\/strong> method notice a few stark\u00a0differences with Java. We don’t have to enclose our main() method and variables in a class.\u00a0This approach resembles\u00a0more dynamic languages such as Python or Javascript, at least on the surface.<\/p>\n
You can also notice that\u00a0variables can be declared in an apparently type-less fashion using the val<\/strong> or var\u00a0<\/strong>keywords. The former represents\u00a0an immutable value (equivalent to Java’s final <\/strong>modifier) while the latter is used for mutable values.<\/p>\n
We said\u00a0that this approach is “apparently type-less” because in reality it isn’t. Kotlin is a statically typed language that supports type inference<\/a>, which means that the compiler will auto-detect what types are being used even without explicit declaration. In those rare exceptions where type detection is not possible an error will be generated.\u00a0In any case we can always be explicit with our type declarations using this syntax:<\/p>\n
val sfs:SmartFox = SmartFox()<\/pre>\n
(Also notice how objects are instantiated without the use of the new<\/strong> keyword, as in Java)<\/p>\n
With this out of the way we can now go back to our main()<\/strong> method. The first line outputs the version of the API in use. Here we can see another interesting feature in Kotlin:\u00a0string templates<\/a>, which allows to write complex expressions directly in a string without the need for concatenation or placeholders.<\/p>\n
The rest of the code should be\u00a0straightforward: we set up the basic settings for the connection and add several event listeners, all pointing to the same instance of our SFSEventListener<\/strong> class. This in turn overrides the dispatch()<\/strong> method, just like in Java, and uses a\u00a0when <\/strong>block<\/a>\u00a0to dispatch different events to their handlers. You can think of this as the equivalent of the\u00a0switch<\/strong> statement in Java.<\/p>\n
Finally in the when<\/strong> block we have used a mix of lambdas and method references to show that both are supported, just like in Java 8 and most modern languages supporting the functional paradigm.<\/p>\n
In a nutshell, for those not entirely familiar with these concepts:<\/p>\n