Positronic Net

Better brains for your droids!

--- Robert Thau

Goals

Eliminate boilerplate --- in UI code and elsewhere
Eliminate clutter --- focus on the essentials
- Convention over configuration
Make it easy to store and organize the data you're working on
- Adopt representations that fit the problem space
- Following best practices should not be a pain

What's that got to do with Scala?

I've got a library which helps with some of this stuff
Uses Scala as a JVM-native language which...
- Eliminates type-related clutter
- Supports control abstraction
- Supports useful concurrency-related idioms

Outline

A few words on Android
Dealing with UI boilerplate
- Callbacks with less pain
- Easier binding of UI components to data structures
Dealing with data repositories
- Dealing with Android requirements
- Records and record managers
- Messaging for interfaces and updates
- Relations, type hierarchies...

A few words on Android

It's Java-ish. Mostly J2SE, but...

Custom bytecodes. (Anything involving a ClassLoader breaks.)
Custom UI layer (not Swing or AWT-based)
Custom interface to SQLite (not JDBC)
Custom RPC framework for invoking other apps, and sharing tables of data
Compared to a server, resources are... constrained.

Android UI

Widgets: TextView, Checkbox, ImageView...
Layout managers: LinearLayout, RelativeLayout...
List widgets and adapters
- Adapter's job: "fill in widgets for item n"
All access to UI is restricted to one thread

UI Goals

Cut down on boilerplate
Ease showing and updating data items

Cut down on boilerplate: not this...

textView.setOnKeyListener{
   new OnKeyListener {
     def onKey(v: View, keyCode: Int, ev: KeyEvent):Boolean={
       if (keyCode == KeyEvent.KEYCODE_ENTER
           && ev.getAction == KeyEvent.ACTION_DOWN)
       {
         addItem
         return true
       }
       return false
    }}}

... but this:

textView.onKey( KeyEvent.KEYCODE_ENTER ){
  addItem
}

A whole screen:

findView( TR.listItemsView ).setAdapter( 
  new IndexedSeqSourceAdapter(
    this, TodoItems,
    itemViewResourceId = 
       android.R.layout.simple_list_item_1 )

findView( TR.listItemsView ).onItemClick{ 
  (view, posn, id) =>
    TodoItems ! Delete( adapter.getItem( posn ))
}

findView( TR.addButton ).onClick { addItem }
findView( TR.newItemText )
   .onKey( KeyEvent.KEYCODE_ENTER ){ addItem }

def addItem = {
  val text = findView( TR.newItemText ).getText.toString.trim
  if (text != "") {
    TodoItem ! Save( new TodoItem( text ))
    findView( TR.newItemText ).setText( "" )
  }}

Another example:


val accounts: Array[android.accounts.Account] = ...
val title = R.string.choose_account_for_contact

withChoiceFromDialog[ Account ]( title, accounts, _.name ){
  acct => createContactForAccount( acct )
}

Mapping data structures to the UI

 case class StructuredName (
   prefix: String,
   firstName: String,
   middleName: String
   familyName: String,
   suffix: String,
   ...
 )

Want to make things simple...

Setting firstName from firstName, etc., should not require much fuss: val myName: StructuredName = ... MyUiBinder.show( myName, findView( TR.nameGroup )) val newName = MyUiBinder.update( myName, findView( TR.nameGroup ))

But that requires:

Being able to say what "property" a widget relates to
Being able to get or set "properties" on the record

Where do those widgets come from?

<LinearLayout android:id="@+id/nameGroup" ...>
   ...
   <EditText android:id="@+id/firstName"
             android:layout_... />
   <EditText android:id="@+id/familyName"
             android:layout_... />
   ...
</LinearLayout>

Widget properties...

Widgets can have IDs...
... which are integers ...
... which are the value of R.id.propName
So, use reflection to construct a map from values back to names.

Properties/lenses

      case class PropertyLens[T,V](
        getter: T => V,
        setter: (T,V) => T
      )

      case class StructuredName ( firstName: String, ... )

      val fnameLens = new PropertyLens[ StructuredName, String ](
        (_.firstName),
        (_.copy( firstName = _ )))

      val myName: StructuredName = ...
      val firstName: String = fnameLens.getter( myName )
      val newName: StructuredName = fnameLens.setter( myName, "Aloysius" )

Lens factories

      case class StructuredName ( firstName: String, ... )
      extends ReflectiveProperties

      val factory = PropertyLensFactory.forPropertyType[ String ]
      val myLensOpt: Option[ PropertyLens[ StructuredName, String ]]
        = factory.forProperty( classOf[ StructuredName ], "firstName" )

"Reflective properties": explicit getter/setter

      case class Foo( x: String )
        extends ReflectiveProperties
      {
        def x_:=( s: String ) = this.copy( x = s )
      }

"Reflective properties": implicit setter

      case class Foo( x: String )
        extends ReflectiveProperties
      {
        // def x_:=( s: String ) = this.copy( x = s )
      }

No explicit setter
As if copy is called, but...
Implementation clones the instance and clobbers the value. Exploiting this can be dangerous, but also useful.

UI binders

object MyUiBinder extends UiBinder {

  bindProperties[ TextView, String ](
    (_.getText.toString), (_.setText( _ )))
         
  bindProperties[ CheckBox, Boolean ](
    (_.isChecked), (_.setChecked( _ )))
}

val myName: StructuredName = ...

MyUiBinder.show( myName, findView( TR.nameGroup ))
val newName = MyUiBinder.update( myName, findView( TR.nameGroup ))

Binds properties of appropriate types to widgets with "matching" IDs.

Dealing with Data

Platform constraints
Platform data repositories
Queries and updates
Relations
Other stuff...

Android UI --- DB constraints

All access to UI is restricted to one thread
Locking that thread locks up the UI

Implications

UI will stutter or freeze if "UI thread" blocks for...

... queries ...
... updates ...
... net access ...

So, don't do that!

How to do blocking work in the background?

Android provides basic machinery:

Can "post work" to be executed on the UI thread...
... or other "handler threads".

But library mechanisms built on top of it can be awkward

So, borrow some better alternatives

Want UI thread (and others?) to be able to defer work to background, and have results posted back when available
Sounds like Actors, Messages and Futures
Don't want to put full Akka on the phones (yet?)...
... but a much cut-down version is still very useful.

Data repositories on Android

Private SQLite databases, through a custom API
"Content Provider"s, which do RPC to another process
Both have ...similar query interfaces
... which return instances of the same Cursor interface
So, can design a quasi-ORM which works for both

Basic concepts

Want UI to do queries and updates through messaging with actor-like entities
Records are in messages both ways (inserts, queries)...
... so they must be immutable

Example: some simple data

object TodoDb extends Database( filename = "todos.sqlite3" ) 
{
  def schemaUpdates =
    List(""" create table todo_items (
               _id integer primary key,
               description string,
               is_done integer default 0
             )
         """
       )
}

Records ...

case class TodoItem( description: String             = null, 
                     isDone:      Boolean            = false,
                     id:          RecordId[TodoItem] = TodoItems.unsavedId
                   )
  extends ManagedRecord

Records ... and RecordManagers

case class TodoItem( description: String ... )
  extends ManagedRecord

object TodoItems extends RecordManager[ TodoItem ]( TodoDb( "todo_items" ))
{
  // This explicitly writes out default behavior...
  mapField( "_id",         "id",          MapAs.ReadOnly  )
  mapField( "isDone",      "is_done",     MapAs.ReadWrite )
  mapField( "description", "description", MapAs.ReadWrite )
}

Futures

      val myFut: Future[T] = ...

      myFut.onSuccess{ t: T => ... }
      myFut.onFailure{ ex: Exception => ... }

Scopes and Futures

val allItemsFut: Future[ IndexedSeq[ TodoItem ]] = 
  TodoItems ? Query

allItemsFut.onSuccess{ items => ... }

(TodoItems ? FindById( myId )).onSuccess{ item => ... }

val sortedDoneItemsScope: Scope[ TodoItem ] = 
  TodoItems.whereEq( "isDone", true ).order( "description" )

(sortedDoneItemsScope ? Query).onSuccess{ items => ... }

val dogItemScope = 
  TodoItems.where( "description like '%dog%'" )

Updates

val myItem = TodoItem( ... )
TodoItems ! Save( myItem )      // inserts new record

(TodoItems ? FindById( someId )).onSuccess {
  item =>
   val new Item = somehowDink( item )
   TodoItems ! Save( myItem )   // updates existing record
}

TodoItems ! Delete( myItem )
TodoItems.whereEq( ... ) ! DeleteAll

(Partial) Message typing

A Query on TodoItems always yields IndexedSeq[TodoItem]...
... so we shouldn't have to declare type of the future
Same for FindById --- which returns a different type of Future
Type: QueryAction[ IndexedSeq[T], V ] --- different Vs
For Query, V is IndexedSeq[T]
For FindById, V is just T

Simple relationships --- schema

object TodoDb extends Database( filename = "todos.sqlite3" ) 
{
  def schemaUpdates =
    List(""" create table todo_items( ... ) """,
         """ create table todo_lists( 
               _id integer primary key,
               name string ) """,
         """ alter table todo_items 
               add column todo_list_id integer """
       )
}

Simple relationships --- code

case class TodoItem(
  val todoListId: RecordId[TodoList] = TodoLists.unsavedId,
  ...
) extends ManagedRecord

case class TodoList(
  val id: RecordId[TodoList] = TodoLists.unsavedId,
  val name: String,

  // The following gives you a Scope[ TodoItem ] when you ask for it...

  @transient lazy val items = new HasMany( TodoItems )
)

Mapping a simple content provider (1)

case class CallLogEntry( 
  callType:   Int    = 0, 
  number:     String = null, 
  cachedName: String = null, 
  whenRaw:    Long   = 0,
  id:         RecordId[CallLogEntry] = CallLogEntries.unsavedId 
)
extends ManagedRecord
{
  lazy val when = new Date( whenRaw )
  def when_:=( d: Date ) = this.copy( whenRaw = d.getTime )
}

Mapping a simple content provider (2)

import android.provider.CallLog.Calls

val callsRepository = PositronicContentResolver( Calls.CONTENT_URI )

object CallLogEntries
  extends RecordManagerForFields[ CallLogEntry, Calls ]( 
    callsRepository.order( Calls.DEFAULT_SORT_ORDER ))
{
  mapField( "callType", Calls.TYPE ) // override to avoid reserved word 'type'
  mapField( "whenRaw",  Calls.DATE ) // here we're just being different
}

A messy provider: ContactsContract.Data

Heterogeneous table representing name, phone, email...
Common "contact ID" and "type" columns
"data1" ... "data15", whose interpretation depends on the type

Data base class (simplified)...

abstract class ContactData
  extends ManagedRecord with ReflectiveProperties with Serializable
{
  // Generic fields...

  val rawContactId:   RecordId[ RawContact ]
  val isPrimary:      Boolean
  ...
}

Data subclass: StructuredName

case class StructuredName (

  val id:             RecordId[ StructuredName ] = ContactData.names.unsavedId

  val rawContactId:   RecordId[ RawContact ]     = RawContacts.unsavedId
  val isPrimary:      Boolean                    = false
  val dataVersion:    Int                      = -1 // read-only

  val firstName:      String = null
  val lastName:       String = null
  ...  
)
extends ContactData

Data subclass: Photo

case class Photo (

  val id:             RecordId[ StructuredName ] = ContactData.names.unsavedId

  val rawContactId:   RecordId[ RawContact ]     = RawContacts.unsavedId
  val isPrimary:      Boolean                    = false
  val dataVersion:    Int                      = -1 // read-only

  val photoBits:      Array[Byte] = null
  ...  

  @transient lazy val thumbnailBitmap =
    BitmapFactory.decodeByteArray( photoBits, 0, photoBits.length )
)
extends ContactData

Variant record managers

import android.provider.ContactsContract
import android.provider.ContactsContract.CommonDataKinds

object ContactData
  extends VariantRecordManager[ ContactData ](
    PositronicContentResolver( ContactsContract.Data.CONTENT_URI ),
    "mimetype" // documented value of ContactsContract.DataColumns.MIMETYPE
  )
{
  val names =
    new TaggedVariantForFields[StructuredName, CommonDataKinds.StructuredName](
      CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE
    )
  
  val photos =
    new TaggedVariantForFields[ Photo, CommonDataKinds.Photo ](
      CommonDataKinds.Photo.CONTENT_ITEM_TYPE
    )

  ...
}

Other stuff

Shorthand for other platform components (app lifecycle, invoking other apps)
"Notifications" framework
... and unrestricted access to the full platform API, if Positronic Net has no wrapper, or you just don't like it.

To find more...

https://github.com/rst/positronic_net
https://rst.github.com/positronic_docs.html