About me

About you?

?

About this session

• Do ask questions whenever you feel like it!
• Scala is Simple, but Hard.
• Some presented topics are really advanced.

Scala...

Scala...

• is a Functional language
• ... and Object Oriented language
• ... that runs on the JVM
• ... so, it compiles down to Bytecode
• ... so, it can run on Android!

The basics first!

Variables vs. Values

val conference = "Mobilizejszon"
// conference = "mobilization" // compile error val == "java final"

var age = 90
age = 2
// age = "trolololo!" // compile error String != Int

val name: String = "Mobilization"

val name: String = "Mobilization"   ; // yay semicolons, GREAT!!!

From POJO...

public class Person {
  private String name;
  private String surname;

  public Person(String name, String surname) {
    this.name = name;
    this.surname = surname;
  }

  public String getName() { return name; }
  public void setName(String name) { this.name = name; }

  public String getSurname() { return surname; }
  public void setSurname(String surname) { this.surname = surname; }

  @Override
  public String toString() { /*...*/ }
}
                

class Person(name: String, surname: String)

Case class

case class Person(name: String, age: Int)

• has toString,
• has hashCode, equals and more scala specific things...

Collections

 List<String> girls = FluentIterable
   .from(people)
   .filter(new Predicate<Person>() {
     @Override
     public boolean apply(Person person) {
       return person != null && person.isWoman();
     }
   })
   .transform(new Function<Person, String>() {
     @Override
     public String apply(Person input) {
       return input.getFirstName() + " " + input.getLastName();
     }
   })
   .toImmutableList();

   for(String name : names)
    println(String.format("Hello %s!", name);

       // PS: DON'T call format on Android!

Embrace Scala Collections

people.filter(_.isWoman)

people.filter(_.isWoman).map(_.name)

people.filter(_.isWoman).map(_.name).foreach(greet _)

def greet(name: String) = println("Hello " + name + "!")

people filter { _.isWoman } map { _.name } foreach { n => greet _ } 

people foreach println

Scala collections == Immutable

• Immutability rocks
• thread-safe by design
• no need for manual defensive copy

• val bothSets: Set[String] = set ++ anotherSet

  and others...

Let's roll

findById

<Button
  android:id="@+id/my_button"
  android:layout_width="wrap_content"
  android:layout_height="wrap_content"
  android:text="@string/my_button_text">

class MyActivity extends Activity {

  ListView comments;
  Button newComment;

  @Override
  void onCreate(Bundle bundle) {
    super.onCreate(bundle);
    comments = (ListView) findViewById(R.id.comments);
    newComment = (Button) findViewById(R.id.new_comment);
  }
}
              

findView + TR

class MyScalaActivity extends ScalaActivity {

  lazy val Comments = findView(TR.comments)
  lazy val NewComment = findView(TR.new_comment)

  // with Types!
}

Lazy values

var thing = 0

lazy val incrementInLazyVal = { thing += 1; thing }

thing = 100
incrementInLazyVal
incrementInLazyVal
incrementInLazyVal

assert { thing == 101 && incrementInLazyVal == 101 }
            

var thing = 0

val incrementInVal = { thing += 1; thing }

thing = 100
incrementInVal
incrementInVal
incrementInVal

assert { thing == 1 && incrementInVal == 1 }

Calling methods without ()

var thing = 0

def incrementDef() = { thing += 1; thing }

incrementDef()
incrementDef
incrementDef

assert { thing == 3 }

def something = 1337

something // OK
something() // compile error

Traits

• is "An interface with implementation".
• can be "mixed in"
• MANY traits can be mixed into one single class
• it's NOT "just multiple inheritance", it's smarter:
• "type linearization" avoids the "diamond problem"

Traits

trait SayVerb {
  // some magic here... Comes after the next few slides ;-)

  def sayAwesome() = "Awesome!".toast() // make a toast!
  def sayAmazing() = "Amazing!".toast()
}

trait Logging { /* logging impl */ }

class MyActivity extends Activity
  with SayVerb
  with Logging

Same Menu, Many Activities

public class ActivityA extends Activity {
  @Override
  public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.game_menu, menu);
    return true;
  }
}

public class ActivityB extends Activity {
  @Override
  public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.game_menu, menu);
    return true;
  }
}

trait GameMenu

trait GameMenu extends Activity {
  override onCreateOptionsMenu(menu: Menu) = {
    getMenuInflater.inflate(R.menu.game_menu, menu)
    true
  }
}

class ActivityA extends Activity
  with GameMenu {
    /*...*/
}


class ActivityB extends SomethingFromAFrameworkActivity
  with GameMenu {
    /*...*/
}

A trait for ContentView

trait ContentView extends Activity with TypedActivity {

  // force the user to implement this "method? / field?"
  def ContentView: TypedLayout

  override def onCreate(bundle: Bundle) {
    setContentView(ContentView.id)
    super.onCreate(bundle)
  }
} 

with ContentView

class LoginActivity extends ScalaActivity
  with ViewListenerConversions
  with ContentView {

  // we implement the def ContentView with a value!
  val ContentView = TR.layout.login
}

Mix and match

object Dictionary extends Logging
  with TimedVerb
  with RetryVerb
  with DoToVerb
  with UniquifyVerb

