by Chetan Padia at Londroid 25th April 2017

1. Launching Beeline with Firebase
25-04-2017

2. Who is this guy?
CTO at beeline.co
@chetbox

3. What is Beeline?
We make journeys
more enjoyable

4. What is Beeline?

5. What is Beeline?

6. The app

7. The app

8. When I joined
BOM almost finalised
iOS prototype (built by contractor)
Firmware prototype (built by Charlie)
⚡ Bluetooth proof-of-concept (Android)
First tech hire

9. The big
challenge
● 3 months
● Android and iOS
● Bluetooth Low Energy
● User accounts
● Data storage
● Analytics

10. User accounts

11. User accounts
Just use Firebase Authentication

12. Data storage Realm + S3 → ?

13. Data storage
Why Firebase Database?
● Hosted
● Automatic sync to server
● iOS and Android SDK
● Open-source UI libraries

14. Data storage
What’s different?
● NoSQL
● Security enforced by rules.json
● Realtime
● Reactive UI

15. rules.json
{
"rules": {
".read": "auth != null",
".write": "auth != null"
}
}

16. rules.json
{
"rules": {
"destinations": {
"$user_id": {
".validate": "newData.hasChildren(['latitude', 'longitude'])”,
".read": "auth != null && auth.uid == $user_id",
".write": "auth != null && auth.uid == $user_id",
".indexOn": [
"isFavourite"
],
"$id": {
"latitude": {
".validate": "newData.isNumber() && newData.val() >= -90 &&
newData.val() <= 90"
},
"longitude": {
".validate": "newData.isNumber() && newData.val() >= -180 &&
newData.val() <= 180"
},
"name": {
".validate": "newData.isString()"
}
...

17. Data storage
FIREBASE WARNING:
set at /destinations/abc/def failed:
permission_denied

18. rules.bolt
path /destinations/{user_id}/{id} {
latitude: Number;
longitude: Number;
name: String | Null;
}
path /destinations/{user_id} {
read() {auth && auth.uid == user_id}
write() {auth && auth.uid == user_id}
}

19. rules.bolt
path /destinations/{user_id}/{id}
is Destination;
type LatLon {
latitude: Number;
longitude: Number;
}
type Destination extends LatLon {
name: String | Null;
}

20. rules.bolt
type LatLon {
latitude: Number;
longitude: Number;
validate() {
latitude >= -90 &&
latitude <= 90 &&
longitude >= -180 &&
longitude <= 180
}
}

21. rules.bolt
path /destinations/{user_id} {
read() { isSignedInUser(user_id) }
write() { isSignedInUser(user_id) }
}
isSignedInUser(user_id) {
isSignedIn() && auth.uid === user_id
}
isSignedIn() {
auth != null
}

22. Test your rules!

23. Test your rules!
Targaryen is a former Great House of Westeros and
was the ruling royal House of the Seven Kingdoms
for three centuries, before it was deposed during
Robert's Rebellion and House Baratheon replaced it
as the new royal House. The few surviving
Targaryens fled into exile. Currently based in Essos,
House Targaryen seeks to retake the Seven
Kingdoms from House Lannister, who formally
replaced House Baratheon as the royal House
following the destruction of the Great Sept of Baelor.
http://gameofthrones.wikia.com/wiki/House_Targaryen

24. Test your rules!
targaryen = require 'targaryen'
rules = require 'rules.json'
describe 'Destinations', ->
beforeEach ->
targaryen.setFirebaseRules rules
targaryen.setFirebaseData
destinations:
queen:
buckingham_palace:
latitude: 51.5013021
longitude: -0.148308
it 'cannot be read publicly', ->
expect targaryen.users.unauthenticated
.cannotRead '/destinations'

25. Test your rules!
it 'can be read by owner', ->
expect uid: 'queen'
.canRead '/destinations/queen'
it 'cannot be read by others', ->
expect {}
.cannotRead '/destinations/queen'
expect uid: 'mayor'
.cannotRead '/destinations/queen'

26. Test your rules!
it 'can be created by owner', ->
expect uid: 'queen'
.canWrite '/destinations/queen/trafalgar_square',
latitude: 51.5069249
longitude: -0.1297893
it 'cannot be created by others', ->
[{}, uid: 'peasant']
.forEach (user) ->
expect user
.cannotWrite '/destinations/queen/trafalgar_square',
latitude: 51.5069249
longitude: -0.1297893

27. Test your rules!
it 'can be re-named by owner', ->
expect uid: 'queen'
.canWrite '/destinations/queen/buckingham_palace/name',
'Home'

28. Test your rules!
$ firebase-bolt rules.bolt
$ node node_modules/jasmine/bin/jasmine.js
// package.json
{
"scripts": {
"test": "..."
}
}
$ npm test

29. Test your rules!
language: node_js
node_js: "6"
before_script:
- npm install
script:
- npm test
- ./deploy

30. Automatic
deployment
#!/bin/bash
set -e
if [ "$TRAVIS_PULL_REQUEST" == "false" ] ; then
if [ "$TRAVIS_BRANCH" == "master" ] ; then
FIREBASE_PROJECT="my-staging-project"
fi
if [ "$TRAVIS_BRANCH" == "release" ] ; then
FIREBASE_PROJECT="my-production-project"
fi
fi
if [ -n "$FIREBASE_PROJECT" ] ; then
node "node_modules/firebase-tools/bin/firebase"
--project "$FIREBASE_PROJECT"
--token "$FIREBASE_TOKEN"
deploy
--message "$TRAVIS_COMMIT")
fi

31. Automatic
deployment
$ npm test
bolt: Generating rules.json...
Started
...............................................................
...............................................................
...............................................................
..........................
215 specs, 0 failures
Finished in 0.5 seconds
The command "npm test" exited with 0.
$ ./deploy
Deploying to 'master' beeline-test-e7288
=== Deploying to 'beeline-test-e7288'...
i deploying database, functions
✔ database: rules ready to deploy.
i starting release process (may take several minutes)...
✔ Deploy complete!

32. Migration

33. Upgrade your
anonymous
accounts
final Task<AuthResult> task;
if (user != null && user.isAnonymous()) {
task = user.linkWithCredential(credential);
} else {
task = FirebaseAuth.getInstance()
.signInWithCredential(credential);
}

34. Android
● Use Firebase Authentication
● Serialise to/from POJOs
● Reactive binding to UI

35. Android
- app
- src
- debug
- google-services.json
- release
- google-services.json

36. Android
package co.beeline.model;
// imports...
@AutoValue
@FirebaseValue
@IgnoreExtraProperties
public abstract class Destination {
@Nullable public abstract String name();
public abstract Double latitude();
public abstract Double longitude();
...
}

37. Android
public static Destination create(
String name,
Location location) {
return create(
name,
location.getLatitude(),
location.getLongitude());
}
public static Destination create(DataSnapshot snapshot) {
return snapshot.getValue(
AutoValue_Destination.FirebaseValue.class
).toAutoValue();
}

38. Sprinkle on
some RxJava
public static <T> Observable<T> fromTask(Task<T> task) {
return Observable.create(subscriber -> {
task.addOnCompleteListener(completeTask -> {
if (completeTask.isSuccessful()) {
subscriber.onNext(completeTask.getResult());
subscriber.onCompleted();
} else {
subscriber.onError(
completeTask.getException()
);
}
});
});
}

39. Sprinkle on
some RxJava
public static Observable<Void> save(DatabaseReference ref,
Object value) {
return fromTask(ref.setValue(value));
}
public static Observable<Void> update(DatabaseReference ref,
Map<String, Object> values) {
return fromTask(ref.updateChildren(values));
}
public static Observable<Void> delete(DatabaseReference ref) {
return fromTask(ref.setValue(null));
}

40. Sprinkle on
some RxJava
public static Observable<DataSnapshot> value(DatabaseReference ref) {
return Observable.create(subscriber -> {
final ValueEventListener listener = new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
subscriber.onNext(dataSnapshot);
}
@Override
public void onCancelled(DatabaseError databaseError) {
subscriber.onError(databaseError.toException());
}
};
ref.addValueEventListener(listener);
subscriber.add(Subscriptions.create(
() -> ref.removeEventListener(listener)
));
});
}

41. Sprinkle on
some RxJava
public static Observable<Void> save(
DatabaseReference ref,
Destination destination) {
return save(ref,
new AutoValue_Destination.FirebaseValue(destination));
}
public static Observable<Destination> get(
DatabaseReference ref) {
return value(ref).map(Destination::create);
}

42. Sprinkle on
some RxJava
FirebaseDatabase db = FirebaseDatabase.getInstance();
DatabaseReference dests = db.getReference("destinations");
save(dests.push(), Destination.create(location, “My Location”))
.subscribeOn(Schedulers.io())
.subscribe();

43. UI binding
public static abstract class RecyclerAdapter<VH extends
RecyclerView.ViewHolder> extends
FirebaseRecyclerAdapter<AutoValue_Destination.FirebaseValue, VH> {
public RecyclerAdapter(int modelLayout, Class<VH> viewHolderClass,
Query query) {
super(AutoValue_Destination.FirebaseValue.class, modelLayout,
viewHolderClass, query);
}
@Override
protected final void populateViewHolder(VH viewHolder,
AutoValue_Destination.FirebaseValue model, int position) {
populateViewHolder(viewHolder, model.toAutoValue(), position);
}
abstract protected void populateViewHolder(VH viewHolder,
Destination model, int position);
}

44. UI binding
public class DestinationsAdapter extends
Destination.RecyclerAdapter<DestinationViewHolder> {
public DestinationsAdapter(FirebaseDatabase db) {
super(
R.layout.destination,
DestinationViewHolder.class,
db.getReference(“destinations”));
}
@Override
protected void populateViewHolder(
DestinationViewHolder viewHolder,
Destination model,
int position) {
viewHolder.populate(model);
}
}

45. Caching and
offline support
FirebaseDatabase.getInstance()
.setPersistenceEnabled(true);
FirebaseDatabase.getInstance()
.getReference("destinations")
.keepSynced(true);

46. How did it go?
● Android + iOS
○ Worked in parallel
○ Integration/migration in a few weeks
○ Offline “just works” (but a bit slow)
● rules.json
○ A bit of a learning curve
○ No servers to manage
○ Querying the data is not straightforward

47. Querying
ref.orderBy("date")
.startAt("2017-04-16")
.endAt("2017-04-23")
ref.orderBy("date")
.equalTo("2017-04-24")
.limitToLast(1)

48. Aggregating
// index.js
const admin = require('firebase-admin');
const db = admin.database();
exports.all_destinations =
functions.database.ref('/destinations/{userId}/{id}')
.onWrite(event => {
return db.ref(`/all-destinations/${event.params.id}`)
.set(event.data.val());
});
exports.count_user_destinations =
functions.database.ref('/destinations/{userId}')
.onWrite(event => {
return db.ref(`/stats/user/${event.params.userId}/`)
.set({destinations: event.numChildren()});
});

49. Cloud function
security
const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp(Object.assign(
{databaseAuthVariableOverride: {
uid: "stats@cloudfunction.beeline.co"
},
functions.config().firebase
);
const db = admin.database();

50. Cloud function
security
path /stats/user/{user_id} {
read() { isSignedInUser(user_id) }
write() { isCloudFunction('stats') }
}
isCloudFunction(name) {
auth.uid === name + '@cloudfunction.beeline.co'
}

51. Cloud function
tests
● Use .val()
● Unit test your data logic
● Connect it up in index.js

52. Cloud function
tests
language: node_js
node_js: "6"
before_script:
- npm install
- (cd functions && npm install)
script:
- npm test
- (cd functions && npm test)
- ./deploy

53. Web dashboard

54. Web dashboard

55. Web dashboard

56. Web dashboard

57. Permissions for
special users
path /permissions/{user_id} {
change_permissions: PermissionGranted | Null;
internal_feature_1: PermissionGranted | Null;
beta_feature_1: PermissionGranted | Null;
write(){ userHasPermission('change_permissions') }
}
type PermissionGranted extends Boolean {
validate(){ this === true }
}
userHasPermission(permission) {
root.permissions[auth.uid][permission] === true
}

58. Automatically
save device
metadata
exports.ride_saveAppAndDeviceInfo =
functions.analytics.event('ride_started')
.onLog(event => {
const user = event.data.user;
const uid = user && user.userId;
const rideId = event.data.params && event.data.params.value;
if (uid && rideId) {
return db.ref(`/rides/${uid}/${rideId}`).update({
app_version: user.appInfo.appVersion,
phone_os: user.appInfo.appPlatform,
phone_os_version: user.deviceInfo.platformVersion,
phone_model: user.deviceInfo.mobileModelName,
phone_manufacturer: user.deviceInfo.mobileBrandName
});
}
});

59. What we like
so far
● Easy to set up
● Use as much as you like
● Realtime DB updates
● Minimal backend code
● Detailed docs

60. What we like
less so far
● A bit of a learning curve
● Lacking examples
● Limited querying
● Testing functions is slow
● Slow to load lots of data
● In flux

61. What’s next
● More in-depth stats
● Large data → Long term (cheaper)
storage
● Functions error logging
● Statically typed functions
● Emails/push for in-app events

62. Questions?
https://beeline.co
@chetbox