Zzivi

Google Play Services Location API

Tue, 09 Jan 2018 15:00:00 +0000

To implement location awareness in your Android app Google supports two location strategies: android.location package and Google Play Services Location API. Google strongly advices developers to use the second approach.

In fairness Google has simplified the process greatly and claims following this approach improves battery performance in most cases. This makes sense as the Location Service is run as system process to which you subscribe. On the less bright side this approach depends on Google Play Services being installed in the phone.

So in order to implement this solution and make sure your app gracefully handles all possible combination of scenarios there are a few things you need to do.

Setup Google Play Services Location API
Verify Google Play Services is installed
Handle App Permissions
Implement Location Service

Setup Google Play Services Location API

Google Play Services comprises several services. To get the user current location and request location updates from your Android app you will need to include the play-services-location package.

In order to include this package in your app as a selective dependency of the Google Play Services you need to follow these steps:

If you haven't already done so, download and install Google Play Services from Android Studio's SDK Manager.
Include google() or maven { url "https://maven.google.com" } repository to top level build.gradle

Include play-services-location dependency to app level build.gradle

			compile 'com.google.android.gms:play-services-location:11.8.0'

Sync Gradle dependencies

Verify Google Play is installed

Your app should verify the required version of the Google Play Services APK is installed in the device. There are two strategies to perform this step:

Delegate the check on the service client object by passing an Activity at time on instatiation*

			//this must be an Activity
			FusedLocationClient client = LocationServices.getFusedLocationProviderClient(this);

Use the GoogleApiAvailibility singlenton service to manually check:

			public boolean checkPlayServices(final IcabbiActivity activity) {
		        GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance();
		        int resultCode = apiAvailability.isGooglePlayServicesAvailable(context);
		        if (resultCode != ConnectionResult.SUCCESS) {
		            if (apiAvailability.isUserResolvableError(resultCode)) {
		                Dialog playServicesErrorDialog = apiAvailability.getErrorDialog(activity, resultCode, PLAY_SERVICES_RESOLUTION_REQUEST);
		                playServicesErrorDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
		                    @Override
		                    public void onCancel(DialogInterface dialogInterface) {
		                        activity.finish();
		                    }
		                });
		                playServicesErrorDialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
		                    @Override
		                    public void onDismiss(DialogInterface dialog) {
		                    }
		                });
		                playServicesErrorDialog.show();
		            } else {
		                Timber.e(String.format("This device is not supported. Result code: %s", resultCode));
		                activity.finish();
		            }
		            return false;
		        }
		        return true;
		    }

Then in your activiy get the intent result

			@Override
		    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		        super.onActivityResult(requestCode, resultCode, data);
		        if (requestCode == PermissionHelper.PLAY_SERVICES_RESOLUTION_REQUEST) {
		            if (resultCode != ConnectionResult.SUCCESS) {
		                Timber.e(String.format("This device is not supported. Result code: %s", resultCode));
		                finish();
		            }
		        }
		    }

Handle App Permissions

Since Android M permission granting was moved from install time to runtime. This is good for the user and hell for the developer. There is no way around this one. Before accessing the device location you must cofirm you have permission to do so and fail gracefully if you don't.

I am currently using the Permision Dispatcher library to handle the permissions checks.

Implement Location Service

If you need to get location updates from you app you need to be aware that since Android O, if your app is running in the background the number of requests your app can make to the FusedLocationManager and the LocationsManager are restricted to a few every hour.*.

Every app is different. If you need to request frequent updates you can run your location service as a foreground service*.

References

android.location package

Mon, 08 Jan 2018 13:15:00 +0000

To get the user current location and request location updates from your Android app you could use the SDK embadded android.location package.

As these classes are part of the Android SDK there is no prior setup required and you don't need to add any dependencies to your gradle file.

Warning

Google strongly advises to stop using this API and migrate your apps to use Google Location Services APIs instead.

To learn the right way to do this checkout Google Location Services APIs Post

Location awareness using android.location package

You will need to get familiar with the classes:

LocationProvider
LocationManager
LocationListener

The plan is to attach a LocationListener to a LocationManager for a given LocationProvider (NETWORK_PROVIDER, GPS_PROVIDER,...) and listen for updates.

	String locationProvider = LocationManager.NETWORK_PROVIDER;
	locationManager.requestLocationUpdates(locationProvider, 0, 0, locationListener);

