Add new techstackskotlin port of techstacks Android App in Kotlin with Kotlin dtos

Author: mythz

src/AndroidClient/.idea/gradle.xml

@@ -1,2 +1,2 @@
-include ':app', ':client', ':android', ':techstacks', ':kotlin'
+include ':app', ':client', ':android', ':techstacks', ':kotlin', ':techstackskotlin'
 

src/AndroidClient/.idea/modules.xml

@@ -0,0 +1 @@
+/build

src/AndroidClient/settings.gradle

@@ -0,0 +1,46 @@
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.2"
+
+    defaultConfig {
+        applicationId "test.servicestack.net.techstackskotlin"
+        minSdkVersion 16
+        targetSdkVersion 23
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    sourceSets {
+        main.java.srcDirs += 'src/main/kotlin'
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    testCompile 'junit:junit:4.12'
+    compile 'com.android.support:appcompat-v7:23.1.1'
+    compile 'com.android.support:design:23.1.1'
+    compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    compile project(':android')
+    compile 'com.squareup.picasso:picasso:2.5.2'
+}
+buildscript {
+    ext.kotlin_version = '1.0.0-beta-3595'
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+repositories {
+    mavenCentral()
+}

src/AndroidClient/techstackskotlin/.gitignore

@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in C:\Users\mythz\AppData\Local\Android\sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}

src/AndroidClient/techstackskotlin/build.gradle

@@ -0,0 +1,9 @@
+package servicestack.net.techstackskotlin
+
+import android.app.Application
+import android.test.ApplicationTestCase
+
+/**
+ * [Testing Fundamentals](http://d.android.com/tools/testing/testing_android.html)
+ */
+class ApplicationTest : ApplicationTestCase<Application>(Application::class.java)

src/AndroidClient/techstackskotlin/proguard-rules.pro

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="servicestack.net.techstackskotlin" >
+
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/logo_transparent"
+        android:label="@string/app_name"
+        android:theme="@style/AppTheme" >
+        <activity
+            android:name=".MainActivity"
+            android:label="TechStacks (Kotlin)" >
+            <intent-filter android:label="@string/app_name">
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".TechnologyActivity"
+            android:label="Technology" >
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".TechStackActivity"
+            android:label="TechStack" >
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

src/AndroidClient/techstackskotlin/src/androidTest/java/servicestack/net/techstackskotlin/ApplicationTest.kt

@@ -0,0 +1,209 @@
+package servicestack.net.techstackskotlin
+
+import android.app.Activity
+import android.content.Intent
+import android.graphics.Bitmap
+import android.net.Uri
+import net.servicestack.android.AndroidServiceClient
+import net.servicestack.android.AndroidUtils
+import net.servicestack.client.AsyncResult
+import net.servicestack.client.Utils
+import java.util.*
+
+class App {
+
+    internal var client: AndroidServiceClient
+    var appData: AppData
+
+    init {
+        client = AndroidServiceClient("http://techstacks.io")
+        appData = AppData(client)
+    }
+
+    class AppData(internal var client: AndroidServiceClient) {
+
+        internal var listeners = ArrayList<AppDataListener>()
+
+        fun addListener(callback: AppDataListener): AppData {
+            if (!listeners.contains(callback)) {
+                listeners.add(callback)
+            }
+            return this
+        }
+
+        fun onUpdate(dataType: DataType) {
+            for (listener in listeners) {
+                listener.onUpdate(this, dataType)
+            }
+        }
+
+        fun loadAppOverview(): AppData {
+            if (appOverviewResponse != null) {
+                onUpdate(DataType.AppOverview)
+            }
+            client.getAsync(AppOverview(), object : AsyncResult<AppOverviewResponse>() {
+                override fun success(response: AppOverviewResponse) {
+                    appOverviewResponse = response
+                    onUpdate(DataType.AppOverview)
+                }
+            })
+            return this
+        }
+
+        var appOverviewResponse: AppOverviewResponse? = null
+            internal set
+
+        internal var lastTechStacksQuery: String? = null
+
+        fun searchTechStacks(query: String): AppData {
+            if (searchTechStacksResponse != null && Utils.equals(query, lastTechStacksQuery)) {
+                onUpdate(DataType.SearchTechStacks)
+            }
+
+            lastTechStacksQuery = query
+            client.getAsync(FindTechStacks(),
+                    Utils.createMap("NameContains", query, "DescriptionContains", query),
+                    object : AsyncResult<QueryResponse<TechnologyStack>>() {
+                        override fun success(response: QueryResponse<TechnologyStack>) {
+                            if (Utils.equals(query, lastTechStacksQuery)) {
+                                searchTechStacksResponse = response
+                                onUpdate(DataType.SearchTechStacks)
+                            }
+                        }
+                    })
+
+            return this
+        }
+
+        var searchTechStacksResponse: QueryResponse<TechnologyStack>? = null
+            internal set
+
+        internal var lastTechnologiesQuery: String? = null
+
+        fun searchTechnologies(query: String): AppData {
+            if (searchTechnologiesResponse != null && Utils.equals(query, lastTechnologiesQuery)) {
+                onUpdate(DataType.SearchTechnologies)
+            }
+
+            lastTechnologiesQuery = query
+            client.getAsync(FindTechnologies(),
+                    Utils.createMap("NameContains", query, "DescriptionContains", query),
+                    object : AsyncResult<QueryResponse<Technology>>() {
+                        override fun success(response: QueryResponse<Technology>) {
+                            if (Utils.equals(query, lastTechnologiesQuery)) {
+                                searchTechnologiesResponse = response
+                                onUpdate(DataType.SearchTechnologies)
+                            }
+                        }
+                    })
+
+            return this
+        }
+
+        var searchTechnologiesResponse: QueryResponse<Technology>? = null
+            internal set
+
+        var technology: GetTechnologyResponse? = null
+            internal set
+
+        fun loadTechnology(slug: String) {
+            if (technology != null) {
+                onUpdate(DataType.Technology)
+            }
+
+            val request = GetTechnology()
+            request.Slug = slug
+            client.getAsync(request,
+                object : AsyncResult<GetTechnologyResponse>() {
+                    override fun success(response: GetTechnologyResponse) {
+                        technology = response
+                        onUpdate(DataType.Technology)
+                    }
+                })
+        }
+
+        var techStack: GetTechnologyStackResponse? = null
+            internal set
+
+        fun loadTechStack(slug: String) {
+            if (techStack != null) {
+                onUpdate(DataType.TechStack)
+            }
+
+            val request = GetTechnologyStack()
+            request.Slug = slug
+            client.getAsync(request,
+                    object : AsyncResult<GetTechnologyStackResponse>() {
+                        override fun success(response: GetTechnologyStackResponse) {
+                            techStack = response
+                            onUpdate(DataType.TechStack)
+                        }
+                    })
+        }
+
+        internal var imgCache = HashMap<String, Bitmap>()
+        fun loadImage(imgUrl: String, callback: ImageResult) {
+            val img = imgCache[imgUrl]
+            if (img != null) {
+                callback.success(img)
+                return
+            }
+
+            client.getAsync(imgUrl, object : AsyncResult<ByteArray>() {
+                override fun success(imgBytes: ByteArray) {
+                    val img = AndroidUtils.readBitmap(imgBytes)
+                    imgCache.put(imgUrl, img)
+                    callback.success(img)
+                }
+            })
+        }
+    }
+
+    interface AppDataListener {
+        fun onUpdate(data: AppData, dataType: DataType)
+    }
+
+    interface ImageResult {
+        fun success(img: Bitmap)
+    }
+
+    enum class DataType {
+        AppOverview,
+        SearchTechStacks,
+        SearchTechnologies,
+        Technology,
+        TechStack
+    }
+
+    companion object {
+
+        var Instance = App()
+
+        fun get(): App {
+            return Instance
+        }
+
+        val data: AppData
+            get() = get().appData
+
+        fun openTechStack(activity: Activity, slug: String?) {
+            if (slug == null) return
+            val openTechStack = Intent(activity, TechStackActivity::class.java)
+            openTechStack.putExtra("slug", slug)
+            activity.startActivity(openTechStack)
+        }
+
+        fun openTechnology(activity: Activity, slug: String?) {
+            if (slug == null) return
+            val openTechnology = Intent(activity, TechnologyActivity::class.java)
+            openTechnology.putExtra("slug", slug)
+            activity.startActivity(openTechnology)
+        }
+
+        fun openUrl(activity: Activity, url: String?) {
+            if (url == null) return
+            activity.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url)))
+        }
+    }
+
+}