def things() {
  import Dictionary._
  // use this dictionaty
}

Pimp my Library!

"Hello world!".toast

Implicit Conversions

// Scala "magic" here
val it: java.lang.String = "Hello %s!"

it.format("Łódź")        == "Hello Łódź!"

implicit def string2richString(s: String) = new RichString(s)

// String -> RichString

Implicit Conversions

"%s".format("aha!") // compiler starts looking...

// and REWRITES it to:

new RichString("%s").format("aha!")

Toast.makeText

Back to our Toast example

Java:

Toast.makeText(ctx, msg, Toast.LENGTH_SHORT).show()

Multiple parameter lists

def function(a: Int)(b: Int)

Multiple parameter lists

def add(a: Int): (Int) => Int = addStep2(a, _)
// add returns a function that takes an Int, and returns an Int

def addStep2(a: Int, b: Int) = a + b
// the final step, adding those numbers

// usage:
val part2 = add(2)(2)

def add(a: Int)(b: Int) = a + b

Implicit Values + Parameters

// IMPLICIT VALUE
implicit val ctx = getApplicationContext()

// IMPLICIT PARAMETER LIST
def example()(implicit ctx: Context) = "I have " + ctx

                example()(getApplicationContext)

                // or!

                implicit val ctx = getApplicationContext
                example()
              

trait Toasts

trait Toasts {

  implicit def charSeq2toastable(str: java.lang.CharSequence) =
    new Toastable(str.toString)

  class Toastable(msg: String) {

    import android.widget.Toast._

    def toast(implicit ctx: Context) {
      makeText(ctx, msg, LENGTH_LONG).show()
    }
  }
}

class MyActivity extends Activity with Toasts {
  implicit lazy val ctx = getApplicationContext

  def sayHello() { "Hello".toast }
}

Don't worry.

More pimpin' - Operators?

SomeTextView.setText("Hello World!")

SomeTextView := "Hello World!"

SomeTextView.:=("Hello World!")

More pimpin' - onClick

button.setOnClickListener(new OnClickListener() {
  public void onClick(View v) {
    // do things...
  }
});

import ListenerConversions._

button onClick { /* do things */ }

// even better:
val sendMessage = { /*...*/ }

button onClick sendMessage

Threading helpers

handler.post(new Runnable(){
  @Override
  void run() {
    /* ... */
  }
});

inFuture { /* ... */ }
inUiThread { /*...*/ }

inFuture(whenComplete = notifyUser) { /* long task...*/ }

inFutureWithProgressDialog  { /* long task...*/ }

Shared preferences

SharedPreferences sp = ctx.getSharedPreferences(key, 0);
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString("key", "value");
editor.commit();

AppSharedPreferences.someKey = "value"

Funny methods - part 2

def sharedPreferences(implicit ctx: Context) =
  ctx.getSharedPreferences(AppName, 0)

def workspaceName(implicit ctx: Context) =
  Option { sharedPreferences.getString(KeyWorkspaceName, null) }

def workspaceName_=(name: String)(implicit ctx: Context) {

  withSharedPreferencesEditor { _.putString(KeyWorkspaceName, name) }

}

What's Option?

optionalValue map { _.toast }

Passing around Intents

Intent intent = new Intent(this, A.class);
intent.putExtra("user_id", 1234);
intent.putExtra("data", new SomeData());
startActivity(intent);

public class A extends Activity {

@Override
public void onCreate(Bundle savedInstance) {
  super.onCreate(savedInstance);

  int userId = getIntent().getIntExtra("user_id");
  SomeData data = (SomeData) getIntent().getSerializableExtra("data");
}

"Intents" Pattern

Intents.Login.show()

public class A extends Activity {

@Override
public void onCreate(Bundle savedInstance) {
  super.onCreate(savedInstance);

  LoginData data = Intents.Login.getData(getIntent());
}

interface Intents {
  abstract class Login { /*...*/ }
  abstract class Messages { /*...*/ }

  // etc...
}

Pattern Matching and Extractors

if("Bob".equals(person.getName()) {
  String name = person.getName();
  String surname = person.getSurname();
  // do things...
} else {
  Log.d("You're not Bob!");
}

person match {
  case Person("Bob", surname) =>
    ("Bob's surname is: " + surname).toast
  case _ =>
    "You're not Bob!".toast
}

Roll your own Extractor

class Data(num: Int)

object Data { // that's called an "companion object"

  def apply(num: Int) = new Data(num)

  def unapply(i: Intent): Option[Data] =
    if (i.hasExtra("num"))
      Some(new Data(i.getIntExtra("num")))
    else
      None
}

Extracting our Data

val data = Data(1)
// is the same as:
val data2 = Data.apply(2)

data match {
  case Data(num) => assert { num == 1 }  // matches here! num = 1
  case _ => ???
}

data match {
  case Data(333) => ???
  case Data(1) => // matches here!
}

data match {
  case Something(a, b) =>
  case other => // matches here
}

SBT

SBT

• a fantastic shell
• it's not 5000 lines of XML (hello pom.xml!) - Build.scala
• hard to get into at first...
• the de facto standard build tool
• Type Safe!!!

Sbt ~test

> ~test

Tasks: Android:[tab]