There are some considerations to keep in mind when using this approach like what provider to choose (i.e: GPS is more accurate but doesn't work indoors).

You also need to consider every how often your updates should happen and how accurate they should be. These decisions will have an impact on the battery life of the device your app is running on so you have to be careful.

References

Android Developer Tutorial on Location Strategies

A dynamic app without a server

Tue, 13 Dec 2016 00:00:00 +0000

Motivation

As a an App Developer it isn't uncommon to need to mock an API for a new project whose API hasn't been developed yet. You could also want to use one like the marvel ones used in many meetups that allows you to create a fully functional app without getting your hands dirty on the backend.

In this particular case I need an out of the box solution that allows me to easily model, document, test and mock a new API. These are a few of the solutions I found out there.

Option 1: Swagger

Swagger is sometimes incorrectly categorized as a modeling language, truly it is so much more. It uses OpenAPI specification which is both machine and human readible. It counts with massive adoption and community support.

Swagger is supported by most free/commercial options I researched so the definition written with these tools could be used to generate the server stubs on a second phase. The power of this solution lies in that it allows top-down approach where you would use the Swagger Editor to create your Swagger definition and then use the integrated Swagger Codegen tools to generate server implementation.

Option 2: Mockable.io

Mockable.io seems to be a good option for mocking an API when you need to develop a client without worrying too much about the backend. The console is easy to use, allows collaboration and seems to integrate with Swagger. They have free options and trials which is really nice.

Another cool feature is the template assistant that allows you to automate common tasks easily, i.e: Retrieve headers from the request, return dynamic responses, etc.

Option 3: Apiary

This to me looks like the best of both worlds, it supports API Blueprint and OpenAPI Modeling languages from an easy to use UI.

Here you have the convenience of controling the API from the Dashboard with easy access to Documentation, mocks, tests and even an editor that commits and pushes to your github repo. But if you decide to move on to the actual API implementation you can still reuse all the work done in this stage.

It integrates with Github meaning your API definition is versionated out of the box.

It integrates with Dredd a language agnostic API testing tool. Dredd integrates with most common Continuous Integration platforms: Travis CI, CircleCI, Jenkins, ... In terms this means that your tests can be used to test the actual implementation of the API still complies with the contract once it's implemented.

They offer free plan and trial on premium plan so you can try the product.

Benefits

As an app developer for me the most immediate benefit is to be able to concentrate on developing a fully functional client with minimum effort invested on the backend. However my backend developer background makes me appreciate the collateral benefits derived from this solution:

Debate over API model is encouraged from kickoff
A well modeled API is easier to maintain
The API specs are written from the consumers point of view
Backend developers can agree on the contract before a single line of code is implemented

Resources

Mockable.io Swagger.io Apiray.io Dredd

Generate Android APKs with Travis

Tue, 25 Aug 2015 00:00:00 +0000

Motivation

I wanted that every time that I commit a change in my Android repo a new APK is automatically generated and stored. Although I use Jenkins as my Continuous Integration server at work, I use Travis CI for this project. Travis CI launched Android Builds Support in Beta and I wanted to give them a chance :P

Building the project

Travis CI automatically detects when a commit has been made and pushed to a GitHub repository that is using Travis CI, and each time this happens, it will try to build the project and run tests. Following the instructions that Travis CI provides is very easy to setup your project and compile your code: Building an Android Project with Travis

Uploading the APK in GitHub Releases

Travis can upload the artifacts of your build in AWS S3. But I want to have the APK in the same place where a I have my code (I save a little of money too :P)

So I setup my yaml file to upload the APK to GitHub Releases every time that a new tag in Github is created. If you use Git Flow, it will create a tag automatically for each release. So you will have your APK ready to be published in Google Play.

language: android
script: ./gradlew build assembleRelease
android:
  components:
  - build-tools-20.0.0
  - android-19

deploy:
  - provider: releases
    api_key:
      <your key>
    file: app/build/outputs/apk/app-release.apk
    on:
      repo: Zzivi/Sodexo
      tags: true

notifications:
  email:
    recipients:
    - daniel.viorreta@zzivi.com
    - romina.liuzzi@zzivi.com
    on_success: always
    on_failure: always

Notice that I use ./gradlew build assembleRelease to avoid launching the Android emulator. The deploy section has the configuration to upload the apk only when a tag is created.

Android App using Travis
GitHub Releases Uploading with Travis

Migration from Perforce to Git

Mon, 24 Aug 2015 00:00:00 +0000

Motivation

After almost ten years using Perforce in our company I have decided to move to Git. You can find a lot of posts about the advantages of using Git over other version control system (VCS). In my opinion, the most important advantage is that Git is becoming the default VCS.

Git Fusion

Perforce launched a very nice tool called Git Fusion. With Git Fusion you can work with your Git client without knowing that there is a Perforce server behind it. When a Git user pushes a change in the repo, GitFusion translates those Git changes into Perforce changes and submits them to the Perforce depot. And when a Perforce user submits a change to the Perforce depot Git Fusion translates those changes to Git depot.

Git Fusion is a powerfull tool that allows you keep using Perforce through it. But, as I only used it to move to Git, I just set the configuration that I needed.

My Perforce server was an old machine in our datacenter with RedHat 4 and Git Fusion was only available from RedHat 5. So, I installed a new machine in Amazon Web Services with the rpms of Git Fusion.

Once GitFusion is configured, you will find a new Perforce user called git-fusion-user . A new Perforce depot in //.git-fusion will be automatically created too.

I set my user adding a new file in //.git-fusion/users/daniel.viorreta/keys/keymac with my ssh public key. Then, I created a file like this //.git-fusion/repos/myrepo/p4gf_config for each repo that I wanted to migrate. As I used peforce streams my file looks like this:

[@repo]
description = Repo for MyRepo

[master]
git-branch-name = master
stream = //myrepo/mainline
original-view = //myrepo/mainline/... ...

[myfeature]
git-branch-name = feature/myfeature
stream = //myrepo/myfeature
original-view = //myrepo/myfeature/... ...

To clone the Git repo you can do it like a normal Git repo with git clone:

git clone git@git.gitfusion.zzivi.com:myrepo

Notice that the first time that you clone the repo Git Fusion will translate all the changes to Git repo, so it can take several minutes or hours depending on the size of your repo.

GitHub

Once that I had Git Fusion running I wanted to move my Git repo to GitHub. So I cloned my Git Fusion repo with the bare option. After creating a new empty repo in GitHub, I pushed my changes to the new repo adding a new remote to my Git configuration:

git clone git@git.gitfusion.zzivi.com:myrepo --bare  #clone repo from Git Fusion
git remote add github git@github.com:zzivi/myrepo.git # add github remote
git push github --mirror # push changes to github

Finally I removed the write permissions in the Perforce depot and started the new challenge of using Git!!

Building an AAR Library in Android Studio

Sun, 31 May 2015 20:00:00 +0000

What is an ".aar" library?

The .aar bundle is the binary distribution of the Android Library Project. It is simply a zip file with at least the following entries at the root level:

/AndroidManifest.xml
/classes.jar
/res/
/R.txt

It might also include /assets/, /libs/, /jni/, /profguard.txt and /lint.jar.

Why use an .aar?

Often after building one or two applications you find common code you could like to pull out of your project and centralize in one location. You can then add the library to your project as a gradle dependency and make all changes only in one place rather than copy pasting bug fixes to several repos.

Once your library is all neat and ready you can share it with the community and spare some fellow developers the work you have just gone through.You can also benefit from community solutions by integrating third party libraries into your project.

In summary you use .aar libraries to:

Organize your code
Share your solutions with the community
Use other developers solutions

How to build an .aar?

It is not necessary, but I recommend having all your source code into a git repo. Library projects cannot be compiled to Android applications and started without another project using them, so for testing purposes I first created a project and then created a module.

Project: AppCore
Module Application: app
Module Library: apilibrary

Within Android Studio (v1 and above) right click on your Project structure and choose the option "new module".

Deleting old AMIs and snapshots

Wed, 20 May 2015 00:00:00 +0000

Deleting AMIs by date

When you are a heavy use of Amazon you can have a lot of Amazon Machine Images (AMIs). I have created a boto function to delete AMIs by date:

def delete_old_amis(awsAccount, vRetentionTime=68, vdryRun=False):

    ec2conn = boto.ec2.connect_to_region("eu-west-1", profile_name=awsAccount)
 
    images = ec2conn.get_all_images(owners=['self'])

    count = 0
    for image in images:
        creation_date = image.creationDate.split('T')[0].split('-')
        split_time = (date.today() - date(int(creation_date[0]), int(creation_date[1]), int(creation_date[2]))).days
        if split_time > vRetentionTime:
            print image.id+ " : is going to be deregistered"
            print "Split_time is : "+str(split_time)
            if vdryRun == True:
               image.deregister(delete_snapshot=True)
            count = count + 1
    print 'AMIs deleted: ' + str(count)

Deleting orphaned snapshots

When you create a new AMI, AWS creates a S3 snapshot of all of the instance’s EBS volumes. But when you delete an AMI the snapshots are left behind. I have created a boto function to delete snapshot not associated with an existing AMI:

def delete_orphan_snapshots(awsAccount, vdryRun=False):
    ec2conn = boto.ec2.connect_to_region("eu-west-1", profile_name=awsAccount)

    imageIds = []
    for image in ec2conn.get_all_images(owners=['self']):
        #print image.id, image.name + ", " + image.description
        #imageIds, imageNames = zip(*[(image.id, image.id)])
        imageIds.append(image.id)

    print 'Number of AMIs: '+str(len(imageIds))

    # Get list of snapshots and AMIs
    reAmi = re.compile('ami-[^ ]+')
    snapshots = []
    snapshotsToDelete = []
    snapshotsUnknown = []
    imageSnapshots = {}

    for snapshot in ec2conn.get_all_snapshots(owner='self'):
        # Get id and image ID via regex.
        snapshotId = snapshot.id
        snapshotImageId = reAmi.findall(snapshot.description)
        if len(snapshotImageId) != 1:
            snapshotsUnknown.append(snapshotId)
        else:
            snapshotImageId = snapshotImageId[0]
            
        # Update lists
        snapshots.append(snapshotId)
        #print 'snapshotImageId: '+str(snapshotImageId)
        if snapshotImageId not in imageIds:
            snapshotsToDelete.append(snapshotId)
        else:
            if snapshotImageId in imageSnapshots:
                imageSnapshots[snapshotImageId].append(snapshotId)
            else:
                imageSnapshots[snapshotImageId] = [snapshotId]
    
    print 'Number of orphaned snapshots to delete: '+str(len(snapshotsToDelete))
    print 'Number of mapped snapshots to keep: '+str(len(imageSnapshots))
    
    if vdryRun == True:
        for snapshot in snapshotsToDelete:
            print 'Removing ' + snapshot + '...'
            ec2conn.delete_snapshot(snapshot)

Reusing VPCs between stacks

Mon, 18 May 2015 00:00:00 +0000

Amazon VPCs lets create your own isolated section in AWS in your own virtual network.

The problem

I have only one VPC and its subnets created in my production environment. Then I have different stacks with my production services that use them. A new deployment of my application consists in deploying new stacks using the VPC deployed previously and delete the old stacks without modifying the VPC. The problem is how to identify the VPC where I want to deploy my new stacks without deploying a new VPC each time that I have a new version of my code. Similar for security groups and route53 private zones.

Tagging VPCs and subnets

To identify my VPC and my subnet I use a label to tag them. This is a part of a cloudformation where I tag the VPC and one of its subnets. Assume than we pass labelstack as a cloudformation parameter:

...
    "MyVPC" : {
      "Type" : "AWS::EC2::VPC",
      "Properties" : {
        "CidrBlock" : { "Ref" : "CIDRVPC" },
        "EnableDnsSupport" : "true",
        "EnableDnsHostnames" : "true",
        "Tags": [ {"Key" : "Name", "Value" : { "Ref" : "labelstack" }} ]
      }
    },
    "MySubnet1" : {
      "Type" : "AWS::EC2::Subnet",
      "Properties" : {
        "AvailabilityZone" : { "Ref" : "Subnet1AZ" },
        "CidrBlock" : { "Ref" : "CIDRSubnet1" },
        "VpcId" : { "Ref" : "MyVPC" },
        "Tags": [ {"Key" : "Name", "Value" : { "Fn::Join" : ["-", [ { "Ref" : "labelstack" }, "MySubnet1" ]]}} ]
      }
    },
...

Note that we can do something similar to security groups.

Getting VPCs, subnets and route53 zones by tag name

Then, via boto I can get the vpcs and subnet using the labelstack to identify them. Similar for security groups and route53 private zones.

This is the ‘api’ that our class will have to implement:

class IManageVpc:
    """ Class to manage vpcs and security groups reuse
    """
    def get_vpc(self, vpc_name):
        """ Get the vpc by name
        """
        raise NotImplementedError( "Should have implemented this" )

    def get_subnets_by_vpc_and_name(self, vpc, subnet_name):
        """ Get the subnet by vpc name and by subnet name
        """
        raise NotImplementedError( "Should have implemented this" ) 

    def get_security_groups_by_vpc_and_name(self, vpc, sg_name):
        """ Get the security group by vpc name and by security group name
        """
        raise NotImplementedError( "Should have implemented this" )

    def get_zone_by_vpc_and_name(self, vpc_id, zone_name):
        """ Get the zone by vpc and zone name
        """
        raise NotImplementedError( "Should have implemented this" )

And this is an implementation of it:

import boto.vpc
import boto.ec2
import boto.route53
import imanagevpc
import time


REGION='eu-west-1'

class ManageVpc(imanagevpc.IManageVpc):

    def __init__(self, ec2conn, profile_name):
        self.ec2conn = ec2conn
        self.profile_name = profile_name
        self.vpcconn = self.__connect_vpc()
        self.route53conn = self.connect_route53()

    def connect_vpc(self):
        region = boto.ec2.get_region(REGION)
        conn = boto.vpc.VPCConnection(region=region, profile_name=self.profile_name)
        return conn

    def connect_route53(self):
        conn = boto.route53.connect_to_region(REGION, profile_name=self.profile_name)
        return conn

    def filter_by_name(self, function, name):
        filters = {'tag:Name': name}
        return function(filters=filters)

    def filter_by_name_and_vpc(self, function, vpc, name):
        filters = {'vpc_id': vpc.id, 'tag:Name': name}
        return function(filters=filters)

    def get_vpc(self, vpc_name):
        for vpc in self.filter_by_name(self.vpcconn.get_all_vpcs, vpc_name):
            return vpc
        raise ValueError("A VPC for the given vpc name doesn't exist")

    def get_subnets_by_vpc_and_name(self, vpc, subnet_name):
        for subnet in self.filter_by_name_and_vpc(self.vpcconn.get_all_subnets, vpc, subnet_name):
            return subnet
        raise ValueError("A Subnet in the VPC doesn't exist")    

    def get_security_groups_by_vpc_and_name(self, vpc, sg_name):
        for security_group in self.filter_by_name_and_vpc(self.vpcconn.get_all_security_groups, vpc, sg_name):
            return security_group
        raise ValueError("A Segurity Group for the VPC doesn't exist")

    def get_zone_by_vpc_and_name(self, vpc_id, zone_name):
        for zone in self.route53conn.get_zones():
            if zone.name == zone_name:
                try:
                    if self.route53conn.get_hosted_zone(zone.id)['GetHostedZoneResponse']['VPCs']['VPC']['VPCId'] == vpc_id:
                        valueToReturn = {}
                        valueToReturn["zoneName"] = zone.name
                        valueToReturn["zoneId"] = zone.id
                        return valueToReturn
                except boto.route53.exception.DNSServerError as e:
                    print "Error getting route53 zones. Retrying it...:"
                    print e
                    time.sleep(20)

Now, each time that I deploy a new version on my application a pass the parameter whith the label where I want to attach the stacks.

Route53 and ELBs

Mon, 27 Apr 2015 00:00:00 +0000

Route53 is the DNS service offered by Amazon Web Services. Route53 is composed by hosted zones. Each hosted zone is a collection of resource records sets.

Alias Resource Record Sets

Alias resource record sets is a specific extension to standard DNS functionality provided by Route53. Instead of using standard CNAME entries, using Alias Resources is advantageous because:

Save time because Route53 automatically recognizes changes in the resource record sets that the alias resource record set refers to. If the IP address of the load balancer changes, Amazon Route 53 will automatically reflect those changes in DNS answers.
They are not counted as chargeable Route 53 requests so they are free.

Use Alias resources (instead of the usual CNAME entry) to point to resources as:

An Elastic Load Balancer
An Amazon S3 bucket that is configured as a static website
Another record in the same DNS zone with Amazon Route 53
An alternate domain name for a CloudFront distribution

In this example we set up an alias record set responding to an ELB:

  "myELB" : {
    "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
    "Properties" : {
      "AvailabilityZones" : [ "us-east-1a" ],
      "Listeners" : [ {
        "LoadBalancerPort" : "80",
        "InstancePort" : "80",
        "Protocol" : "HTTP"
      } ]
    }
  },
  "myDNS" : {
    "Type" : "AWS::Route53::RecordSetGroup",
      "Properties" : {
        "HostedZoneName" : "example.com.",
        "Comment" : "Zone apex alias targeted to myELB LoadBalancer.",
        "RecordSets" : [ {
          "Name" : "example.com.",
          "Type" : "A",
            "AliasTarget" : {
              "HostedZoneId" : { "Fn::GetAtt" : ["myELB", "CanonicalHostedZoneNameID"] },
              "DNSName" : { "Fn::GetAtt" : ["myELB","DNSName"] }
            }
          }
        ]
    }
  }

Private zones

A private hosted zone is a container that holds information about how you want to route traffic for a domain and its subdomains within one or more Amazon Virtual Private Clouds (Amazon VPCs). Typically we have to use internal ELBs together with private hosted zones to route traffic inside your VPC. To route traffic from internet then we have to use public hosted zones with public ELBs.

For example, imagine that we have one ELB responding to example1.com and another one responding to example2.com. There are requests from internet to both sites but because of dependencies between them we have to route internal traffic between them too. In that case we have to create two private zones for the VPC with two internal ELBs and two public zones with two public ELBs.

In this example we create an internal ELB, a private hosted zone and an alias record set for "example.com":

  "myELBPriv" : {
    "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
    "Properties" : {
      "AvailabilityZones" : [ "us-east-1a" ],
      "Scheme" : "internal",
      "Listeners" : [ {
        "LoadBalancerPort" : "80",
        "InstancePort" : "80",
        "Protocol" : "HTTP"
      } ]
    }
  },
  "DNS": {
    "Type": "AWS::Route53::HostedZone",
    "Properties": {
      "HostedZoneConfig": {
        "Comment": "My hosted zone for example.com"
      },
      "Name": "example.com",
      "VPCs": [{
        "VPCId": "vpc-abcd1234",
        "VPCRegion": "ap-northeast-1"
      }],
      "HostedZoneTags" : [{
        "Key": "SampleKey1",
        "Value": "SampleValue1"
      },
      {
        "Key": "SampleKey2",
        "Value": "SampleValue2"
      }]
    }
  },
  "myDNS" : {
    "Type" : "AWS::Route53::RecordSetGroup",
      "Properties" : {
        "HostedZoneId" : { "Fn::Join" : ["",[ "/hostedzone/", { "Ref" : "DNS"  } ]]},
        "Comment" : "Zone apex alias targeted to myELBPriv LoadBalancer.",
        "RecordSets" : [ {
          "Name" : "example.com.",
          "Type" : "A",
            "AliasTarget" : {
              "HostedZoneId" : { "Fn::GetAtt" : ["myELBPriv", "CanonicalHostedZoneNameID"] },
              "DNSName" : { "Fn::GetAtt" : ["myELBPriv","DNSName"] }
            }
          }
        ]
    }
  }

Useful links

Example of how to set Route53 manually step by step.

Amazon Route 53 Template Snippets.

SOA on to API, on to Microservices?

Fri, 13 Mar 2015 00:00:00 +0000

I also have a past: I gave technical assistance (and sometimes moral support) to Web Services clients. During this time I learned two very valuable lessons:

A contract is more serious than a marriage
Legacy services are like Chuck Norris, chances are they simply won't die

So I learned to develop, use, troubleshoot and live with these services.

By that time WS were far from trendy and not cool enough to be regarded as "vintage". Back then the world (read: google, fb, twitter) was taking about REST APIs and of course we dived in. I learned that with REST APIs it is all about the model and if is consistent your life is much easier.

Now I am an Android developer so I am both provider and consumer of these services.

A contract is still more serious than a marriage
It is more hurtful breaking your own client
Entity: To be or not be, with REST this truly is the question.

Microservices bells are ringing and I can only assume it will get messy before it gets fancy ;D. No pain, no gain.