Update to use new Injectable implementation.

build.sbt

@@ -10,7 +10,8 @@ version := "0.1-SNAPSHOT"
 
 scalaVersion := "2.11.6"
 
-scalacOptions in Compile ++= Seq("-feature", "-language:implicitConversions", "-language:postfixOps", "-target:jvm-1.6")
+javacOptions ++= Seq("-source", "1.7", "-target", "1.7")
+scalacOptions in Compile ++= Seq("-feature", "-language:implicitConversions", "-language:postfixOps", "-target:jvm-1.7")
 platformTarget in Android := "android-21"
 
 resolvers += "Local Maven Repository" at "file://"+Path.userHome.absolutePath+"/.m2/repository"

project/plugins.sbt

@@ -1 +1 @@
-addSbtPlugin("com.hanhuy.sbt" % "android-sdk-plugin" % "1.3.18")
+addSbtPlugin("com.hanhuy.sbt" % "android-sdk-plugin" % "1.4.4")

src/main/scala/com/geteit/cache/CacheEntry.scala

@@ -2,12 +2,11 @@ package com.geteit.cache
 
 import java.io._
 
-import com.geteit.app.GtContext
-import com.geteit.inject.Injectable
 import com.geteit.util.IoUtils
 import com.geteit.util.Log._
+import com.geteit.inject.{Injectable, Injector}
 
-class CacheEntry(val data: CacheEntryData)(implicit context: GtContext) extends Injectable {
+class CacheEntry(val data: CacheEntryData)(implicit inj: Injector) extends Injectable {
   private implicit val logTag: LogTag = "CacheEntry"
 
   private lazy val service = inject[CacheService]

src/main/scala/com/geteit/cache/CacheService.scala

@@ -2,9 +2,9 @@ package com.geteit.cache
 
 import java.io._
 
-import com.geteit.inject.{Factory, GtSingleton, Injectable}
 import com.geteit.util.IoUtils
 import com.geteit.util.Log._
+import com.geteit.inject.{Injectable, Injector}
 
 import scala.concurrent.Future
 import scala.concurrent.duration._
@@ -18,7 +18,7 @@ object Expiration {
   implicit def in(d: Duration) : Expiration = if (d.isFinite()) Expiration(d.toMillis) else Expiration(100L * 3600L * 24L * 365L * 1000L) // 100 years (don't use Long.MaxValue due to overflow dangers)
 }
 
-class CacheService extends GtSingleton with Injectable {
+class CacheService(implicit inj: Injector) extends Injectable {
   private implicit val logTag: LogTag = "CacheService"
   import com.geteit.concurrent.Threading.global
 
@@ -99,6 +99,4 @@ class CacheService extends GtSingleton with Injectable {
 
 object CacheService {
   val DefaultExpiryTime = 7.days
-
-  implicit val factory = new Factory(_ => new CacheService)
 }

src/main/scala/com/geteit/cache/CacheStorage.scala

@@ -3,22 +3,23 @@ package com.geteit.cache
 import java.io.File
 import java.lang.System._
 
-import com.geteit.app.GtContext
+import android.content.Context
 import com.geteit.cache.CacheEntryData.CacheEntryDao
 import com.geteit.concurrent.Threading
-import com.geteit.db.{Storage, CachedStorage}
-import com.geteit.inject.{Factory, GtSingleton, Injectable}
+import com.geteit.db.{CachedStorage, Storage}
+import com.geteit.events.EventContext
 import com.geteit.util.Log._
 import com.geteit.util._
+import com.geteit.inject.{Injectable, Injector}
 
 import scala.concurrent.Future
 
-class CacheStorage extends CachedStorage[String, CacheEntryData] with GtSingleton with Injectable {
+class CacheStorage(implicit inj: Injector) extends CachedStorage[String, CacheEntryData] with Injectable {
   private implicit val logTag: LogTag = "CacheStorage"
+  private implicit val eventContext = inject[EventContext]
 
-  lazy val cacheDir = CacheStorage.cacheDir
+  lazy val cacheDir = CacheStorage.cacheDir(inject[Context])
 
-  override lazy val storage = inject[Storage]
   override protected val cache = new LruCache[String, Option[CacheEntryData]](512 *1024) {
     override def sizeOf(key: String, value: Option[CacheEntryData]): Int =
       value.flatMap(_.data).fold(0)(_.length) + key.length + 128 // data plus some object overhead
@@ -67,9 +68,7 @@ class CacheStorage extends CachedStorage[String, CacheEntryData] with GtSingleto
 }
 
 object CacheStorage {
-  implicit val factory = new Factory(_ => new CacheStorage)
-
-  def cacheDir(implicit context: GtContext) = returning(new File(Option(context.getExternalCacheDir).getOrElse(context.getCacheDir), "cache_entries")) { dir => dir.mkdirs() }
+  def cacheDir(context: Context) = returning(new File(Option(context.getExternalCacheDir).getOrElse(context.getCacheDir), "cache_entries")) { dir => dir.mkdirs() }
 
   def entryFile(cacheDir: File, uid: Uid) = new File(cacheDir, uid.str.take(2) + File.separator + uid.str)
 }

src/main/scala/com/geteit/db/CachedStorage.scala

@@ -7,18 +7,19 @@ import com.geteit.events
 import com.geteit.events.{EventObserver, EventContext, Signal}
 import com.geteit.util.Log._
 import com.geteit.util.ThrottledProcessingQueue
+import com.geteit.inject.{Injectable, Injector}
 
 import scala.collection.JavaConverters._
 import scala.collection.mutable
 import scala.concurrent.Future
 import scala.concurrent.duration._
 
-abstract class CachedStorage[K, V](implicit val dao: Dao[K, V]) {
+abstract class CachedStorage[K, V](implicit val dao: Dao[K, V], inj: Injector) extends Injectable {
   protected implicit val executionContext = new LimitedExecutionContext
 
   protected val cache: LruCache[K, Option[V]]
 
-  val storage: Storage
+  val storage: Storage = inject[Storage]
 
   val onAdded = new events.EventStream[V]
   val onRemoved = new events.EventStream[K]

src/main/scala/com/geteit/db/Storage.scala

@@ -2,7 +2,6 @@ package com.geteit.db
 
 import android.database.sqlite.{SQLiteDatabase, SQLiteOpenHelper}
 import com.geteit.concurrent.LimitedExecutionContext
-import com.geteit.inject.Factory
 import com.geteit.util.Log._
 import com.geteit.util.returning
 
@@ -34,6 +33,4 @@ trait Storage {
 
 object Storage {
   private implicit val tag: LogTag = "Storage"
-
-  implicit val factory = new Factory[Storage](_ => throw new UnsupportedOperationException("Injectable storage should be provided"))
 }

src/main/scala/com/geteit/image/ImageProvider.scala

@@ -5,27 +5,22 @@ import java.io.IOException
 import android.content.ContentResolver
 import android.graphics.Bitmap
 import android.net.Uri
-import com.geteit.app.GtContext
 import com.geteit.bitmap
 import com.geteit.cache.{CacheEntry, CacheService}
 import com.geteit.concurrent.{CancellableFuture, Threading}
-import com.geteit.inject.{Factory, GtContextSingleton, Injectable}
 import com.geteit.net.Response.SuccessHttpStatus
 import com.geteit.net._
 import com.geteit.util.Log._
 import com.geteit.util.Serialized
+import com.geteit.inject.{Injectable, Injector}
 
 import scala.util.control.NoStackTrace
 
 trait ImageProvider {
   def apply(uri: Uri, size: Int): CancellableFuture[(Bitmap, Boolean)]
 }
 
-object ImageProvider {
-  implicit val factory = new Factory[ImageProvider](new BasicImageProvider()(_))
-}
-
-class BasicImageProvider(implicit val context: GtContext) extends ImageProvider with GtContextSingleton with Injectable {
+class BasicImageProvider(implicit injector: Injector) extends ImageProvider with Injectable {
   private implicit val tag: LogTag = "ImageProvider"
   import Threading.image
 
@@ -56,7 +51,7 @@ class BasicImageProvider(implicit val context: GtContext) extends ImageProvider
       case None =>
         (uri.getScheme match {
           case ContentResolver.SCHEME_CONTENT =>
-            CancellableFuture.lift(cache.addStream(uri.toString, context.getContentResolver.openInputStream(uri))) flatMap resultFromCache
+            CancellableFuture.lift(cache.addStream(uri.toString, inject[ContentResolver].openInputStream(uri))) flatMap resultFromCache
           case "http" | "https" =>
             CancellableFuture.lift(cache.getEntry(uri.toString)) flatMap {
               case Some(entry) => loadCached(entry) flatMap {

src/main/scala/com/geteit/image/MemoryImageCache.scala

@@ -3,16 +3,17 @@ package com.geteit.image
 import android.app.ActivityManager
 import android.graphics.Bitmap
 import android.net.Uri
-import com.geteit.events.EventStream
-import com.geteit.inject.{Factory, GtSingleton, Injectable}
+import com.geteit.events.{EventContext, EventStream}
 import com.geteit.util.Log._
 import com.geteit.util.{GtAssert, LruCache}
+import com.geteit.inject.{Injectable, Injector}
 
 import scala.collection.mutable
 
-class MemoryImageCache extends GtSingleton with Injectable {
+class MemoryImageCache(implicit injector: Injector) extends Injectable {
 
     private implicit val tag: LogTag = "MemoryImageCache"
+    private implicit val eventContext = inject[EventContext]
 
     val onInvalidated = new EventStream[Uri]
 
@@ -74,7 +75,3 @@ class MemoryImageCache extends GtSingleton with Injectable {
         cache.put(url, bitmap)
     }
 }
-
-object MemoryImageCache {
-  implicit val factory = new Factory(_ => new MemoryImageCache)
-}

src/main/scala/com/geteit/inject/GtAppModule.scala

@@ -0,0 +1,18 @@
+package com.geteit.inject
+
+import com.geteit.cache.{CacheStorage, CacheService}
+import com.geteit.image.{BasicImageProvider, ImageProvider, MemoryImageCache}
+import com.geteit.net._
+
+object GtAppModule {
+
+  def apply() = Module { implicit bind =>
+    bind [MemoryImageCache] to new MemoryImageCache
+    bind [ImageProvider] to new BasicImageProvider
+    bind [CacheService] to new CacheService
+    bind [CacheStorage] to new CacheStorage
+    bind [AsyncClient] to new AsyncClient
+    bind [CookieStorage] to new MemoryCookieStorage
+    bind [ResponseBodyDecoder] to new DefaultResponseBodyDecoder
+  }
+}

src/main/scala/com/geteit/net/AsyncClient.scala

@@ -3,11 +3,11 @@ package com.geteit.net
 import java.net.ConnectException
 import java.util.concurrent.atomic.AtomicLong
 
+import android.content.Context
 import android.net.Uri
 import com.geteit.app.GtContext
 import com.geteit.concurrent.CancellableFuture.CancelException
 import com.geteit.concurrent.{CancellableFuture, LimitedExecutionContext}
-import com.geteit.inject.{Factory, GtSingleton, Injectable}
 import com.geteit.net.Request.ProgressCallback
 import com.geteit.net.Response.HttpStatus
 import com.geteit.util.Log._
@@ -16,21 +16,22 @@ import com.koushikdutta.async.callback.DataCallback.NullDataCallback
 import com.koushikdutta.async.callback.{CompletedCallback, DataCallback}
 import com.koushikdutta.async.http._
 import com.koushikdutta.async.http.callback.HttpConnectCallback
+import com.geteit.inject.{Injectable, Injector}
 
 import scala.concurrent.duration._
 import scala.concurrent.{Future, Promise}
 import scala.util.control.NonFatal
 import scala.util.{Failure, Success}
 
-class AsyncClient extends GtSingleton with Injectable {
+class AsyncClient(implicit inj: Injector) extends Injectable {
   import AsyncClient._
 
   implicit val dispatcher = new LimitedExecutionContext()
 
   lazy val cookies = inject[CookieStorage]
   lazy val bodyDecoder = inject[ResponseBodyDecoder]
 
-  lazy val userAgent = AsyncClient.userAgent
+  lazy val userAgent = AsyncClient.userAgent(inject[Context])
 
   val client = ClientWrapper { new AsyncHttpClient(new AsyncServer) }
 
@@ -156,9 +157,7 @@ object AsyncClient {
   val DefaultTimout = 5.minutes
   val EmptyHeaders = Map[String, String]()
 
-  implicit val factory = new Factory(_ => new AsyncClient)
-
-  def userAgent(implicit context: GtContext) = {
+  def userAgent(implicit context: Context) = {
     import android.os.Build._
     val appVersion = context.getPackageManager.getPackageInfo(context.getPackageName, 0).versionName
     s"${context.getPackageName}/$appVersion (Android ${VERSION.RELEASE}; $MANUFACTURER $MODEL)"

src/main/scala/com/geteit/net/CookieStorage.scala

@@ -5,7 +5,6 @@ import java.util.{Date, Locale, TimeZone}
 
 import android.net.Uri
 import com.geteit.concurrent.LimitedExecutionContext
-import com.geteit.inject.Factory
 import com.geteit.json.Json
 import com.geteit.net.CookieStorage.{Cookie, CookieSet}
 import com.geteit.util.Log._
@@ -42,9 +41,6 @@ class MemoryCookieStorage extends CookieStorage {
 }
 
 object CookieStorage {
-
-  implicit val factory = new Factory[CookieStorage](_ => new MemoryCookieStorage)
-
   @Json
   case class Cookie(key: String, value: String, expires: Date) {
     def expired = expires.before(new Date)

src/main/scala/com/geteit/net/Request.scala

@@ -5,7 +5,6 @@ import java.net.URLEncoder
 
 import android.net.Uri
 import android.net.http.AndroidHttpClient
-import com.geteit.app.GtContext
 import com.geteit.net.ContentEncoder.{EmptyContentEncoder, EmptyRequestContent, RequestContent}
 import com.geteit.net.Request.ProgressCallback
 import com.geteit.util.{IoUtils, _}
@@ -14,6 +13,7 @@ import com.koushikdutta.async.http.AsyncHttpRequest
 import com.koushikdutta.async.http.body.{AsyncHttpRequestBody, MultipartFormDataBody}
 import com.koushikdutta.async.{DataEmitter, DataSink, Util}
 import org.json.JSONObject
+import com.geteit.inject.Injector
 
 import scala.concurrent.duration._
 
@@ -54,7 +54,7 @@ object Request {
   def Get(uri: Uri, callback: Option[ProgressCallback] = None, headers: Map[String, String] = EmptyHeaders) =
     Request[Unit](uri, GetMethod, callback = callback, headers = headers)(EmptyContentEncoder)
 
-  def RangeGet(uri: Uri, range: RangeSpec, dst: File, callback: Option[ProgressCallback] = None, headers: Map[String, String] = EmptyHeaders)(implicit context: GtContext) = {
+  def RangeGet(uri: Uri, range: RangeSpec, dst: File, callback: Option[ProgressCallback] = None, headers: Map[String, String] = EmptyHeaders)(implicit inj: Injector) = {
     Request[Unit](uri, GetMethod, callback = callback, headers = headers + RangeSpec(range), decoder = Some(new RangeResponseBodyDecoder(dst)))(EmptyContentEncoder)
   }
 

src/main/scala/com/geteit/net/Response.scala

@@ -2,12 +2,13 @@ package com.geteit.net
 
 import java.io.File
 
+import android.content.Context
 import com.geteit.app.GtContext
 import com.geteit.cache.CacheService
-import com.geteit.inject.{Factory, Injectable}
 import com.geteit.net.ResponseConsumer._
 import com.geteit.util.Log._
 import com.koushikdutta.async.http.{Headers => KoushHeaders}
+import com.geteit.inject.{Injectable, Injector}
 
 case class Response(
                      status: Response.Status,
@@ -115,7 +116,7 @@ trait ResponseBodyDecoder {
   def apply(headers: KoushHeaders, contentLength: Long): ResponseConsumer[_ <: ResponseContent]
 }
 
-class DefaultResponseBodyDecoder(implicit context: GtContext) extends ResponseBodyDecoder with Injectable {
+class DefaultResponseBodyDecoder(implicit inj: Injector) extends ResponseBodyDecoder with Injectable {
   val TextContent = "text/.*".r
   val JsonContent = "application/json.*".r
   val ImageContent = "image/.*".r
@@ -135,7 +136,7 @@ class DefaultResponseBodyDecoder(implicit context: GtContext) extends ResponseBo
   }
 }
 
-class RangeResponseBodyDecoder(dst: File)(implicit context: GtContext) extends DefaultResponseBodyDecoder {
+class RangeResponseBodyDecoder(dst: File)(implicit inj: Injector) extends DefaultResponseBodyDecoder {
   private implicit val tag: LogTag = "RangeResponseBodyDecoder"
 
   override def apply(headers: KoushHeaders, contentLength: Long): ResponseConsumer[_ <: ResponseContent] = {
@@ -148,7 +149,3 @@ class RangeResponseBodyDecoder(dst: File)(implicit context: GtContext) extends D
     }
   }
 }
-
-object ResponseBodyDecoder {
-  implicit val factory = new Factory[ResponseBodyDecoder](new DefaultResponseBodyDecoder()(_))
-}